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

// Get derived address and public key
const addressInfo = await playgroundHelper.provider.callFunction<{
  public_key: string;
  address: `0x${string}`;
}>(
  playgroundHelper.vaultContractId,
  "derive_address_and_public_key",
  {
    path: stablecoinVaultConstants.ETHEREUM_DERIVATION_PATH,
    chain: "EVM",
    near_network: "Testnet",
  });
if(!addressInfo){
  throw new Error("Unable to find chain sig address info")
}
console.log("Derived address info:", addressInfo);

const client = createPublicClient({
  chain: mainnet,
  transport: http(),
});

// Example: Approve USDC spending for Morpho Blue vault
const approveTxRequest = await client.prepareTransactionRequest({
  account: addressInfo.address,
  to: stablecoinVaultConstants.USDC_ADDRESS,
  data: encodeFunctionData({
    abi: stablecoinVaultConstants.erc20Abi,
    functionName: "approve",
    args: [stablecoinVaultConstants.MORPHO_BLUE_VAULT_ADDRESS, parseUnits("1000", 6)], // Approve 1000 USDC
  }),
  type: "eip1559",
});

const approveSerializedTx = serializeTransaction(approveTxRequest);

// Execute approve transaction via Morpho Blue USDC policy
const approveSignatures = await playgroundHelper.account.callFunction<MPCSignature[]>({
  contractId: playgroundHelper.vaultContractId,
  methodName: "propose_execution",
  args: {
    policy_id: "morpho_blue_usdc",
    function_args: approveSerializedTx,
    deadline_hours: 0,
  },
});

// Example: Deposit USDC into Morpho Blue vault
const depositTxRequest = await client.prepareTransactionRequest({
  account: addressInfo.address,
  to: stablecoinVaultConstants.MORPHO_BLUE_VAULT_ADDRESS,
  data: encodeFunctionData({
    abi: stablecoinVaultConstants.vaultAbi,
    functionName: "deposit",
    args: [parseUnits("500", 6), addressInfo.address], // Deposit 500 USDC
  }),
  type: "eip1559",
});

const depositSerializedTx = serializeTransaction(depositTxRequest);

// Execute deposit transaction via Morpho Blue USDC policy
const depositSignatures = await playgroundHelper.account.callFunction<MPCSignature[]>({
  contractId: playgroundHelper.vaultContractId,
  methodName: "propose_execution",
  args: {
    policy_id: "morpho_blue_usdc",
    function_args: depositSerializedTx,
    deadline_hours: 0,
  },
});

// Example: Redeem shares from Euler Prime vault
const redeemTxRequest = await client.prepareTransactionRequest({
  account: addressInfo.address,
  to: stablecoinVaultConstants.EULER_PRIME_VAULT_ADDRESS,
  data: encodeFunctionData({
    abi: stablecoinVaultConstants.vaultAbi,
    functionName: "redeem",
    args: [parseUnits("100", 18), addressInfo.address, addressInfo.address], // Redeem 100 shares
  }),
  type: "eip1559",
});

const redeemSerializedTx = serializeTransaction(redeemTxRequest);

// Execute redeem transaction via Euler Prime USDC policy
const redeemSignatures = await playgroundHelper.account.callFunction<MPCSignature[]>({
  contractId: playgroundHelper.vaultContractId,
  methodName: "propose_execution",
  args: {
    policy_id: "euler_prime_usdc",
    function_args: redeemSerializedTx,
    deadline_hours: 0,
  },
});

// Setup chain signature contract and adapter
const contract = new contracts.ChainSignatureContract({
  networkId: "testnet",
  contractId: "v1.signer-prod.testnet",
});

const evmChain = new chainAdapters.evm.EVM({
  publicClient: client,
  contract,
});

// Sign and broadcast transactions
console.log("Signing and broadcasting approve transaction...");
const signedApproveTx = evmChain.finalizeTransactionSigning({
  transaction: approveTxRequest,
  rsvSignatures: approveSignatures.map((v) => utils.cryptography.toRSV(v)),
});
const { hash: approveHash } = await evmChain.broadcastTx(signedApproveTx);
console.log("Approve transaction hash:", approveHash);

console.log("Signing and broadcasting deposit transaction...");
const signedDepositTx = evmChain.finalizeTransactionSigning({
  transaction: depositTxRequest,
  rsvSignatures: depositSignatures.map((v) => utils.cryptography.toRSV(v)),
});
const { hash: depositHash } = await evmChain.broadcastTx(signedDepositTx);
console.log("Deposit transaction hash:", depositHash);

console.log("Signing and broadcasting redeem transaction...");
const signedRedeemTx = evmChain.finalizeTransactionSigning({
  transaction: redeemTxRequest,
  rsvSignatures: redeemSignatures.map((v) => utils.cryptography.toRSV(v)),
});
const { hash: redeemHash } = await evmChain.broadcastTx(signedRedeemTx);
console.log("Redeem transaction hash:", redeemHash);

// Example: NEAR native mt_transfer
console.log("Executing NEAR native mt_transfer...");
const mtTransferResult = await playgroundHelper.account.callFunction({
  contractId: playgroundHelper.vaultContractId,
  methodName: "propose_execution",
  args: {
    policy_id: "near_native_mt_transfer",
    function_args: {
      receiver_id: "receiver.near",
      token_id: "usdc",
      amount: "1000000", // 1 USDC with 6 decimals
      memo: "Transfer via vault policy",
    },
    deadline_hours: 0,
  },
});

console.log("NEAR mt_transfer result:", mtTransferResult);