import {
    AdapterState,
    isInBrowser,
    WalletReadyState,
    WalletSignMessageError,
    WalletDisconnectedError,
    WalletConnectionError,
    WalletSignTransactionError,
    WalletGetNetworkError,
    isInMobileBrowser,
    AddonAdapter,
    WalletError,
} from '@tronweb3/tronwallet-abstract-adapter';
import type {
    Transaction,
    SignedTransaction,
    AdapterName,
    BaseAdapterConfig,
    Network,
} from '@tronweb3/tronwallet-abstract-adapter';
import { getNetworkInfoByTronWeb } from '@tronweb3/tronwallet-adapter-tronlink';
import type { Tron, TronWeb } from '@tronweb3/tronwallet-adapter-tronlink';
import { supportTomowallet } from './utils.js';

declare global {
    interface Window {
        tomo_wallet?: {
            tron?: Tron | undefined;
        };
    }
}
export interface TomoWalletAdapterConfig extends BaseAdapterConfig {
    /**
     * The icon of your dapp. Used when open Tomo app in mobile device browsers.
     */
    dappIcon?: string;
    /**
     * The name of your dapp. Used when open Tomo app in mobile device browsers.
     */
    dappName?: string;
}

export const TomoWalletAdapterName = 'Tomo Wallet' as AdapterName<'Tomo Wallet'>;

export class TomoWalletAdapter extends AddonAdapter {
    name = TomoWalletAdapterName;
    url = 'https://tomo.inc/';
    icon =
        'data:image/svg+xml;base64,<svg version="1.2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 240 240" width="40" height="40">
	<title>favicon</title>
	<defs>
		<image  width="234" height="163" id="img1" href="data:image/png;base64,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"/>
	</defs>
	<style>
	</style>
	<use id="Background" href="#img1" x="3" y="31"/>
</svg>';

    config: Required<TomoWalletAdapterConfig>;
    private _readyState: WalletReadyState = isInBrowser() ? WalletReadyState.Loading : WalletReadyState.NotFound;
    private _state: AdapterState = AdapterState.Loading;
    private _connecting: boolean;
    private _wallet: Tron | null;
    private _address: string | null;

    constructor(config: TomoWalletAdapterConfig = {}) {
        super(config);
        const { checkTimeout = 3 * 1000, dappIcon = '', dappName = '' } = config;
        if (typeof checkTimeout !== 'number') {
            throw new Error('[TomoWalletAdapter] config.checkTimeout should be a number');
        }
        this.config = {
            ...this.commonConfig,
            checkTimeout,
            dappIcon,
            dappName,
        };
        this._connecting = false;
        this._wallet = null;
        this._address = null;

        if (!isInBrowser()) {
            this._readyState = WalletReadyState.NotFound;
            this.setState(AdapterState.NotFound);
            return;
        }
        if (isInMobileBrowser() && supportTomowallet()) {
            this._readyState = WalletReadyState.Found;
            this._updateWallet().then(() => {
                if (this.connected) {
                    this.emit('connect', this.address || '');
                }
            });
        } else {
            this._checkWallet().then(() => {
                if (this.connected) {
                    this.emit('connect', this.address || '');
                }
            });
        }
    }

    get address() {
        return this._address;
    }

    get state() {
        return this._state;
    }
    get readyState() {
        return this._readyState;
    }

    get connecting() {
        return this._connecting;
    }

    /**
     * Get network information used by Tomo.
     * @returns {Network} Current network information.
     */
    async network(): Promise<Network> {
        try {
            await this._checkWallet();
            if (this.state !== AdapterState.Connected) throw new WalletDisconnectedError();
            const tronWeb = this._wallet?.tronWeb;
            if (!tronWeb) throw new WalletDisconnectedError();
            try {
                return await getNetworkInfoByTronWeb(tronWeb);
            } catch (e: any) {
                throw new WalletGetNetworkError(e?.message, e);
            }
        } catch (e: any) {
            this.emit('error', e);
            throw e;
        }
    }

    async connect(): Promise<void> {
        try {
            if (!(await this._beforeConnect())) return;
            if (!this._wallet) return;
            this._connecting = true;
            if (supportTomowallet()) {
                const wallet = this._wallet;
                const res = await wallet.request({ method: 'eth_requestAccounts' });
                if (!res) {
                    // 1. wallet is locked
                    throw new WalletConnectionError('Tomo wallet is locked or no wallet account is avaliable.');
                }

                const address = (wallet.tronWeb && wallet.tronWeb.defaultAddress?.base58) || '';
                this.setAddress(address);
                this.setState(AdapterState.Connected);
            } else {
                throw new WalletConnectionError('Cannot connect wallet.');
            }
            this.connected && this.emit('connect', this.address || '');
        } catch (error: any) {
            const err = error instanceof WalletError ? error : new WalletConnectionError(error?.message, error);
            this.emit('error', err);
            throw err;
        } finally {
            this._connecting = false;
        }
    }

    async disconnect(): Promise<void> {
        if (this.state !== AdapterState.Connected) {
            return;
        }
        this.setAddress(null);
        this.setState(AdapterState.Disconnect);
        this.emit('disconnect');
    }

    async signTransaction(transaction: Transaction): Promise<SignedTransaction> {
        try {
            const wallet = await this.checkAndGetWallet();

            try {
                return await wallet.tronWeb.trx.sign(transaction);
            } catch (error: any) {
                if (error instanceof Error) {
                    throw new WalletSignTransactionError(error.message, error);
                } else {
                    throw new WalletSignTransactionError(error, new Error(error));
                }
            }
        } catch (error: any) {
            this.emit('error', error);
            throw error;
        }
    }

    async multiSign(transaction: Transaction, options: { permissionId?: number } = {}): Promise<SignedTransaction> {
        try {
            const wallet = await this.checkAndGetWallet();

            try {
                return await wallet.tronWeb.trx.multiSign(transaction, undefined, options.permissionId);
            } catch (error: any) {
                if (error instanceof Error) {
                    throw new WalletSignTransactionError(error.message, error);
                } else {
                    throw new WalletSignTransactionError(error, new Error(error));
                }
            }
        } catch (error: any) {
            this.emit('error', error);
            throw error;
        }
    }

    async signMessage(message: string): Promise<string> {
        try {
            const wallet = await this.checkAndGetWallet();
            try {
                return await wallet.tronWeb.trx.signMessageV2(message);
            } catch (error: any) {
                if (error instanceof Error) {
                    throw new WalletSignMessageError(error.message, error);
                } else {
                    throw new WalletSignMessageError(error, new Error(error));
                }
            }
        } catch (error: any) {
            this.emit('error', error);
            throw error;
        }
    }

    private async checkAndGetWallet() {
        await this._checkWallet();
        if (this.state !== AdapterState.Connected) throw new WalletDisconnectedError();
        const wallet = this._wallet;
        if (!wallet || !wallet.tronWeb) throw new WalletDisconnectedError();
        return wallet as Tron & { tronWeb: TronWeb };
    }

    private _checkPromise: Promise<boolean> | null = null;
    /**
     * check if wallet exists by interval, the promise only resolve when wallet detected or timeout
     * @returns if wallet exists
     */
    protected _checkWallet(): Promise<boolean> {
        if (this.readyState === WalletReadyState.Found) {
            return Promise.resolve(true);
        }
        if (this._checkPromise) {
            return this._checkPromise;
        }
        const interval = 100;
        const checkTronTimes = Math.floor(2000 / interval);
        const maxTimes = Math.floor(this.config.checkTimeout / interval);
        let times = 0,
            timer: ReturnType<typeof setInterval>;
        this._checkPromise = new Promise((resolve) => {
            const check = () => {
                times++;
                const isSupport = times < checkTronTimes && !!isInMobileBrowser() && supportTomowallet();
                if (isSupport || times > maxTimes) {
                    timer && clearInterval(timer);
                    this._readyState = isSupport ? WalletReadyState.Found : WalletReadyState.NotFound;
                    this._updateWallet();
                    this.emit('readyStateChanged', this.readyState);
                    resolve(isSupport);
                }
            };
            timer = setInterval(check, interval);
            check();
        });
        return this._checkPromise;
    }

    private listenToEvents() {
        this.stopEventListening();
        // @ts-ignore
        this._wallet?.on('accountsChanged', this.onAccountsChanged);
    }

    private stopEventListening() {
        if (this._wallet) {
            this._wallet.removeListener('accountsChanged', this.onAccountsChanged);
        }
    }

    private onAccountsChanged = (account: string) => {
        if (this._state === AdapterState.Disconnect) {
            return;
        }
        const preAddr = this.address || '';
        if (account !== preAddr) {
            this.setAddress(account);
            this.emit('accountsChanged', this.address || '', preAddr);
        }
        if (!preAddr && this.address) {
            this.emit('connect', this.address);
        } else if (preAddr && !this.address) {
            this.emit('disconnect');
        }
    };

    private _updateWallet = async () => {
        let state = this.state;
        let address = this.address;
        if (isInMobileBrowser()) {
            if (window.tomo_wallet?.tron) {
                this._wallet = window.tomo_wallet.tron;

                try {
                    await this.checkSecurity();
                } catch {
                    this.setAddress(null);
                    this.setState(AdapterState.Disconnect);
                    return;
                }
                this.listenToEvents();
            }
            address = (this._wallet?.tronWeb && this._wallet?.tronWeb?.defaultAddress?.base58) || null;
            state = address ? AdapterState.Connected : AdapterState.Disconnect;
        } else {
            console.error('[TomoWalletAdapter] Only supported in mobile app for now');
            this._wallet = null;
            address = null;
            state = AdapterState.NotFound;
        }
        // In Tomo Wallet App, account should be connected
        if (isInMobileBrowser() && state === AdapterState.Disconnect) {
            this.checkForWalletReadyForApp();
        }
        this.setAddress(address);
        this.setState(state);
    };

    private checkReadyInterval: ReturnType<typeof setInterval> | null = null;
    private checkForWalletReadyForApp() {
        if (this.checkReadyInterval) {
            return;
        }
        let times = 0;
        const maxTimes = Math.floor(this.config.checkTimeout / 200);
        const check = () => {
            if (window.tomo_wallet?.tron?.tronWeb && window.tomo_wallet?.tron?.tronWeb?.defaultAddress) {
                this.checkReadyInterval && clearInterval(this.checkReadyInterval);
                this.checkReadyInterval = null;
                this._updateWallet();
                this.emit('connect', this.address || '');
            } else if (times > maxTimes) {
                this.checkReadyInterval && clearInterval(this.checkReadyInterval);
                this.checkReadyInterval = null;
            } else {
                times++;
            }
        };
        this.checkReadyInterval = setInterval(check, 200);
    }
    private setAddress(address: string | null) {
        this._address = address;
    }

    private setState(state: AdapterState) {
        const preState = this.state;
        if (state !== preState) {
            this._state = state;
            this.emit('stateChanged', state);
        }
    }

    protected _openAppByDeepLinkIfNeed(): boolean {
        return false;
    }
}