import QtQuick 2.15

import AppLayouts.Wallet.services.dapps 1.0
import AppLayouts.Wallet.services.dapps.plugins 1.0
import AppLayouts.Wallet.services.dapps.types 1.0
import AppLayouts.Wallet.stores 1.0 as WalletStore

import StatusQ.Core.Utils 0.1 as SQUtils

import shared.stores 1.0
import utils 1.0

import "./internal"

/// Component that provides the dapps integration for the wallet.
/// It provides the following features:
/// - WalletConnect integration
///     - WalletConnect pairing
///     - WalletConnect sessions management
///     - WalletConnect signing requests
///     - WalletConnect SIWE
///     - WalletConnect online status
/// - BrowserConnect integration
///     - BrowserConnect pairing
///     - BrowserConnect - access to persistent sessions
///     - BrowserConnect - access to persistent signing requests
///     - BrowserConnect signing requests
///     - BrowserConnect online status
SQUtils.QObject {
    id: root

    // SDKs providing the DApps API
    required property WalletConnectSDKBase wcSdk
    required property WalletConnectSDKBase bcSdk

    // DApps shared store - used for wc peristence and signing requests/transactions
    required property DAppsStore store
    required property CurrenciesStore currenciesStore

    // Required roles: address
    required property var accountsModel
    // Required roles: chainId, layer, isOnline
    required property var networksModel
    // Required roles: tokenKey, balances
    required property var groupedAccountAssetsModel

    readonly property alias requestsModel: requests
    readonly property alias dappsModel: dappConnections.dappsModel
    readonly property bool enabled: wcSdk.enabled || bcSdk.enabled
    readonly property bool isServiceOnline: chainsSupervisorPlugin.anyChainAvailable && (wcSdk.sdkReady || bcSdk.enabled)

    // Connection signals
    /// Emitted when a new DApp requests a connection
    signal connectDApp(var chains, string dAppUrl, string dAppName, string dAppIcon, int connectorId, string key)
    /// Emitted when a new DApp is connected
    signal dappConnected(string proposalId, string newTopic, string url, int connectorId)
    /// Emitted when a DApp is disconnected
    signal dappDisconnected(string topic, string url)
    /// Emitted when a new DApp fails to connect
    signal newConnectionFailed(string key, string dappUrl, var error)

    // Pairing signals
    signal pairingValidated(int validationState)
    signal pairingResponse(int state) // Maps to Pairing.errors

    // Sign request signals
    signal signCompleted(string topic, string id, bool userAccepted, string error)
    signal siweCompleted(string topic, string id, string error)

    /// WalletConnect pairing
    /// @param uri - the pairing URI to pair
    /// Result is emitted via the pairingResponse signal
    /// A new session proposal is expected to be emitted if the pairing is successful
    function pair(uri) {
        return wcSdk.pair(uri)
    }

    /// Approves or rejects the session proposal. App response to `connectDApp`
    /// @param key - the key of the session proposal
    /// @param approvedChainIds - array containing the chainIds that the user approved
    /// @param accountAddress - the address of the account that approved the session
    function approvePairSession(key, approvedChainIds, accountAddress) {
        if (siwePlugin.connectionRequests.has(key.toString())) {
            siwePlugin.accept(key, approvedChainIds, accountAddress)
            siwePlugin.connectionRequests.delete(key.toString())
            return
        }
        dappConnections.connect(key, approvedChainIds, accountAddress)
    }

    /// Rejects the session proposal. App response to `connectDApp`
    /// @param id - the id of the session proposal
    function rejectPairSession(id) {
        if (siwePlugin.connectionRequests.has(id.toString())) {
            siwePlugin.reject(id)
            siwePlugin.connectionRequests.delete(id.toString())
            return
        }
        dappConnections.reject(id)
    }

    /// Disconnects the WC session with the given topic. Expected `dappDisconnected` signal
    /// @param sessionTopic - the topic of the session to disconnect
    function disconnectSession(sessionTopic) {
        dappConnections.disconnect(sessionTopic)
    }

    /// Validates the pairing URI and emits the pairingValidated signal. Expected `pairingValidated` signal
    /// Async function
    /// @param uri - the pairing URI to validate
    function validatePairingUri(uri){
        const info = DAppsHelpers.extractInfoFromPairUri(uri)
        wcSdk.getActiveSessions((sessions) => {
            // Check if the URI is already paired
            let validationState = Pairing.errors.uriOk
            for (const key in sessions) {
                if (sessions[key].pairingTopic === info.topic) {
                    validationState = Pairing.errors.alreadyUsed
                    break
                }
            }

            // Check if expired
            if (validationState === Pairing.errors.uriOk) {
                const now = (new Date().getTime())/1000
                if (info.expiry < now) {
                    validationState = Pairing.errors.expired
                }
            }

            root.pairingValidated(validationState)
        });
    }

    /// Returns the DApp with the given topic
    /// @param topic - the topic of the DApp to return
    /// @return the DApp with the given topic
    /// DApp {
    ///    name: string
    ///    url: string
    ///    iconUrl: string
    ///    topic: string
    ///    connectorId: int
    ///    accountAddressses: [{address: string}]
    ///    chains: string
    ///    rawSessions: [{session: object}]
    /// }
    function getDApp(topic) {
        return SQUtils.ModelUtils.getFirstModelEntryIf(dappsModel, (dapp) => {
            return dapp.topic === topic
            SQUtils.ModelUtils.getFirstModelEntryIf(dapp.rawSessions, (session) => {
                return session.topic === topic
            })
        })
    }

    DAppConnectionsPlugin {
        id: dappConnections
        wcSDK: root.wcSdk
        bcSDK: root.bcSdk
        dappsStore: root.store
        accountsModel: root.accountsModel
        networksModel: root.networksModel

        onConnected: (proposalId, topic, url, connectorId) => {
            root.dappConnected(proposalId, topic, url, connectorId)
        }
        onDisconnected: (topic, url) => {
            root.dappDisconnected(topic, url)
        }
        onNewConnectionProposed: (key, chains, dAppUrl, dAppName, dAppIcon, connectorId) => {
            root.connectDApp(chains, dAppUrl, dAppName, dAppIcon, connectorId, key)
        }
        onNewConnectionFailed: (key, dappUrl, error) => {
            root.newConnectionFailed(key, dappUrl, error)
        }
    }

    SessionRequestsModel {
        id: requests
    }

    ChainsSupervisorPlugin {
        id: chainsSupervisorPlugin

        sdk: root.wcSdk
        networksModel: root.networksModel
    }

    Connections {
        target: root.wcSdk
        enabled: root.wcSdk.enabled

        function onPairResponse(ok) {
            root.pairingResponse(ok)
        }
    }

    SiweRequestPlugin {
        id: siwePlugin

        readonly property var connectionRequests: new Map()
        sdk: root.wcSdk
        store: root.store
        accountsModel: root.accountsModel
        networksModel: root.networksModel

        onRegisterSignRequest: (request) => {
            requests.enqueue(request)
        }

        onUnregisterSignRequest: (requestId) => {
            const request = requests.findById(requestId)
            if (request === null) {
                console.error("SiweRequestPlugin::onUnregisterSignRequest: Error finding event for requestId", requestId)
                return
            }
            requests.removeRequest(request.topic, requestId)
        }

        onConnectDApp: (chains, dAppUrl, dAppName, dAppIcon, key) => {
            siwePlugin.connectionRequests.set(key.toString(), {chains, dAppUrl, dAppName, dAppIcon})
            root.connectDApp(chains, dAppUrl, dAppName, dAppIcon, Constants.DAppConnectors.WalletConnect, key)
        }

        onSiweFailed: (id, error, topic) => {
            root.siweCompleted(topic, id, error)
        }

        onSiweSuccessful: (id, topic) => {
            d.lookupSession(topic, function(session) {
                // Persist session
                if(!root.store.addWalletConnectSession(JSON.stringify(session))) {
                    console.error("Failed to persist session")
                }

                root.siweCompleted(topic, id, "")
            })
        }

        function accept(key, approvedChainIds, accountAddress) {
            const approvedNamespaces = JSON.parse(
                DAppsHelpers.buildSupportedNamespaces(approvedChainIds,
                                                [accountAddress],
                                                SessionRequest.getSupportedMethods()))
            siwePlugin.connectionApproved(key, approvedNamespaces)
        }
        function reject(key) {
            siwePlugin.connectionRejected(key)
        }
    }

    SQUtils.QObject {
        id: d

        function lookupSession(topicToLookup, callback) {
            wcSdk.getActiveSessions((res) => {
                Object.keys(res).forEach((topic) => {
                    if (topic === topicToLookup) {
                        let session = res[topic]
                        callback(session)
                    }
                })
            })
        }
    }

    // The fees broker to handle all fees requests for all components and connections
    TransactionFeesBroker {
        id: feesBroker
        store: root.store
    }

    // bcSignRequestPlugin and wcSignRequestPlugin are used to handle sign requests
    // Almost identical, and it's worth extracting in an inline component, but Qt5.15.2 doesn't support it
    SignRequestPlugin {
        id: bcSignRequestPlugin

        sdk: root.bcSdk
        groupedAccountAssetsModel: root.groupedAccountAssetsModel
        networksModel: root.networksModel
        accountsModel: root.accountsModel
        store: root.store
        requests: root.requestsModel
        dappsModel: root.dappsModel
        feesBroker: feesBroker

        getFiatValue: (value, currency) => {
            return root.currenciesStore.getFiatValue(value, currency)
        }

        onSignCompleted: (topic, id, userAccepted, error) => {
            root.signCompleted(topic, id, userAccepted, error)
        }
    }

    SignRequestPlugin {
        id: wcSignRequestPlugin

        sdk: root.wcSdk
        groupedAccountAssetsModel: root.groupedAccountAssetsModel
        networksModel: root.networksModel
        accountsModel: root.accountsModel
        store: root.store
        requests: root.requestsModel
        dappsModel: root.dappsModel
        feesBroker: feesBroker

        getFiatValue: (value, currency) => {
            return root.currenciesStore.getFiatValue(value, currency)
        }

        onSignCompleted: (topic, id, userAccepted, error) => {
            root.signCompleted(topic, id, userAccepted, error)
        }
    }
}