import { Cluster, Transaction } from '@solana/web3.js';
import {
  PromiseCallback,
  SalmonWallet,
  SalmonConfig,
  SalmonWindow,
} from './types';
import EventEmitter from 'eventemitter3';
import WalletAdapter from './adapters/base';
import WebAdapter from './adapters/web';
import ExtensionAdapter from './adapters/extension';

export { SalmonWallet, SalmonConfig } from './types';

declare const window: SalmonWindow;

export default class Salmon extends EventEmitter {
  private _network: Cluster = 'mainnet-beta';
  private _provider: string | SalmonWallet;
  private _adapterInstance: WalletAdapter | null = null;
  private _connectHandler: { resolve: PromiseCallback, reject: PromiseCallback } | null = null;

  constructor (config?: SalmonConfig) {
    super();

    if (config?.network) {
      this._network = config?.network;
    }

    if (config?.provider) {
      this._provider = config?.provider;
    } else if (window.salmon) {
      this._provider = window.salmon;
    } else {
      this._provider = 'https://app.salmonwallet.io';
    }
  }

  get publicKey () {
    return this._adapterInstance?.publicKey || null;
  }

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

  get connected () {
    return this.isConnected;
  }

  get autoApprove () {
    return false;
  }

  async connect () {
    if (this.connected) {
      return;
    }

    if (typeof this._provider === 'string') {
      this._adapterInstance = new WebAdapter(this._provider, this._network);
    } else {
      this._adapterInstance = new ExtensionAdapter(this._provider, this._network);
    }
    this._adapterInstance.on('connect', this._connected);
    this._adapterInstance.on('disconnect', this._disconnected);
    this._adapterInstance.connect();

    await new Promise((resolve, reject) => {
      this._connectHandler = { resolve, reject };
    });
  }

  async disconnect () {
    if (!this._adapterInstance) {
      return;
    }

    await this._adapterInstance.disconnect();
  }

  async signTransaction (transaction: Transaction): Promise<Transaction> {
    if (!this.connected) {
      throw new Error('Wallet not connected');
    }

    return await this._adapterInstance!.signTransaction(transaction);
  }

  async signAllTransactions (transactions: Transaction[]): Promise<Transaction[]> {
    if (!this.connected) {
      throw new Error('Wallet not connected');
    }

    return await this._adapterInstance!.signAllTransactions(transactions);
  }

  async signMessage (data: Uint8Array, display: 'hex' | 'utf8' = 'utf8'): Promise<Uint8Array> {
    if (!this.connected) {
      throw new Error('Wallet not connected');
    }

    return await this._adapterInstance!.signMessage(data, display);
  }

  async sign (data: Uint8Array, display: 'hex' | 'utf8' = 'utf8'): Promise<Uint8Array> {
    return await this.signMessage(data, display);
  }

  private _connected = () => {
    if (this._connectHandler) {
      this._connectHandler.resolve();
      this._connectHandler = null;
    }

    this.emit('connect', this.publicKey);
  };

  private _disconnected = () => {
    if (this._connectHandler) {
      this._connectHandler.reject();
      this._connectHandler = null;
    }

    this._adapterInstance = null;

    this.emit('disconnect');
  };
}