import QtQuick 2.15
import QtQuick.Layouts 1.15
import QtQuick.Dialogs 1.3

import SortFilterProxyModel 0.2

import StatusQ.Components 0.1
import StatusQ.Controls 0.1
import StatusQ.Core 0.1
import StatusQ.Core.Theme 0.1
import StatusQ.Core.Utils 0.1 as StatusQUtils
import StatusQ.Layout 0.1

import shared.panels 1.0
import shared.popups 1.0
import shared.stores 1.0
import shared.views.chat 1.0
import utils 1.0

import AppLayouts.Communities.controls 1.0
import AppLayouts.Communities.panels 1.0
import AppLayouts.Communities.popups 1.0
import AppLayouts.Communities.helpers 1.0

StatusSectionLayout {
    id: root

    notificationCount: activityCenterStore.unreadNotificationsCount
    hasUnseenNotifications: activityCenterStore.hasUnseenNotifications
    onNotificationButtonClicked: Global.openActivityCenterPopup()

    property var rootStore
    property var chatCommunitySectionModule
    property var community
    property var transactionStore: TransactionStore {}
    property bool communitySettingsDisabled

    required property var walletAccountsModel // name, address, emoji, color

    readonly property bool isOwner: community.memberRole === Constants.memberRole.owner
    readonly property bool isAdmin: isOwner || community.memberRole === Constants.memberRole.admin
    readonly property bool isControlNode: community.isControlNode

    readonly property string filteredSelectedTags: {
        let tagsArray = []
        if (community && community.tags) {
            try {
                const json = JSON.parse(community.tags)

                if (!!json)
                    tagsArray = json.map(tag => tag.name)
            } catch (e) {
                console.warn("Error parsing community tags: ", community.tags,
                             " error: ", e.message)
            }
        }
        return JSON.stringify(tagsArray)
    }

    signal backToCommunityClicked

    backButtonName: stackLayout.children[d.currentIndex].previousPageName || ""

    //navigate to a specific section and subsection
    function goTo(section: int, subSection: int) {
        d.goTo(section, subSection)
    }

    onBackButtonClicked: stackLayout.children[d.currentIndex].navigateBack()

    leftPanel: Item {
        anchors.fill: parent

        ColumnLayout {
            anchors {
                top: parent.top
                bottom: backToCommunityButton.top
                bottomMargin: 12
                topMargin: Style.current.smallPadding
                horizontalCenter: parent.horizontalCenter
            }
            width: parent.width
            spacing: 32
            clip: true

            StatusChatInfoButton {
                id: communityHeader

                title: community.name
                subTitle: qsTr("%n member(s)", "", community.members.count || 0)
                asset.name: community.image
                asset.color: community.color
                asset.isImage: true
                Layout.fillWidth: true
                Layout.leftMargin: Style.current.halfPadding
                Layout.rightMargin: Style.current.halfPadding
                type: StatusChatInfoButton.Type.OneToOneChat
                hoverEnabled: false
            }

            StatusListView {
                id: listView

                Layout.fillWidth: true
                Layout.fillHeight: true
                Layout.leftMargin: Style.current.padding
                Layout.rightMargin: Style.current.padding
                model: stackLayout.children
                spacing: 8
                enabled: !root.communitySettingsDisabled

                delegate: StatusNavigationListItem {
                    objectName: "CommunitySettingsView_NavigationListItem_" + model.sectionName
                    width: ListView.view.width
                    title: model.sectionName
                    asset.name: model.sectionIcon
                    asset.height: 24
                    asset.width: 24
                    selected: d.currentIndex === index && !root.communitySettingsDisabled
                    onClicked: d.currentIndex = index
                    visible: model.sectionEnabled
                    height: visible ? implicitHeight : 0
                }
            }
        }

        StatusBaseText {
            id: backToCommunityButton
            objectName: "communitySettingsBackToCommunityButton"
            anchors {
                bottom: parent.bottom
                bottomMargin: 16
                horizontalCenter: parent.horizontalCenter
            }
            text: "<- " + qsTr("Back to community")
            color: Theme.palette.baseColor1
            font.pixelSize: 15
            font.underline: true

            MouseArea {
                anchors.fill: parent
                cursorShape: Qt.PointingHandCursor
                onClicked: root.backToCommunityClicked()
                hoverEnabled: true
            }
        }
    }

    centerPanel: StackLayout {
        id: stackLayout

        anchors.fill: parent

        currentIndex: d.currentIndex

        OverviewSettingsPanel {
            readonly property int sectionKey: Constants.CommunitySettingsSections.Overview
            readonly property string sectionName: qsTr("Overview")
            readonly property string sectionIcon: "show"
            readonly property bool sectionEnabled: true

            communityId: root.community.id
            name: root.community.name
            description: root.community.description
            introMessage: root.community.introMessage
            outroMessage: root.community.outroMessage
            logoImageData: root.community.image
            bannerImageData: root.community.bannerImageData
            color: root.community.color
            tags: root.rootStore.communityTags
            selectedTags: root.filteredSelectedTags
            archiveSupportEnabled: root.community.historyArchiveSupportEnabled
            archiveSupporVisible: root.community.isControlNode
            requestToJoinEnabled: root.community.access === Constants.communityChatOnRequestAccess
            pinMessagesEnabled: root.community.pinMessageAllMembersEnabled
            editable: true
            owned: root.community.memberRole === Constants.memberRole.owner
            loginType: root.rootStore.loginType
            isControlNode: root.isControlNode
            communitySettingsDisabled: root.communitySettingsDisabled
            overviewChartData: rootStore.overviewChartData

            onCollectCommunityMetricsMessagesCount: {
                rootStore.collectCommunityMetricsMessagesCount(intervals)
            }

            onEdited: {
                const error = root.chatCommunitySectionModule.editCommunity(
                                StatusQUtils.Utils.filterXSS(item.name),
                                StatusQUtils.Utils.filterXSS(item.description),
                                StatusQUtils.Utils.filterXSS(item.introMessage),
                                StatusQUtils.Utils.filterXSS(item.outroMessage),
                                item.options.requestToJoinEnabled ? Constants.communityChatOnRequestAccess
                                                                  : Constants.communityChatPublicAccess,
                                item.color.toString().toUpperCase(),
                                item.selectedTags,
                                Utils.getImageAndCropInfoJson(item.logoImagePath, item.logoCropRect),
                                Utils.getImageAndCropInfoJson(item.bannerPath, item.bannerCropRect),
                                item.options.archiveSupportEnabled,
                                item.options.pinMessagesEnabled
                                )
                if (error) {
                    errorDialog.text = error.error
                    errorDialog.open()
                }
            }

            onInviteNewPeopleClicked: {
                Global.openInviteFriendsToCommunityPopup(root.community,
                                                         root.chatCommunitySectionModule,
                                                         null)
            }

            onAirdropTokensClicked: root.goTo(Constants.CommunitySettingsSections.Airdrops)
            onExportControlNodeClicked: {
                if(!root.isControlNode)
                    return

                root.rootStore.authenticateWithCallback((authenticated) => {
                    if(!authenticated)
                        return

                    Global.openExportControlNodePopup(root.community.name, root.chatCommunitySectionModule.exportCommunity(root.community.id), (popup) => {
                        popup.onDeletePrivateKey.connect(() => {
                            root.rootStore.removePrivateKey(root.community.id)
                        })  
                    })
                })
            }

            onImportControlNodeClicked: {
                if(root.isControlNode)
                    return

                Global.openImportControlNodePopup(root.community, d.importControlNodePopupOpened)
            }
        }

        MembersSettingsPanel {
            readonly property int sectionKey: Constants.CommunitySettingsSections.Members
            readonly property string sectionName: qsTr("Members")
            readonly property string sectionIcon: "group-chat"
            readonly property bool sectionEnabled: true

            rootStore: root.rootStore
            membersModel: root.community.members
            bannedMembersModel: root.community.bannedMembers
            pendingMemberRequestsModel: root.community.pendingMemberRequests
            declinedMemberRequestsModel: root.community.declinedMemberRequests
            editable: root.isAdmin
            communityName: root.community.name

            onKickUserClicked: root.rootStore.removeUserFromCommunity(id)
            onBanUserClicked: root.rootStore.banUserFromCommunity(id)
            onUnbanUserClicked: root.rootStore.unbanUserFromCommunity(id)
            onAcceptRequestToJoin: root.rootStore.acceptRequestToJoinCommunity(id, root.community.id)
            onDeclineRequestToJoin: root.rootStore.declineRequestToJoinCommunity(id, root.community.id)
        }

        PermissionsSettingsPanel {
            readonly property int sectionKey: Constants.CommunitySettingsSections.Permissions
            readonly property string sectionName: qsTr("Permissions")
            readonly property string sectionIcon: "objects"
            readonly property bool sectionEnabled: true

            readonly property PermissionsStore permissionsStore:
                rootStore.permissionsStore

            permissionsModel: permissionsStore.permissionsModel

            // temporary solution to provide icons for assets, similar
            // method is used in wallet (constructing filename from asset's
            // symbol) and is intended to be replaced by more robust
            // solution soon.

            assetsModel: rootStore.assetsModel
            collectiblesModel: rootStore.collectiblesModel
            channelsModel: rootStore.chatCommunitySectionModule.model

            communityDetails: d.communityDetails

            onCreatePermissionRequested:
                permissionsStore.createPermission(holdings, permissionType,
                                                  isPrivate, channels)

            onUpdatePermissionRequested:
                permissionsStore.editPermission(
                    key, holdings, permissionType, channels, isPrivate)

            onRemovePermissionRequested:
                permissionsStore.removePermission(key)

            onNavigateToMintTokenSettings: {
                root.goTo(Constants.CommunitySettingsSections.MintTokens)
                mintPanel.openNewTokenForm(isAssetType)
            }
        }

        MintTokensSettingsPanel {
            id: mintPanel

            readonly property int sectionKey: Constants.CommunitySettingsSections.MintTokens
            readonly property string sectionName: qsTr("Tokens")
            readonly property string sectionIcon: "token"
            readonly property bool sectionEnabled: root.isOwner

            readonly property CommunityTokensStore communityTokensStore:
                rootStore.communityTokensStore

            function setFeesInfo(ethCurrency, fiatCurrency, errorCode) {
                if (errorCode === Constants.ComputeFeeErrorCode.Success
                        || errorCode === Constants.ComputeFeeErrorCode.Balance) {

                    const valueStr = LocaleUtils.currencyAmountToLocaleString(ethCurrency)
                        + "(" + LocaleUtils.currencyAmountToLocaleString(fiatCurrency) + ")"
                    mintPanel.feeText = valueStr

                    if (errorCode === Constants.ComputeFeeErrorCode.Balance)
                        mintPanel.feeErrorText = qsTr("Not enough funds to make transaction")

                    mintPanel.isFeeLoading = false

                    return
                } else if (errorCode === Constants.ComputeFeeErrorCode.Infura) {
                    mintPanel.feeErrorText = qsTr("Infura error")
                    mintPanel.isFeeLoading = true
                    return
                }
                mintPanel.feeErrorText = qsTr("Unknown error")
                mintPanel.isFeeLoading = true
            }

            // General community props
            communityName: root.community.name
            communityLogo: root.community.image
            communityColor: root.community.color

            // User profile props
            isOwner: root.isOwner
            isAdmin: root.isAdmin
            isTokenMasterOwner: false // TODO: Backend

            // Owner and TMaster properties
            isOwnerTokenDeployed: tokensModelChangesTracker.isOwnerTokenDeployed
            isTMasterTokenDeployed: tokensModelChangesTracker.isTMasterTokenDeployed
            anyPrivilegedTokenFailed: tokensModelChangesTracker.isOwnerTokenFailed || tokensModelChangesTracker.isTMasterTokenFailed

            // Models
            tokensModel: root.community.communityTokens
            tokensModelWallet: root.rootStore.tokensModelWallet
            layer1Networks: communityTokensStore.layer1Networks
            layer2Networks: communityTokensStore.layer2Networks
            enabledNetworks: communityTokensStore.enabledNetworks
            allNetworks: communityTokensStore.allNetworks
            accounts: root.walletAccountsModel

            onDeployFeesRequested: {
                feeText = ""
                feeErrorText = ""
                isFeeLoading = true

                communityTokensStore.computeDeployFee(
                    chainId, accountAddress, tokenType, !(mintPanel.isOwnerTokenDeployed && mintPanel.isTMasterTokenDeployed))
            }

            onBurnFeesRequested: {
                feeText = ""
                feeErrorText = ""
                isFeeLoading = true

                communityTokensStore.computeBurnFee(tokenKey, amount, accountAddress)
            }

            onMintCollectible:
                communityTokensStore.deployCollectible(
                    root.community.id, collectibleItem)

            onMintAsset:
                communityTokensStore.deployAsset(root.community.id, assetItem)

            onMintOwnerToken:
                communityTokensStore.deployOwnerToken(
                    root.community.id, ownerToken, tMasterToken)

            onRemotelyDestructFeesRequest:
                communityTokensStore.computeSelfDestructFee(
                    remotelyDestructTokensList, tokenKey, accountAddress)

            onRemotelyDestructCollectibles:
                communityTokensStore.remoteSelfDestructCollectibles(
                    root.community.id, remotelyDestructTokensList, tokenKey, accountAddress)

            onSignBurnTransactionOpened:
                communityTokensStore.computeBurnFee(tokenKey, amount, accountAddress)

            onBurnToken:
                communityTokensStore.burnToken(root.community.id, tokenKey, amount, accountAddress)

            onDeleteToken:
                communityTokensStore.deleteToken(root.community.id, tokenKey)

            onAirdropToken: {
                root.goTo(Constants.CommunitySettingsSections.Airdrops)

                // Force a token selection to be airdroped with default amount 1
                airdropPanel.selectToken(tokenKey, 1, type)

                // Set given addresses as recipients
                airdropPanel.addAddresses(addresses)
            }
        }

        AirdropsSettingsPanel {
            id: airdropPanel

            readonly property int sectionKey: Constants.CommunitySettingsSections.Airdrops
            readonly property string sectionName: qsTr("Airdrops")
            readonly property string sectionIcon: "airdrop"
            readonly property bool sectionEnabled: root.isOwner

            communityDetails: d.communityDetails

            // Profile type
            isOwner: root.isOwner
            isTokenMasterOwner: false // TODO: Backend
            isAdmin: root.isAdmin

            // Owner and TMaster properties
            isOwnerTokenDeployed: tokensModelChangesTracker.isOwnerTokenDeployed
            isTMasterTokenDeployed: tokensModelChangesTracker.isTMasterTokenDeployed

            readonly property CommunityTokensStore communityTokensStore:
                rootStore.communityTokensStore

            readonly property var communityTokens: root.community.communityTokens

            Loader {
                id: assetsModelLoader
                active: airdropPanel.communityTokens

                sourceComponent: SortFilterProxyModel {

                    sourceModel: airdropPanel.communityTokens
                    filters: ValueFilter {
                        roleName: "tokenType"
                        value: Constants.TokenType.ERC20
                    }
                    proxyRoles: [
                        ExpressionRole {
                            name: "category"

                            // Singleton cannot be used directly in the expression
                            readonly property int category: TokenCategories.Category.Own
                            expression: category
                        },
                        ExpressionRole {
                            name: "iconSource"
                            expression: model.image
                        },
                        ExpressionRole {
                            name: "key"
                            expression: model.symbol
                        },
                        ExpressionRole {
                            name: "communityId"
                            expression: ""
                        }
                    ]
                }
            }

            Loader {
                id: collectiblesModelLoader
                active: airdropPanel.communityTokens

                sourceComponent: SortFilterProxyModel {

                    sourceModel: airdropPanel.communityTokens
                    filters: ValueFilter {
                        roleName: "tokenType"
                        value: Constants.TokenType.ERC721
                    }
                    proxyRoles: [
                        ExpressionRole {
                            name: "category"

                            // Singleton cannot be used directly in the epression
                            readonly property int category: TokenCategories.Category.Own
                            expression: category
                        },
                        ExpressionRole {
                            name: "iconSource"
                            expression: model.image
                        },
                        ExpressionRole {
                            name: "key"
                            expression: model.symbol
                        },
                        ExpressionRole {
                            name: "communityId"
                            expression: ""
                        }
                    ]
                }
            }

            assetsModel: assetsModelLoader.item
            collectiblesModel: collectiblesModelLoader.item
            membersModel: community.members

            accountsModel: root.walletAccountsModel

            onAirdropClicked: communityTokensStore.airdrop(
                                  root.community.id, airdropTokens, addresses,
                                  feeAccountAddress)

            onNavigateToMintTokenSettings: {
                root.goTo(Constants.CommunitySettingsSections.MintTokens)
                mintPanel.openNewTokenForm(isAssetType)
            }

            onAirdropFeesRequested:
                communityTokensStore.computeAirdropFee(
                    root.community.id, contractKeysAndAmounts, addresses,
                    feeAccountAddress)
        }
    }

    QtObject {
        id: d

        property int currentIndex: 0

        readonly property QtObject communityDetails: QtObject {
            readonly property string id: root.community.id
            readonly property string name: root.community.name
            readonly property string image: root.community.image
            readonly property string color: root.community.color
            readonly property bool owner: root.community.memberRole === Constants.memberRole.owner
            readonly property bool admin: root.community.memberRole === Constants.memberRole.admin
        }

        function goTo(section: int, subSection: int) {
            const stackContent = stackLayout.children

            for (let i = 0; stackContent.length; i++) {
                const item = stackContent[i]

                if (item.sectionKey === section) {
                    d.currentIndex = i

                    if(item.goTo)
                        item.goTo(subSection)

                    break
                }
            }
        }

        function requestCommunityInfoWithCallback(privateKey, callback) {
            if(!callback) return

            //success
            root.rootStore.communityAdded.connect(function communityAddedHandler(communityId) {
                root.rootStore.communityAdded.disconnect(communityAddedHandler)
                let community = null
                try {
                    const communityJson = root.rootStore.getSectionByIdJson(communityId)
                    community = JSON.parse(communityJson)
                } catch (e) {
                    console.warn("Error parsing community json: ", communityJson, " error: ", e.message)
                }

                callback(community)
            })

            //error
            root.rootStore.importingCommunityStateChanged.connect(function communityImportingStateChangedHandler(communityId, status) {
                root.rootStore.importingCommunityStateChanged.disconnect(communityImportingStateChangedHandler)
                if(status === Constants.communityImportingError) {
                    callback(null)
                }
            })

            root.rootStore.requestCommunityInfo(privateKey, false)
        }

        function importControlNodePopupOpened(popup) {
            popup.requestCommunityInfo.connect((privateKey) => {
                requestCommunityInfoWithCallback(privateKey, popup.setCommunityInfo)
            })

            popup.importControlNode.connect((privateKey) => {
                root.rootStore.importCommunity(privateKey)
            })
        }
    }

    StatusQUtils.ModelChangeTracker {
        id: tokensModelChangesTracker

        // Owner and TMaster token deployment states
        property bool isOwnerTokenDeployed: false
        property bool isTMasterTokenDeployed: false
        property bool isOwnerTokenFailed: false
        property bool isTMasterTokenFailed: false

        // It will monitorize if Owner and/or TMaster token items are included in the `model` despite the deployment state
        property bool ownerOrTMasterTokenItemsExist: false

        function checkIfPrivilegedTokenItemsExist() {
           return StatusQUtils.ModelUtils.contains(model, "privilegesLevel", Constants.TokenPrivilegesLevel.Owner) ||
                  StatusQUtils.ModelUtils.contains(model, "privilegesLevel", Constants.TokenPrivilegesLevel.TMaster)
        }

        function reviewTokenDeployState(isOwner, deployState) {
            const privileges = isOwner ? Constants.TokenPrivilegesLevel.Owner : Constants.TokenPrivilegesLevel.TMaster
            const index = StatusQUtils.ModelUtils.indexOf(model, "privilegesLevel", privileges)
            if(index === -1)
                return false

            const token = StatusQUtils.ModelUtils.get(model, index)
            // Some assertions:
            if(isOwner && token.privilegesLevel !== Constants.TokenPrivilegesLevel.Owner)
                return false
            if(!isOwner && token.privilegesLevel !== Constants.TokenPrivilegesLevel.TMaster)
                return false

            // Deploy state check:
            return token.deployState === deployState
        }

        model: root.community.communityTokens

        onRevisionChanged: {
            // It will update property to know if Owner and TMaster token items have been added into the tokens list.
            ownerOrTMasterTokenItemsExist = checkIfPrivilegedTokenItemsExist()
            if(!ownerOrTMasterTokenItemsExist)
                return

            // It monitors the deployment:
            if(!isOwnerTokenDeployed) {
                isOwnerTokenDeployed = reviewTokenDeployState(true, Constants.ContractTransactionStatus.Completed)
                isOwnerTokenFailed = reviewTokenDeployState(true, Constants.ContractTransactionStatus.Failed)
            }

            if(!isTMasterTokenDeployed) {
                isTMasterTokenDeployed = reviewTokenDeployState(false, Constants.ContractTransactionStatus.Completed)
                isTMasterTokenFailed = reviewTokenDeployState(false, Constants.ContractTransactionStatus.Failed)
            }

            // Not necessary to track more changes since privileged tokens have been correctly deployed.
            if(isOwnerTokenDeployed && isTMasterTokenDeployed)
                tokensModelChangesTracker.enabled = false
        }
    }

    MessageDialog {
        id: errorDialog

        title: qsTr("Error editing the community")
        icon: StandardIcon.Critical
        standardButtons: StandardButton.Ok
    }

    Component {
        id: transferOwnershipPopup

        TransferOwnershipPopup {
            anchors.centerIn: parent
            store: root.rootStore
            onClosed: destroy()
        }
    }

    Component {
        id: noPermissionsPopupCmp

        NoPermissionsToJoinPopup {
            onRejectButtonClicked: {
                root.rootStore.declineRequestToJoinCommunity(requestId, communityId)
                close()
            }
            onClosed: destroy()
        }
    }


    Connections {
        target: rootStore.communityTokensStore

        function onDeployFeeUpdated(ethCurrency, fiatCurrency, errorCode) {
            mintPanel.setFeesInfo(ethCurrency, fiatCurrency, errorCode)
        }

        function onSelfDestructFeeUpdated(ethCurrency, fiatCurrency, errorCode) {
            mintPanel.setFeesInfo(ethCurrency, fiatCurrency, errorCode)
        }

        function onBurnFeeUpdated(ethCurrency, fiatCurrency, errorCode) {
            mintPanel.setFeesInfo(ethCurrency, fiatCurrency, errorCode)
        }

        function onAirdropFeeUpdated(airdropFees) {
            airdropPanel.airdropFees = airdropFees
        }

        function onRemoteDestructStateChanged(communityId, tokenName, status, url) {
            if (root.community.id !== communityId)
                return

            let title = ""
            let loading = false
            let type = Constants.ephemeralNotificationType.normal

            switch (status) {
            case Constants.ContractTransactionStatus.InProgress:
                title = qsTr("Remotely destroying tokens...")
                loading = true
                break
            case Constants.ContractTransactionStatus.Completed:
                title = qsTr("%1 tokens destroyed").arg(tokenName)
                type = Constants.ephemeralNotificationType.success
                break
            case Constants.ContractTransactionStatus.Failed:
                title = qsTr("%1 tokens destruction failed").arg(tokenName)
                break
            default:
                console.warn("Unknown destruction state: "+status)
                return
            }

            Global.displayToastMessage(title, qsTr("View on etherscan"), "",
                                       loading, type, url)
        }

        function onAirdropStateChanged(communityId, tokenName, chainName,
                                       status, url) {
            if (root.community.id !== communityId)
                return

            let title = ""
            let loading = false
            let type = Constants.ephemeralNotificationType.normal

            switch (status) {
            case Constants.ContractTransactionStatus.InProgress:
                title = qsTr("Airdrop on %1 in progress...").arg(chainName)
                loading = true
                break
            case Constants.ContractTransactionStatus.Completed:
                title = qsTr("Airdrop on %1 in complete").arg(chainName)
                type = Constants.ephemeralNotificationType.success
                break
            case Constants.ContractTransactionStatus.Failed:
                title = qsTr("Airdrop on %1 failed").arg(chainName)
                break
            default:
                console.warn("Unknown airdrop state: "+status)
                return
            }

            Global.displayToastMessage(title, qsTr("View on etherscan"), "",
                                       loading, type, url)
        }

        function onBurnStateChanged(communityId, tokenName, status, url) {
            if (root.community.id !== communityId)
                return

            let title = ""
            let loading = false
            let type = Constants.ephemeralNotificationType.normal

            switch (status) {
            case Constants.ContractTransactionStatus.InProgress:
                title = qsTr("%1 being burned...").arg(tokenName)
                loading = true
                break
            case Constants.ContractTransactionStatus.Completed:
                title = qsTr("%1 burning is complete").arg(tokenName)
                type = Constants.ephemeralNotificationType.success
                break
            case Constants.ContractTransactionStatus.Failed:
                title = qsTr("%1 burning is failed").arg(tokenName)
                break
            default:
                console.warn("Unknown burning state: "+status)
                return
            }

            Global.displayToastMessage(title, qsTr("View on etherscan"), "",
                                       loading, type, url)
        }

        function onDeploymentStateChanged(communityId, status, url) {
            if (root.community.id !== communityId)
                return

            let title = ""
            let loading = false
            let type = Constants.ephemeralNotificationType.normal

            switch (status) {
            case Constants.ContractTransactionStatus.InProgress:
                title = qsTr("Token is being minted...")
                loading = true
                break
            case Constants.ContractTransactionStatus.Completed:
                title = qsTr("Token minting finished")
                type = Constants.ephemeralNotificationType.success
                break
            case Constants.ContractTransactionStatus.Failed:
                title = qsTr("Token minting failed")
                break
            default:
                console.warn("Unknown deploy state: "+status)
                return
            }

            Global.displayToastMessage(title, url === "" ? qsTr("Something went wrong") : qsTr("View on etherscan"), "",
                                       loading, type, url)
        }

        function onOwnerTokenDeploymentStateChanged(communityId, status, url) {
            if (root.community.id !== communityId)
                return

            if (status === Constants.ContractTransactionStatus.Completed)
            {
                let title1 = qsTr("%1 Owner and TokenMaster tokens minting complete").arg(community.name)
                let title2 = qsTr("%1 Owner token airdropped to you").arg(community.name)
                let title3 = qsTr("%1 Owner and TokenMaster permissions created").arg(community.name)
                let type = Constants.ephemeralNotificationType.normal

                Global.displayToastMessage(title1, url, "", true, type, url)
                Global.displayToastMessage(title2, url, "", true, type, url)
                Global.displayToastMessage(title3, url, "", true, type, url)
            } else if (status === Constants.ContractTransactionStatus.Failed) {
                let title = qsTr("%1 Owner and TokenMaster tokens minting failed").arg(community.name)
                let type = Constants.ephemeralNotificationType.normal
                Global.displayToastMessage(title, url, "", true, type, url)
            }
        }

        function onOwnerTokenDeploymentStarted(communityId, url) {
            if (root.community.id !== communityId)
                return

            let title1 = qsTr("%1 Owner and TokenMaster tokens are being minted...").arg(community.name)
            let title2 = qsTr("Airdropping %1 Owner token to you...").arg(community.name)
            let type = Constants.ephemeralNotificationType.normal

            Global.displayToastMessage(title1, url, "", true, type, url)
            Global.displayToastMessage(title2, url, "", true, type, url)
        }
    }

    Connections {
        target: root.chatCommunitySectionModule

        function onOpenNoPermissionsToJoinPopup(communityName: string,
                                                userName: string, communityId:
                                                string, requestId: string) {
            const properties = {
                communityName: communityName,
                userName: userName,
                communityId: communityId,
                requestId: requestId
            }

            Global.openPopup(noPermissionsPopupCmp, properties)
        }
    }
}