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

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

interface NekoWallet extends EventEmitter<NekoWalletEvents> {
    isNeko?: boolean;
    publicKey?: { toBytes(): Uint8Array };
    isConnected: boolean;
    signTransaction(transaction: Transaction): Promise<Transaction>;
    signAllTransactions(transactions: Transaction[]): Promise<Transaction[]>;
    signMessage(message: Uint8Array): Promise<{ signature: Uint8Array }>;
    connect(): Promise<void>;
    disconnect(): Promise<void>;
}

interface NekoWalletWindow extends Window {
    neko?: NekoWallet;
}

declare const window: NekoWalletWindow;

export interface NekoWalletAdapterConfig {}

export const NekoWalletName = 'Neko' as WalletName<'Neko'>;

export class NekoWalletAdapter extends BaseMessageSignerWalletAdapter {
    name = NekoWalletName;
    url = 'https://nekowallet.com';
    icon =
        'data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="244px" height="260px" viewBox="0 0 244 260" enable-background="new 0 0 244 260" xml:space="preserve">  <image id="image0" width="244" height="260" x="0" y="0"
    href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAPQAAAEECAMAAAAoFOlhAAAABGdBTUEAALGPC/xhBQAAACBjSFJN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" />
</svg>
';
    readonly supportedTransactionVersions = null;

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

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

        if (this._readyState !== WalletReadyState.Unsupported) {
            scopePollingDetectionStrategy(() => {
                if (window.neko?.isNeko) {
                    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.neko!;

            if (!wallet.isConnected) {
                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 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');
        }
    };
}