import { BN } from "@coral-xyz/anchor";
import type { Wallet } from "@saberhq/solana-contrib";
import type { Connection, PublicKey, Transaction } from "@solana/web3.js";

import { tryGetAccount } from "../../utils/tryGetAccount";
import { getIdentifier } from "./accounts";
import {
  adminCloseIdentifierInstruction,
  adminCloseProjectInstruction,
  adminInitIdentifierInstruction,
  adminUpdateIdentifierInstruction,
  adminUpdateProjectInstruction,
  closeProjectInstruction,
  initProjectInstruction,
  updateProjectInstruction,
} from "./instruction";
import { findIdentifierId, findProjectId } from "./pda";

/**
 * Add init project identifier instructions to a transaction
 * Only the contract admins can sign this transaction
 * @param transaction
 * @param connection
 * @param wallet
 * @param params
 * @returns Transaction, public key for the created project identifier
 */
export const withAdminInitProjectIdentifier = async (
  transaction: Transaction,
  connection: Connection,
  wallet: Wallet,
  params: {
    defaultStaticFee: BN;
    defaultTreasury: PublicKey;
    defaultSellerFeeBasisPoint: number;
  }
): Promise<[Transaction, PublicKey]> => {
  const identifierId = findIdentifierId();
  transaction.add(
    await adminInitIdentifierInstruction(connection, wallet, {
      identifierId,
      ...params,
    })
  );
  return [transaction, identifierId];
};

/**
 * Add update project identifier instructions to a transaction
 * Only the contract admins can sign this transaction
 * @param transaction
 * @param connection
 * @param wallet
 * @param params
 * @returns Transaction
 */
export const withAdminUpdateProjectIdentifier = async (
  transaction: Transaction,
  connection: Connection,
  wallet: Wallet,
  params: {
    identifierId: PublicKey;
    defaultStaticFee: BN;
    defaultTreasury: PublicKey;
    defaultSellerFeeBasisPoint: number;
  }
): Promise<Transaction> => {
  transaction.add(
    await adminUpdateIdentifierInstruction(connection, wallet, params)
  );
  return transaction;
};

/**
 * Add init project instructions to a transaction
 * @param transaction
 * @param connection
 * @param wallet
 * @param params
 * @returns Transaction, public key for the created project
 */
export const withInitProject = async (
  transaction: Transaction,
  connection: Connection,
  wallet: Wallet,
  params: {
    name: string;
    authorities: PublicKey[];
    authorizedTokenCreators: PublicKey[];
    public: boolean;
  }
): Promise<[Transaction, PublicKey]> => {
  const identifierId = findIdentifierId();
  const identifierData = await tryGetAccount(() =>
    getIdentifier(connection, identifierId)
  );
  const identifier = identifierData?.parsed.count || new BN(1);

  if (!identifierData) {
    throw new Error("Error on finding project Identifier");
  }

  const projectId = findProjectId(identifier);

  transaction.add(
    await initProjectInstruction(connection, wallet, {
      identifierId,
      projectId,
      ...params,
    })
  );
  return [transaction, projectId];
};

/**
 * Add update project instructions to a transaction
 * @param transaction
 * @param connection
 * @param wallet
 * @param params
 * @returns Transaction
 */
export const withUpdateProject = async (
  transaction: Transaction,
  connection: Connection,
  wallet: Wallet,
  params: {
    projectId: PublicKey;
    name: string;
    authorities: PublicKey[];
    authorizedTokenCreators: PublicKey[];
    public: boolean;
  }
): Promise<Transaction> => {
  transaction.add(await updateProjectInstruction(connection, wallet, params));
  return transaction;
};

/**
 * Add admin update project instructions to a transaction
 * Only the contract admins can sign this transaction
 * @param transaction
 * @param connection
 * @param wallet
 * @param params
 * @returns Transaction
 */
export const withAdminUpdateProject = async (
  transaction: Transaction,
  connection: Connection,
  wallet: Wallet,
  params: {
    projectId: PublicKey;
    name: string;
    authorities: PublicKey[];
    staticFee: BN;
    treasury: PublicKey;
    sellerFeeBasisPoint: number;
    authorizedTokenCreators: PublicKey[];
    public: boolean;
  }
): Promise<Transaction> => {
  transaction.add(
    await adminUpdateProjectInstruction(connection, wallet, params)
  );
  return transaction;
};

/**
 * Add close project instructions to a transaction
 * @param transaction
 * @param connection
 * @param wallet
 * @param params
 * @returns Transaction
 */
export const withCloseProject = async (
  transaction: Transaction,
  connection: Connection,
  wallet: Wallet,
  params: {
    projectId: PublicKey;
  }
): Promise<Transaction> => {
  transaction.add(await closeProjectInstruction(connection, wallet, params));
  return transaction;
};

/**
 * Add admin close identifier instructions to a transaction
 * Only the contract admins can sign this transaction
 * @param transaction
 * @param connection
 * @param wallet
 * @param params
 * @returns Transaction
 */
export const withAdminCloseIdentifier = async (
  transaction: Transaction,
  connection: Connection,
  wallet: Wallet,
  params: {
    identifierId: PublicKey;
  }
): Promise<Transaction> => {
  transaction.add(
    await adminCloseIdentifierInstruction(connection, wallet, params)
  );
  return transaction;
};

/**
 * Add admin close project instructions to a transaction
 * Only the contract admins can sign this transaction
 * @param transaction
 * @param connection
 * @param wallet
 * @param params
 * @returns Transaction
 */
export const withAdminCloseProject = async (
  transaction: Transaction,
  connection: Connection,
  wallet: Wallet,
  params: {
    projectId: PublicKey;
  }
): Promise<Transaction> => {
  transaction.add(
    await adminCloseProjectInstruction(connection, wallet, params)
  );
  return transaction;
};