/*
 * Copyright (c) 2022 @automata-network/wallet-sdk authors and contributors.
 * This software may be modified and distributed under the terms of UNLICENSED
 * license. Refer to the LICENSE file for details.
 */
// import coinbaseWalletModule from '@web3-onboard/coinbase'
import * as solanaWallets from '@solana/wallet-adapter-wallets'
import enrkypt from '@web3-onboard/enkrypt'
import fortmaticModule from '@web3-onboard/fortmatic'
import gnosisModule from '@web3-onboard/gnosis'
import ledgerModule from '@web3-onboard/ledger'
import mewWallet from '@web3-onboard/mew-wallet'
import portisModule from '@web3-onboard/portis'
import torusModule from '@web3-onboard/torus'
import trezorModule from '@web3-onboard/trezor'
import walletConnectModule from '@web3-onboard/walletconnect'

import {
  EVMProviderConfigs,
  EVMProviderGetters,
  PolkadotExtensionModule,
  PolkadotExtensionModuleGetters,
  PolkadotProviderConfigs,
  SolanaProviderConfigs,
  SolanaWalletAdapterGetters
} from '../interfaces'
import enkryptPolkadot from './polkadot/enkrypt'
import { injectedExtension } from './polkadot/injected-wallet'
import polkadotJSExtension from './polkadot/polkadot-extension'
import subwalletPolkadot from './polkadot/subwallet'
import tailsmanPolkadot from './polkadot/talisman'

function getLedgerProvider({ ledger }: EVMProviderConfigs) {
  if (ledger) {
    return ledgerModule(ledger)
  }
}

function getTrezorProvider({ trezor }: EVMProviderConfigs) {
  if (trezor) {
    return trezorModule(trezor)
  }
}

// function getCoinbaseProvider({ coinbase }: EVMProviderConfigs) {
//   if (coinbase) {
//     console.log(coinbaseWalletModule(coinbase))
//     return coinbaseWalletModule(coinbase)
//   }
// }

function getWalletConnectProvider({ walletconnect }: EVMProviderConfigs) {
  if (walletconnect) {
    return walletConnectModule(walletconnect)
  }
}

function getGnosisProvider({ gnosis }: EVMProviderConfigs) {
  if (gnosis) {
    return gnosisModule(
      gnosis.whitelistedDomains ? { whitelistedDomains: gnosis.whitelistedDomains } : undefined
    )
  }
}

function getFortmaticProvider({ fortmatic }: EVMProviderConfigs) {
  if (fortmatic) {
    return fortmaticModule(fortmatic)
  }
}

function getPortisProvider({ portis }: EVMProviderConfigs) {
  if (portis) {
    return portisModule(portis)
  }
}

function getTorusProvider({ torus }: EVMProviderConfigs) {
  if (torus) {
    return torusModule(torus)
  }
}

function getEnkryptProvider({ enkrypt }: EVMProviderConfigs) {
  if (enkrypt) {
    return enrkypt()
  }
}

function getMewWalletProvider({ mew }: EVMProviderConfigs) {
  if (mew) {
    return mewWallet()
  }
}

export const evmProviderGetters: EVMProviderGetters = {
  ledger: getLedgerProvider,
  trezor: getTrezorProvider,
  // coinbase: getCoinbaseProvider,
  walletconnect: getWalletConnectProvider,
  gnosis: getGnosisProvider,
  fortmatic: getFortmaticProvider,
  portis: getPortisProvider,
  torus: getTorusProvider,
  enkrypt: getEnkryptProvider,
  mew: getMewWalletProvider
}

function getEnkryptPolkadotExtensionModule({ enkrypt }: PolkadotProviderConfigs) {
  if (enkrypt) {
    return enkryptPolkadot()
  }
}

function getPolkadotJsExtensionExtensionModule({ polkadotJsExtension }: PolkadotProviderConfigs) {
  if (polkadotJsExtension) {
    return polkadotJSExtension()
  }
}

function getSubwalletPolkadotExtensionModule({ subwallet }: PolkadotProviderConfigs) {
  if (subwallet) {
    return subwalletPolkadot()
  }
}

function getTalismanPolkadotExtensionModule({ talisman }: PolkadotProviderConfigs) {
  if (talisman) {
    return tailsmanPolkadot()
  }
}

export const polkadotExtensionModuleGetters: PolkadotExtensionModuleGetters = {
  polkadotJsExtension: getPolkadotJsExtensionExtensionModule,
  enkrypt: getEnkryptPolkadotExtensionModule,
  subwallet: getSubwalletPolkadotExtensionModule,
  talisman: getTalismanPolkadotExtensionModule
}

export function getInjectedExtensionModule(extensionModules: PolkadotExtensionModule[]) {
  const isExtensionModuleEnabled = extensionModules.map((item) => item.isEnabled())
  const firstEnableExtensionIndex = isExtensionModuleEnabled.findIndex((item) => item === true)

  if (firstEnableExtensionIndex !== -1) {
    const newExtensionModules = [...extensionModules]

    newExtensionModules.splice(firstEnableExtensionIndex, 1)
    newExtensionModules.unshift(extensionModules[firstEnableExtensionIndex])

    return newExtensionModules
  }

  const injectedExtensionModule = injectedExtension()

  return injectedExtensionModule ? [injectedExtensionModule, ...extensionModules] : extensionModules
}

function getSolanaWalletconnectWalletAdapter({ walletconnect }: SolanaProviderConfigs) {
  if (walletconnect) {
    return new solanaWallets.WalletConnectWalletAdapter(walletconnect)
  }
}

function getSolanaLedgerWalletAdapter({ ledger }: SolanaProviderConfigs) {
  if (ledger) {
    return new solanaWallets.LedgerWalletAdapter(ledger)
  }
}

function getSolanaSolflareWalletAdapter({ solflare }: SolanaProviderConfigs) {
  if (solflare) {
    return new solanaWallets.SolflareWalletAdapter(solflare)
  }
}

function getSolanaSolletWalletAdapter({ sollet }: SolanaProviderConfigs) {
  if (sollet) {
    return new solanaWallets.SolletWalletAdapter(sollet)
  }
}

function getSolanaTorusWalletAdapter({ torus }: SolanaProviderConfigs) {
  if (torus) {
    return new solanaWallets.TorusWalletAdapter(torus)
  }
}

function getSolanaBloctoWalletAdapter({ blocto }: SolanaProviderConfigs) {
  if (blocto) {
    return new solanaWallets.BloctoWalletAdapter(blocto)
  }
}

function getSolanaPhantomWalletAdapter({ phantom }: SolanaProviderConfigs) {
  if (phantom) {
    return new solanaWallets.PhantomWalletAdapter(phantom)
  }
}

function getSolanaBackpackWalletAdapter({ backpack }: SolanaProviderConfigs) {
  if (backpack) {
    return new solanaWallets.BackpackWalletAdapter(backpack)
  }
}

function getSolanaNightlyWalletAdapter({ nightly }: SolanaProviderConfigs) {
  if (nightly) {
    return new solanaWallets.NightlyWalletAdapter()
  }
}

function getSolanaCloverWalletAdapter({ clover }: SolanaProviderConfigs) {
  if (clover) {
    return new solanaWallets.CloverWalletAdapter(clover)
  }
}

function getSolanaCoin98WalletAdapter({ coin98 }: SolanaProviderConfigs) {
  if (coin98) {
    return new solanaWallets.Coin98WalletAdapter(coin98)
  }
}

function getSolanaSlopeWalletAdapter({ slope }: SolanaProviderConfigs) {
  if (slope) {
    return new solanaWallets.SlopeWalletAdapter(slope)
  }
}

function getSolanaSolongWalletAdapter({ solong }: SolanaProviderConfigs) {
  if (solong) {
    return new solanaWallets.SolongWalletAdapter(solong)
  }
}

function getSolanaExodusWalletAdapter({ exodus }: SolanaProviderConfigs) {
  if (exodus) {
    return new solanaWallets.ExodusWalletAdapter(exodus)
  }
}

function getSolanaMathWalletAdapter({ math }: SolanaProviderConfigs) {
  if (math) {
    return new solanaWallets.MathWalletAdapter(math)
  }
}

export const solanaWalletAdapterGetters: SolanaWalletAdapterGetters = {
  walletconnect: getSolanaWalletconnectWalletAdapter,
  ledger: getSolanaLedgerWalletAdapter,
  solflare: getSolanaSolflareWalletAdapter,
  sollet: getSolanaSolletWalletAdapter,
  torus: getSolanaTorusWalletAdapter,
  blocto: getSolanaBloctoWalletAdapter,
  phantom: getSolanaPhantomWalletAdapter,
  backpack: getSolanaBackpackWalletAdapter,
  nightly: getSolanaNightlyWalletAdapter,
  clover: getSolanaCloverWalletAdapter,
  coin98: getSolanaCoin98WalletAdapter,
  slope: getSolanaSlopeWalletAdapter,
  solong: getSolanaSolongWalletAdapter,
  exodus: getSolanaExodusWalletAdapter,
  math: getSolanaMathWalletAdapter
}