import type { Signer } from '@irys/bundles';
import type BigNumber from 'bignumber.js';
import Crypto from 'crypto';
import type Irys from './irys';
import type {
  IrysTransaction as IIrysTransaction,
  IrysTransactionCreateOptions,
  IrysTransactonCtor,
  UploadOptions,
  UploadReceipt,
  UploadResponse,
} from './types';

/**
 * Extended DataItem that allows for seamless Irys operations, such as signing and uploading.
 * Takes the same parameters as a regular DataItem.
 */

export default function buildIrysTransaction(
  irys: Pick<Irys, 'uploader' | 'tokenConfig' | 'bundles' | 'utils'>
): IrysTransactonCtor {
  class IrysTransaction
    extends irys.bundles.DataItem
    implements IIrysTransaction
  {
    public Irys: Pick<Irys, 'uploader' | 'tokenConfig' | 'bundles' | 'utils'>;
    public signer: Signer;

    constructor(
      data: string | Uint8Array,
      irys: Pick<Irys, 'uploader' | 'tokenConfig' | 'bundles' | 'utils'>,
      opts?: IrysTransactionCreateOptions
    ) {
      super(
        opts?.dataIsRawTransaction === true
          ? Buffer.from(data)
          : irys.bundles
              .createData(data, irys.tokenConfig.getSigner(), {
                ...opts,
                anchor:
                  opts?.anchor ??
                  Crypto.randomBytes(32).toString('base64').slice(0, 32),
              })
              .getRaw()
      );
      this.Irys = irys;
      this.signer = irys.tokenConfig.getSigner();
    }

    public sign(): Promise<Buffer> {
      return super.sign(this.signer);
    }

    get size(): number {
      return this.getRaw().length;
    }

    /**
     * @deprecated use upload
     */
    async uploadWithReceipt(opts?: UploadOptions): Promise<UploadReceipt> {
      return (await this.Irys.uploader.uploadTransaction(this, opts)).data;
    }

    // parent type union not strictly required, but might be if this type gets extended
    upload(
      opts: UploadOptions & { getReceiptSignature: true }
    ): Promise<UploadReceipt>;
    upload(opts?: UploadOptions): Promise<UploadResponse>;
    async upload(opts?: UploadOptions): Promise<UploadResponse> {
      return (await this.Irys.uploader.uploadTransaction(this, opts)).data;
    }

    // static fromRaw(rawTransaction: Buffer, IrysInstance: Irys): IrysTransaction {
    //   return new IrysTransaction(rawTransaction, IrysInstance, { dataIsRawTransaction: true });
    // }

    async getPrice(): Promise<BigNumber> {
      return this.Irys.utils.getPrice(this.Irys.tokenConfig.name, this.size, {
        tags: this.tags,
      });
    }

    async isValid(): Promise<boolean> {
      return irys.bundles.DataItem.verify(this.getRaw());
    }
  }
  return IrysTransaction;
}

// export abstract class IrysTransaction extends DataItem {}

// export interface IrysTransaction extends DataItem {
//   size: number;
//   uploadWithReceipt(opts?: UploadOptions): Promise<UploadReceipt>;
//   upload(opts: UploadOptions & { getReceiptSignature: true }): Promise<UploadReceipt>;
//   upload(opts?: UploadOptions): Promise<UploadResponse>;
// }