import { PROVIDER_SEARCH_PARAM } from 'constants/providerFactory.constants';

import { CrossWindowProvider } from 'lib/sdkWebWalletCrossWindowProvider';

import { LedgerIdleStateManager } from 'managers/internal/LedgerIdleStateManager/LedgerIdleStateManager';

import { getAddress } from 'methods/account/getAddress';

import { CrossWindowProviderStrategy } from 'providers/strategies/CrossWindowProviderStrategy';

import { ExtensionProviderStrategy } from 'providers/strategies/ExtensionProviderStrategy';

import { IframeProviderStrategy } from 'providers/strategies/IframeProviderStrategy';

import { LedgerProviderStrategy } from 'providers/strategies/LedgerProviderStrategy';

import {

WalletConnectProviderStrategy,

WalletConnectV2Error

} from 'providers/strategies/WalletConnectProviderStrategy';

import { setProviderType } from 'store/actions/loginInfo/loginInfoActions';

import { walletConnectConfigSelector } from 'store/selectors/configSelectors';

import { networkSelector } from 'store/selectors/networkSelectors';

import { getState } from 'store/store';

import { DappProvider } from './DappProvider/DappProvider';

import {

getAccountProvider,

setAccountProvider

} from './helpers/accountProvider';

import { clearInitiatedLogins } from './helpers/clearInitiatedLogins';

import { WebviewProviderStrategy } from './strategies/WebviewProviderStrategy';

import {

ICustomProvider,

IProvider,

IProviderFactory,

ProviderTypeEnum

} from './types/providerFactory.types';

export class ProviderFactory {

private static _customProviders: ICustomProvider[] = [];

public static set customProviders(providers: ICustomProvider[]) {

this._customProviders = providers;

}

public static get customProviders() {

return this._customProviders;

}

public static async create({

type,

anchor

}: IProviderFactory): Promise<DappProvider> {

let createdProvider: IProvider | null = null;

switch (type) {

case ProviderTypeEnum.extension: {

createdProvider = new ExtensionProviderStrategy();

break;

}

case ProviderTypeEnum.crossWindow: {

createdProvider = new CrossWindowProviderStrategy();

break;

}

case ProviderTypeEnum.ledger: {

createdProvider = new LedgerProviderStrategy({ anchor });

const ledgerIdleStateManager = LedgerIdleStateManager.getInstance();

await ledgerIdleStateManager.init();

break;

}

case ProviderTypeEnum.metamask: {

createdProvider = new IframeProviderStrategy();

break;

}

case ProviderTypeEnum.passkey: {

const network = networkSelector(getState());

createdProvider = new CrossWindowProviderStrategy({

walletAddress: `${network.walletAddress}?${PROVIDER_SEARCH_PARAM}=${ProviderTypeEnum.passkey}`

});

break;

}

case ProviderTypeEnum.walletConnect: {

const walletConnectConfig = walletConnectConfigSelector(getState());

if (!walletConnectConfig?.walletConnectV2ProjectId) {

throw new Error(WalletConnectV2Error.invalidConfig);

}

createdProvider = new WalletConnectProviderStrategy({

anchor,

...walletConnectConfig

});

break;

}

case ProviderTypeEnum.webview: {

createdProvider = new WebviewProviderStrategy();

break;

}

default: {

const address = getAddress();

for (const customProvider of this._customProviders) {

if (customProvider.type === type) {

createdProvider = await customProvider.constructor({

address,

anchor

});

}

}

break;

}

}

if (!createdProvider) {

throw new Error('Unable to create provider');

}

await createdProvider.init();

const dappProvider = new DappProvider(createdProvider);

setAccountProvider(dappProvider);

const shouldClearInitiatedLogins =

'provider' in createdProvider &&

createdProvider.provider instanceof CrossWindowProvider;

// Clear initiated logins and skip the login method if it's crossWindow or metamask

clearInitiatedLogins(

shouldClearInitiatedLogins

? { skipLoginMethod: ProviderTypeEnum.crossWindow }

: null

);

return dappProvider;

}

public static async destroy() {

const provider = getAccountProvider();

provider.cancelLogin();

setAccountProvider(null);

setProviderType(ProviderTypeEnum.none);

}

}