import type BigNumber from 'bignumber.js';
import type Irys from './irys';
import type { StringifiedNumber, UnixEpochMs, UploadResponse } from './types';
import Utils from './utils';

export class Approval {
  constructor(protected irys: Irys) {}

  public async getApprovals({
    payingAddresses,
    tokens = [this.irys.token],
    approvedAddresses = [this.irys.address],
  }: {
    payingAddresses?: string[];
    tokens?: string[];
    approvedAddresses?: string[];
  }): Promise<
    {
      amount: string;
      payingAddress: string;
      approvedAddress: string;
      expiresBy: number;
      timestamp: number;
      token: string;
    }[]
  > {
    return this.queryApproval
      .payingAddresses(payingAddresses)
      .tokens(tokens)
      .approvedAddresses(approvedAddresses);
  }

  public async getCreatedApprovals({
    payingAddresses = [this.irys.address],
    tokens = [this.irys.token],
    approvedAddresses,
  }: {
    payingAddresses?: string[];
    tokens?: string[];
    approvedAddresses?: string[];
  }): Promise<
    {
      amount: string;
      payingAddress: string;
      approvedAddress: string;
      expiresBy: number;
      timestamp: number;
      token: string;
    }[]
  > {
    return this.queryApproval
      .payingAddresses(payingAddresses)
      .tokens(tokens)
      .approvedAddresses(approvedAddresses);
  }

  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
  get queryApproval() {
    return this.irys.query().search('irys:paymentApprovals');
  }

  public async getApproval({
    payingAddress = this.irys.address,
    token = this.irys.token,
    approvedAddress,
  }: {
    payingAddress?: string;
    token?: string;
    approvedAddress: string;
  }): Promise<GetApprovedBalanceResponseBody> {
    const res = await this.irys.api.get<GetApprovedBalanceResponseBody>(
      '/account/approval',
      { params: { payingAddress, token, approvedAddress } }
    );
    if (res.status === 404) return { amount: '0' };
    Utils.checkAndThrow(res);
    return res.data;
  }

  public async getApprovedBalanceFrom(
    payingAddress: string
  ): Promise<GetApprovedBalanceResponseBody> {
    if (!payingAddress) throw new Error('Paying address is required');
    return await this.getApproval({
      payingAddress,
      approvedAddress: this.irys.address,
      token: this.irys.token,
    });
  }

  public async createApproval({
    approvedAddress,
    amount,
    expiresInSeconds,
  }: {
    approvedAddress: string;
    amount: string | number | BigNumber;
    expiresInSeconds?: number | string;
  }): Promise<UploadResponse> {
    const tags = [
      { name: UploadApprovalTags.APPROVE_PAYMENT, value: approvedAddress },
      { name: UploadApprovalMetaTags.AMOUNT, value: amount.toString() },
    ];
    if (expiresInSeconds)
      tags.push({
        name: UploadApprovalMetaTags.EXPIRE_SECONDS,
        value: expiresInSeconds.toString(),
      });
    return await this.irys.upload('', { tags });
  }

  public async revokeApproval({
    approvedAddress,
  }: {
    approvedAddress: string;
  }): Promise<UploadResponse> {
    const tags = [
      { name: UploadApprovalTags.DELETE_APPROVAL, value: approvedAddress },
    ];
    return await this.irys.upload('', { tags });
  }
}

type GetApprovedBalanceResponseBody = {
  amount: string;
  expiresBy?: StringifiedNumber<UnixEpochMs>;
};

export enum UploadApprovalTags {
  APPROVE_PAYMENT = 'x-irys-approve-payment',
  DELETE_APPROVAL = 'x-irys-delete-payment-approval',
}

export enum UploadApprovalMetaTags {
  AMOUNT = 'x-amount',
  EXPIRE_SECONDS = 'x-expire-seconds',
}