import type { EventEmitter, SendTransactionOptions, WalletName } from '@solana/wallet-adapter-base';
import {
    BaseMessageSignerWalletAdapter,
    scopePollingDetectionStrategy,
    WalletAccountError,
    WalletConnectionError,
    WalletDisconnectedError,
    WalletDisconnectionError,
    WalletError,
    WalletNotConnectedError,
    WalletNotReadyError,
    WalletPublicKeyError,
    WalletReadyState,
    WalletSendTransactionError,
    WalletSignMessageError,
    WalletSignTransactionError,
} from '@solana/wallet-adapter-base';
import type { Connection, SendOptions, Transaction, TransactionSignature } from '@solana/web3.js';
import { PublicKey } from '@solana/web3.js';

interface SkyWalletEvents {
    connect(...args: unknown[]): unknown;
    disconnect(...args: unknown[]): unknown;
}

interface SkyWallet extends EventEmitter<SkyWalletEvents> {
    isSkyWallet?: boolean;
    publicKey?: { toBytes(): Uint8Array };
    isConnected: boolean;
    signTransaction(transaction: Transaction): Promise<Transaction>;
    signAllTransactions(transactions: Transaction[]): Promise<Transaction[]>;
    signAndSendTransaction(
        transaction: Transaction,
        options?: SendOptions
    ): Promise<{ signature: TransactionSignature }>;
    signMessage(message: Uint8Array): Promise<{ signature: Uint8Array }>;
    connect(): Promise<void>;
    disconnect(): Promise<void>;
}

interface SkyWalletWindow extends Window {
    skySolana?: SkyWallet;
}

declare const window: SkyWalletWindow;

export interface SkyWalletAdapterConfig {}

export const SkyWalletName = 'SKY Wallet' as WalletName<'SKY Wallet'>;

export class SkyWalletAdapter extends BaseMessageSignerWalletAdapter {
    name = SkyWalletName;
    url = 'https://getsky.app';
    icon =
        'data:image/svg+xml;base64,<svg version="1.2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 66 66" width="64" height="64"><defs><image  width="64" height="64" id="img1" href="data:image/png;base64,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"/></defs><style></style><use  href="#img1" x="1" y="1"/></svg>';
    readonly supportedTransactionVersions = null;

    private _connecting: boolean;
    private _wallet: SkyWallet | null;
    private _publicKey: PublicKey | null;
    private _readyState: WalletReadyState =
        typeof window === 'undefined' || typeof document === 'undefined'
            ? WalletReadyState.Unsupported
            : WalletReadyState.NotDetected;

    constructor(config: SkyWalletAdapterConfig = {}) {
        super();
        this._connecting = false;
        this._wallet = null;
        this._publicKey = null;

        if (this._readyState !== WalletReadyState.Unsupported) {
            scopePollingDetectionStrategy(() => {
                if (window.skySolana?.isSkyWallet) {
                    this._readyState = WalletReadyState.Installed;
                    this.emit('readyStateChange', this._readyState);
                    return true;
                }
                return false;
            });
        }
    }

    get publicKey() {
        return this._publicKey;
    }

    get connecting() {
        return this._connecting;
    }

    get connected() {
        return !!this._wallet?.isConnected;
    }

    get readyState() {
        return this._readyState;
    }

    async connect(): Promise<void> {
        try {
            if (this.connected || this.connecting) return;
            if (this._readyState !== WalletReadyState.Installed) throw new WalletNotReadyError();

            this._connecting = true;

            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
            const wallet = window.skySolana!;
            try {
                await wallet.connect();
            } catch (error: any) {
                throw new WalletConnectionError(error?.message, error);
            }

            if (!wallet.publicKey) throw new WalletAccountError();

            let publicKey: PublicKey;
            try {
                publicKey = new PublicKey(wallet.publicKey.toBytes());
            } catch (error: any) {
                throw new WalletPublicKeyError(error?.message, error);
            }

            wallet.on('disconnect', this._disconnected);

            this._wallet = wallet;
            this._publicKey = publicKey;

            this.emit('connect', publicKey);
        } catch (error: any) {
            this.emit('error', error);
            throw error;
        } finally {
            this._connecting = false;
        }
    }

    async disconnect(): Promise<void> {
        const wallet = this._wallet;
        if (wallet) {
            wallet.off('disconnect', this._disconnected);

            this._wallet = null;
            this._publicKey = null;

            try {
                await wallet.disconnect();
            } catch (error: any) {
                this.emit('error', new WalletDisconnectionError(error?.message, error));
            }
        }

        this.emit('disconnect');
    }

    async sendTransaction(
        transaction: Transaction,
        connection: Connection,
        options: SendTransactionOptions = {}
    ): Promise<TransactionSignature> {
        try {
            const wallet = this._wallet;
            if (!wallet) throw new WalletNotConnectedError();

            try {
                const { signers, ...sendOptions } = options;

                transaction = await this.prepareTransaction(transaction, connection, sendOptions);

                signers?.length && transaction.partialSign(...signers);

                sendOptions.preflightCommitment = sendOptions.preflightCommitment || connection.commitment;

                const { signature } = await wallet.signAndSendTransaction(transaction, sendOptions);
                return signature;
            } catch (error: any) {
                if (error instanceof WalletError) throw error;
                throw new WalletSendTransactionError(error?.message, error);
            }
        } catch (error: any) {
            this.emit('error', error);
            throw error;
        }
    }

    async signTransaction<T extends Transaction>(transaction: T): Promise<T> {
        try {
            const wallet = this._wallet;
            if (!wallet) throw new WalletNotConnectedError();

            try {
                return ((await wallet.signTransaction(transaction)) as T) || transaction;
            } catch (error: any) {
                throw new WalletSignTransactionError(error?.message, error);
            }
        } catch (error: any) {
            this.emit('error', error);
            throw error;
        }
    }

    async signAllTransactions<T extends Transaction>(transactions: T[]): Promise<T[]> {
        try {
            const wallet = this._wallet;
            if (!wallet) throw new WalletNotConnectedError();

            try {
                return ((await wallet.signAllTransactions(transactions)) as T[]) || transactions;
            } catch (error: any) {
                throw new WalletSignTransactionError(error?.message, error);
            }
        } catch (error: any) {
            this.emit('error', error);
            throw error;
        }
    }

    async signMessage(message: Uint8Array): Promise<Uint8Array> {
        try {
            const wallet = this._wallet;
            if (!wallet) throw new WalletNotConnectedError();

            try {
                const { signature } = await wallet.signMessage(message);
                return signature;
            } catch (error: any) {
                throw new WalletSignMessageError(error?.message, error);
            }
        } catch (error: any) {
            this.emit('error', error);
            throw error;
        }
    }

    private _disconnected = () => {
        const wallet = this._wallet;
        if (wallet) {
            wallet.off('disconnect', this._disconnected);

            this._wallet = null;
            this._publicKey = null;

            this.emit('error', new WalletDisconnectedError());
            this.emit('disconnect');
        }
    };
}