/**
 * Fetch SOL/USD rate from CoinGecko
 */
export async function fetchSOLUSD(): Promise<number | null> {
  try {
    const response = await fetch(
      `${COINGECKO_API_BASE}/simple/price?ids=solana&vs_currencies=usd`,
      {
        method: 'GET',
        headers: {
          'Accept': 'application/json',
        },
        next: { revalidate: 0 }, // Always fetch fresh data
      }
    );

    if (!response.ok) {
      console.error(`[CoinGecko] Failed to fetch SOL/USD: ${response.status}`);
      return null;
    }

    const data = await response.json();
    const rate = data.solana?.usd;

    if (!rate || typeof rate !== 'number') {
      return null;
    }

    return rate;
  } catch (error) {
    console.error('[CoinGecko] Error fetching SOL/USD:', error);
    return null;
  }
}

CREATE TABLE IF NOT EXISTS public.exchange_rates (
    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
    currency_pair TEXT NOT NULL UNIQUE,
    rate NUMERIC(20, 8) NOT NULL,
    last_updated TIMESTAMP WITH TIME ZONE DEFAULT NOW() NOT NULL,
    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW() NOT NULL
);

// Cron job endpoint: /api/cron/update-exchange-rates
export async function GET(request: NextRequest) {
  // Verify cron secret for security
  const authHeader = request.headers.get('authorization');
  const cronSecret = process.env.CRON_SECRET;
  
  if (!cronSecret || authHeader !== `Bearer ${cronSecret}`) {
    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
  }

  // Update SOL/USD (every 15 minutes)
  const solRate = await fetchSOLUSD();
  if (solRate !== null) {
    await supabase
      .from('exchange_rates')
      .upsert({
        currency_pair: 'SOL/USD',
        rate: solRate,
        last_updated: new Date().toISOString(),
      }, { onConflict: 'currency_pair' });
  }

  // Update fiat rates (every 30 minutes, conditional)
  // ...
}

class WC_Gateway_InstantPay extends WC_Payment_Gateway {
    
    public function __construct() {
        $this->id                 = 'instantpay_sol';
        $this->method_title       = __( 'InstantPay (Pay with SOL)', 'instantpay-solana-payments' );
        $this->method_description = __( 'Accept Solana (SOL) payments directly to your wallet.', 'instantpay-solana-payments' );
        
        // Load settings
        $this->init_form_fields();
        $this->init_settings();
        
        // Define configuration
        $this->wallet_address = $this->get_option( 'wallet_address' );
        $this->min_amount     = $this->get_option( 'min_amount', '0.001' );
    }
    
    public function process_payment($order_id) {
        $order = wc_get_order($order_id);
        
        // Get transaction signature from checkout
        $transaction_signature = sanitize_text_field($_POST['instantpay_transaction_signature']);
        
        // Store transaction data
        $order->update_meta_data('_instantpay_tx_hash', $transaction_signature);
        $order->update_status('processing', __( 'InstantPay payment received. Verifying...', 'instantpay-solana-payments' ));
        
        // Verify transaction asynchronously
        $this->verify_transaction($order_id, $transaction_signature);
        
        return array(
            'result'   => 'success',
            'redirect' => $this->get_return_url($order),
        );
    }
}

// Initialize rates and set up auto-refresh
async function initializeRates() {
  // Fetch initial rates
  await refreshRates();
  
  // Set up 10-minute refresh interval
  state.refreshInterval = setInterval(function() {
    refreshRates();
  }, 10 * 60 * 1000); // 10 minutes
}

async function sendTransaction() {
  // Re-check exchange rate before sending
  var rates = await fetchExchangeRates();
  if (rates) {
    var newSolAmount = calculateSOLAmount(rates);
    
    // If rate changed significantly, ask user to confirm
    if (Math.abs(newSolAmount - state.solAmount) > 0.0001) {
      var confirmed = confirm(
        'Exchange rate has changed. New amount: ' + newSolAmount.toFixed(9) + ' SOL\n' +
        'Previous amount: ' + state.solAmount.toFixed(9) + ' SOL\n\n' +
        'Do you want to proceed with the new amount?'
      );
      if (!confirmed) return;
      
      state.solAmount = newSolAmount;
      updateSOLDisplay(newSolAmount);
    }
  }
  
  // Proceed with transaction...
}

function calculateSOLAmount(rates) {
  var orderTotal = parseFloat(config.orderTotal.replace(/[^0-9.-]+/g, ''));
  var currency = config.currency.toUpperCase();
  var solUsdRate = rates['SOL/USD'];
  
  // Convert to USD if needed
  var usdAmount = orderTotal;
  if (currency !== 'USD') {
    var currencyRate = rates[currency + '/USD'];
    usdAmount = orderTotal * currencyRate;
  }
  
  // Convert USD to SOL
  var solAmount = usdAmount / solUsdRate;
  
  // Round to 9 decimal places (SOL precision)
  solAmount = Math.round(solAmount * 1000000000) / 1000000000;
  
  return solAmount;
}

export async function verifyTransaction(
  signature: string,
  expectedAmountSOL: number,
  recipientAddress: string
): Promise<boolean> {
  const connection = new Connection(
    process.env.NEXT_PUBLIC_HELIUS_RPC_URL!,
    'confirmed'
  );

  // Fetch transaction from blockchain
  const tx = await connection.getTransaction(signature, {
    maxSupportedTransactionVersion: 0,
  });

  if (!tx || !tx.meta || tx.meta.err) {
    return false; // Transaction failed or not found
  }

  // Verify recipient address
  const recipientPubkey = new PublicKey(recipientAddress);
  const accountKeys = tx.transaction.message.getAccountKeys();
  const recipientIndex = accountKeys.findIndex(key => 
    key.equals(recipientPubkey)
  );

  if (recipientIndex === -1) {
    return false; // Recipient not found
  }

  // Verify amount
  const preBalance = tx.meta.preBalances[recipientIndex] || 0;
  const postBalance = tx.meta.postBalances[recipientIndex] || 0;
  const amountReceived = postBalance - preBalance;
  const expectedLamports = Math.round(expectedAmountSOL * LAMPORTS_PER_SOL);

  // Allow small tolerance for rounding
  const tolerance = 1000; // 0.000001 SOL
  if (Math.abs(amountReceived - expectedLamports) > tolerance) {
    return false; // Amount mismatch
  }

  return true; // Transaction verified
}

// Check if transaction signature is already used
$existing_order = wc_get_orders(array(
    'limit'      => 1,
    'meta_key'   => '_instantpay_tx_hash',
    'meta_value' => $transaction_signature,
    'exclude'    => array($order_id),
));

if (!empty($existing_order)) {
    wc_add_notice(
        __( 'This transaction has already been used for another order.', 'instantpay-solana-payments' ),
        'error'
    );
    return array('result' => 'fail');
}

$sol_amount_float = floatval($sol_amount);
if ($sol_amount_float < floatval($this->min_amount)) {
    wc_add_notice(
        sprintf(
            __( 'SOL amount (%s) is below minimum required amount (%s SOL).', 'instantpay-solana-payments' ),
            $sol_amount,
            $this->min_amount
        ),
        'error'
    );
    return array('result' => 'fail');
}

private function verify_transaction($order_id, $transaction_signature, $sol_amount) {
    $max_retries = 3;
    $retry_count = 0;
    
    while ($retry_count < $max_retries) {
        $response = wp_remote_post(
            $this->api_base . '/api/woocommerce/verify-payment',
            array(
                'body'    => array(
                    'order_id'              => $order_id,
                    'transaction_signature' => $transaction_signature,
                    'sol_amount'            => $sol_amount,
                    'recipient_address'     => $this->wallet_address,
                ),
                'timeout' => 30,
            )
        );
        
        if (is_wp_error($response)) {
            $retry_count++;
            if ($retry_count >= $max_retries) {
                // Mark order as on-hold for manual review
                $order->update_status('on-hold', __( 'Verification failed. Please verify manually.', 'instantpay-solana-payments' ));
                return;
            }
            sleep($retry_count); // Exponential backoff
            continue;
        }
        
        // Process response...
        break;
    }
}

private function is_valid_solana_address($address) {
    if (empty($address)) {
        return false;
    }
    
    // Basic Solana address validation
    if (strlen($address) < 32 || strlen($address) > 44) {
        return false;
    }
    
    // Check for base58 characters only
    if (!preg_match('/^[1-9A-HJ-NP-Za-km-z]+$/', $address)) {
        return false;
    }
    
    return true;
}

async function connectWallet() {
    if (!isPhantomInstalled()) {
        alert('Phantom wallet is not installed. Please install from https://phantom.app');
        return;
    }
    
    try {
        var response = await solana.connect();
        state.publicKey = response.publicKey;
        state.walletConnected = true;
        
        // Update UI
        connectWalletBtn.style.display = 'none';
        walletStatusDiv.style.display = 'block';
        walletStatusDiv.textContent = 'Wallet connected: ' + 
            state.publicKey.toString().substring(0, 8) + '...';
    } catch (error) {
        console.error('[InstantPay] Wallet connection error:', error);
        alert('Failed to connect wallet. Please try again.');
    }
}

async function sendTransaction() {
    // Create Solana connection
    var connection = new solanaWeb3.Connection(rpcUrl, 'confirmed');
    
    // Create transaction
    var recipient = new solanaWeb3.PublicKey(config.walletAddress);
    var lamports = Math.round(state.solAmount * 1000000000);
    
    var transaction = new solanaWeb3.Transaction().add(
        solanaWeb3.SystemProgram.transfer({
            fromPubkey: state.publicKey,
            toPubkey: recipient,
            lamports: lamports,
        })
    );
    
    // Get recent blockhash
    var { blockhash } = await connection.getLatestBlockhash();
    transaction.recentBlockhash = blockhash;
    transaction.feePayer = state.publicKey;
    
    // Send transaction
    var signature = await solana.sendTransaction(transaction, connection);
    
    // Store signature for WooCommerce
    transactionSignatureInput.value = signature;
    
    // Poll for confirmation (30 seconds timeout)
    var confirmed = false;
    var attempts = 0;
    var maxAttempts = 15; // 15 attempts * 2 seconds = 30 seconds
    
    while (!confirmed && attempts < maxAttempts) {
        await new Promise(function(resolve) {
            setTimeout(resolve, 2000); // Wait 2 seconds
        });
        
        var status = await connection.getSignatureStatus(signature);
        if (status && status.value && !status.value.err) {
            confirmed = true;
            alert('Transaction confirmed! You can now submit your order.');
        }
        attempts++;
    }
}