import * as anchor from "@project-serum/anchor";
import {
  getAssociatedTokenAddress,
  getAccount,
  createAssociatedTokenAccountInstruction,
} from "@solana/spl-token";
import {
  TOKEN_METADATA_PROGRAM_ID,
  STRIKR_COLLECTION_MINT,
} from "../../constants";
import { getStrikr, getStrikrAuthority } from "../../utils";
import { getFloorOption } from "./get-floor-option";
import { requestComputeUnits } from "../../actions/request-compute-units";
import { Response } from "../../types/types";

/**
 * Close the put option seller position.
 * @param provider Anchor provider
 * @param optionKey Option key representing a unique option
 * @param assetNftMint Asset NFT which underlies the option
 * @param assetNftTokenAccount Token account containing the asset NFT
 * @returns Promise resolving to the transaction signature
 */
export const floorClosePutOptionSeller = async (
  provider: anchor.AnchorProvider,
  optionKey: anchor.web3.PublicKey,
  assetNftMint?: anchor.web3.PublicKey,
  assetNftTokenAccount?: anchor.web3.PublicKey
) : Promise<Response> => {
  const strikr = getStrikr(provider);
  const transaction = new anchor.web3.Transaction();

  const strikrAuthority = await getStrikrAuthority();
  const optionState = await getFloorOption(provider.connection, optionKey);

  if (optionState.isExercised && !assetNftMint) {
    throw new Error(
      "Exercised options need to send an assetNftMint to close seller position."
    );
  }

  // Request additional compute units and attach the instruction
  const computeUnitsIx = requestComputeUnits(provider, 400_000, 0);

  transaction.add(computeUnitsIx);

  const sellerPositionNftTokenAccount = await getAssociatedTokenAddress(
    optionState.sellerPositionNftMint,
    provider.wallet.publicKey,
    true
  );

  if (optionState.isExercised) {
    // Use wallet's ATA as the NFT token account if not passed as argument
    if (!assetNftTokenAccount) {
      assetNftTokenAccount = await getAssociatedTokenAddress(
        assetNftMint,
        provider.wallet.publicKey
      );
      // Check if ATA exists, otherwise initialize it
      try {
        await getAccount(provider.connection, assetNftTokenAccount);
      } catch {
        transaction.add(
          createAssociatedTokenAccountInstruction(
            provider.wallet.publicKey,
            assetNftTokenAccount,
            provider.wallet.publicKey,
            assetNftMint
          )
        );
      }
    }

    const strikrAssetNftTokenAccount = await getAssociatedTokenAddress(
      assetNftMint,
      strikrAuthority,
      true
    );

    transaction.add(
      await strikr.methods
        .floorCollectAssetOnExercise()
        .accounts({
          signer: provider.wallet.publicKey,
          assetNftMint: optionState.assetNftMint,
          optionKey: optionKey,
          strikrCollectionMint: STRIKR_COLLECTION_MINT,
          sellerPositionNftMint: optionState.sellerPositionNftMint,
          sellerPositionNftTokenAccount: sellerPositionNftTokenAccount,
          signerAssetNftTokenAccount: assetNftTokenAccount,
          strikrAssetNftTokenAccount: strikrAssetNftTokenAccount,
          tokenMetadataProgram: TOKEN_METADATA_PROGRAM_ID,
        })
        .instruction()
    );
  } else {
    transaction.add(
      await strikr.methods
        .floorClosePutOptionSeller()
        .accounts({
          signer: provider.wallet.publicKey,
          optionKey: optionKey,
          strikrCollectionMint: STRIKR_COLLECTION_MINT,
          sellerPositionNftMint: optionState.sellerPositionNftMint,
          sellerPositionNftTokenAccount: sellerPositionNftTokenAccount,
          tokenMetadataProgram: TOKEN_METADATA_PROGRAM_ID,
        })
        .instruction()
    );
  }

  const signature = await provider.sendAndConfirm(transaction);

  return {
    signature,
    optionKey: optionState.optionKey,
  };
};