import { playgroundHelper } from "../../helpers/helpers";
import {
  createPublicClient,
  encodeFunctionData,
  http,
  serializeTransaction,
} from "viem";
import { arbitrum } from "viem/chains";
import { chainAdapters, contracts, MPCSignature, utils } from "chainsig.js";
import { stablecoinVaultConstants } from "../constants";

// EVM Intents Deposit process:
// Transfer USDC to NEAR Intent deposit address for vault deposits

const USDC_AMOUNT = "299994700"; // (6 decimals)
const USDC_CONTRACT = stablecoinVaultConstants.USDC_ARB_ADDRESS;
const INTENT_DEPOSIT_ADDRESS = stablecoinVaultConstants.ARBITRUM_NEAR_INTENT_DEPOSIT_ADDRESS_VAULT;
const DEPOSIT_POLICY_ID = "arbitrum_usdc_deposit_intents_vault";
const CHAIN_SIG_DERIVED_ADDRESS = stablecoinVaultConstants.ARBITRUM_CHAINSIG_DERIVED_ADDRESS;

// Create Arbitrum client
const client = createPublicClient({
  chain: arbitrum,
  transport: http(),
});

// Setup chain signature contract and adapter for transaction broadcasting
const chainSigContract = new contracts.ChainSignatureContract({
  networkId: "mainnet",
  contractId: "v1.signer",
});

// setup chain adapter
const evmChain = new chainAdapters.evm.EVM({
  publicClient: client,
  contract: chainSigContract,
});

async function transferUSDCToIntents(): Promise<string> {
  console.log("=== USDC Transfer to NEAR Intents ===");

  const transferTxRequest = await client.prepareTransactionRequest({
    account: CHAIN_SIG_DERIVED_ADDRESS,
    to: USDC_CONTRACT,
    data: encodeFunctionData({
      abi: stablecoinVaultConstants.erc20Abi,
      functionName: "transfer",
      args: [
        INTENT_DEPOSIT_ADDRESS, // to
        USDC_AMOUNT,            // value
      ],
    }),
    type: "eip1559",
  });

  const transferSerializedTx = serializeTransaction(transferTxRequest);

  console.log("Proposing USDC transfer transaction...");

  // Execute transfer transaction via chain signature policy
  const transferSignatures = await playgroundHelper.account.callFunction<MPCSignature[]>({
    contractId: playgroundHelper.vaultContractId,
    methodName: "propose_execution",
    args: {
      policy_id: DEPOSIT_POLICY_ID,
      function_args: transferSerializedTx,
      deadline_hours: 0,
    },
    gas: 50000000000000n, // 50 TGas
  });

  // Sign and broadcast transfer transaction
  console.log("Broadcasting transfer transaction...");
  const signedTransferTx = evmChain.finalizeTransactionSigning({
    transaction: transferTxRequest,
    rsvSignatures: transferSignatures.map((v) => utils.cryptography.toRSV(v)),
  });
  const { hash: transferHash } = await evmChain.broadcastTx(signedTransferTx);
  console.log("Transfer transaction hash:", transferHash);

  return transferHash;
}

async function main() {
  console.log("Starting EVM Intents deposit process...");
  console.log("Derived Arbitrum address:", CHAIN_SIG_DERIVED_ADDRESS);
  console.log("USDC Contract:", USDC_CONTRACT);
  console.log("Intent Deposit Address:", INTENT_DEPOSIT_ADDRESS);
  console.log("Amount to transfer:", USDC_AMOUNT, "USDC");

  try {
    // Transfer USDC to NEAR Intent deposit address
    const transferHash = await transferUSDCToIntents();

    console.log("\n=== EVM Intents deposit process completed successfully! ===");
    console.log(`Transferred ${USDC_AMOUNT} USDC to ${INTENT_DEPOSIT_ADDRESS}`);
    console.log(`Transfer tx: ${transferHash}`);
  } catch (error) {
    console.error("Error during intents deposit process:", error);
    throw error;
  }
}

// Execute the main function
main().catch(console.error);