import { Connection, Keypair, VersionedTransaction } from '@solana/web3.js';
import bs58 from 'bs58';
import dotenv from 'dotenv';

dotenv.config();

const API_KEY = process.env.CARBIUM_API_KEY;
const RPC_URL = process.env.SOLANA_RPC_URL;
const PRIVATE_KEY = process.env.PRIVATE_KEY;

// Initialize connection and wallet
const connection = new Connection(RPC_URL, 'confirmed');
const wallet = Keypair.fromSecretKey(bs58.decode(PRIVATE_KEY));

/**
 * Get executable quote from Carbium
 */
async function getExecutableQuote(srcMint, dstMint, amountIn, slippageBps = 10) {
  const params = new URLSearchParams({
    src_mint: srcMint,
    dst_mint: dstMint,
    amount_in: String(amountIn),
    slippage_bps: String(slippageBps),
    user_account: wallet.publicKey.toBase58()
  });

  const response = await fetch(
    `https://api.carbium.io/api/v2/quote?${params}`,
    { headers: { 'X-API-KEY': API_KEY } }
  );

  if (!response.ok) {
    throw new Error(`Quote failed: ${response.status}`);
  }

  const data = await response.json();

  // API returns empty string when user_account not provided
  if (!data.txn || data.txn.length === 0) {
    throw new Error('Quote missing transaction - ensure user_account is provided');
  }

  return data;
}

/**
 * Confirm transaction using HTTP polling
 */
async function confirmTransaction(signature, timeout = 60000) {
  const startTime = Date.now();

  while (Date.now() - startTime < timeout) {
    const status = await connection.getSignatureStatus(signature);

    if (status.value?.err) {
      throw new Error(`Transaction failed: ${JSON.stringify(status.value.err)}`);
    }

    if (status.value?.confirmationStatus === 'confirmed' ||
        status.value?.confirmationStatus === 'finalized') {
      return true;
    }

    await new Promise(resolve => setTimeout(resolve, 500));
  }

  throw new Error(`Transaction not confirmed within ${timeout / 1000}s`);
}

/**
 * Execute a swap on Carbium
 */
async function executeSwap(srcMint, dstMint, amountIn) {
  console.log(`Executing swap: ${amountIn} ${srcMint.slice(0,4)} → ${dstMint.slice(0,4)}`);

  // Step 1: Get executable quote
  const quote = await getExecutableQuote(srcMint, dstMint, amountIn);
  console.log(`Expected output: ${quote.destAmountOut}`);

  // Step 2: Deserialize transaction
  const transaction = VersionedTransaction.deserialize(
    Buffer.from(quote.txn, 'base64')
  );

  // Step 3: Sign transaction
  transaction.sign([wallet]);

  // Step 4: Send transaction
  const signature = await connection.sendTransaction(transaction, {
    skipPreflight: true,  // Skip simulation for speed (quote already validated)
    maxRetries: 3
  });
  console.log(`Transaction sent: ${signature}`);

  // Step 5: Confirm transaction
  await confirmTransaction(signature);
  console.log(`Confirmed: https://solscan.io/tx/${signature}`);

  return {
    signature,
    inputAmount: amountIn,
    outputAmount: quote.destAmountOut
  };
}

// Example: Swap 0.01 SOL to USDC
const SOL = 'So11111111111111111111111111111111111111112';
const USDC = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';

const result = await executeSwap(SOL, USDC, 10_000_000); // 0.01 SOL
console.log('Swap completed:', result);

import os
import asyncio
import base64
import aiohttp
from solders.keypair import Keypair
from solders.transaction import VersionedTransaction
from solana.rpc.async_api import AsyncClient
from dotenv import load_dotenv

load_dotenv()

API_KEY = os.getenv('CARBIUM_API_KEY')
RPC_URL = os.getenv('SOLANA_RPC_URL')
PRIVATE_KEY = os.getenv('PRIVATE_KEY')

# Initialize wallet from base58 private key
wallet = Keypair.from_base58_string(PRIVATE_KEY)

async def get_executable_quote(session, src_mint, dst_mint, amount_in, slippage_bps=10):
    """Get quote with executable transaction from Carbium"""
    params = {
        'src_mint': src_mint,
        'dst_mint': dst_mint,
        'amount_in': str(amount_in),
        'slippage_bps': str(slippage_bps),
        'user_account': str(wallet.pubkey())
    }
    headers = {'X-API-KEY': API_KEY}

    async with session.get(
        'https://api.carbium.io/api/v2/quote',
        params=params,
        headers=headers
    ) as resp:
        if resp.status != 200:
            raise Exception(f'Quote failed: {resp.status}')
        data = await resp.json()

        # API returns empty string when user_account not provided
        if not data.get('txn') or len(data['txn']) == 0:
            raise Exception('Quote missing transaction - ensure user_account is provided')

        return data

async def confirm_transaction(client, signature, timeout=60):
    """Confirm transaction using HTTP polling"""
    import time
    start_time = time.time()

    while time.time() - start_time < timeout:
        resp = await client.get_signature_statuses([signature])
        status = resp.value[0]

        if status:
            if status.err:
                raise Exception(f'Transaction failed: {status.err}')

            if status.confirmation_status in ['confirmed', 'finalized']:
                return True

        await asyncio.sleep(0.5)

    raise Exception(f'Transaction not confirmed within {timeout}s')

async def execute_swap(src_mint, dst_mint, amount_in):
    """Execute a swap on Carbium"""
    async with aiohttp.ClientSession() as session:
        async with AsyncClient(RPC_URL) as client:
            print(f'Executing swap: {amount_in} {src_mint[:4]} → {dst_mint[:4]}')

            # Step 1: Get executable quote
            quote = await get_executable_quote(session, src_mint, dst_mint, amount_in)
            print(f'Expected output: {quote["destAmountOut"]}')

            # Step 2: Deserialize transaction
            txn_bytes = base64.b64decode(quote['txn'])
            transaction = VersionedTransaction.from_bytes(txn_bytes)

            # Step 3: Sign transaction
            signed_tx = VersionedTransaction(transaction.message, [wallet])

            # Step 4: Send transaction
            resp = await client.send_raw_transaction(
                bytes(signed_tx),
                opts={'skip_preflight': True, 'max_retries': 3}
            )
            signature = str(resp.value)
            print(f'Transaction sent: {signature}')

            # Step 5: Confirm transaction
            await confirm_transaction(client, signature)
            print(f'Confirmed: https://solscan.io/tx/{signature}')

            return {
                'signature': signature,
                'input_amount': amount_in,
                'output_amount': quote['destAmountOut']
            }

# Example: Swap 0.01 SOL to USDC
async def main():
    SOL = 'So11111111111111111111111111111111111111112'
    USDC = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'

    result = await execute_swap(SOL, USDC, 10_000_000)  # 0.01 SOL
    print('Swap completed:', result)

asyncio.run(main())