import { CashuMint, CashuWallet, getEncodedTokenV4, getDecodedToken } from '@cashu/cashu-ts'
import { Global } from '../global'
import path from 'path'
import fs from 'fs/promises'

export interface WalletConfig {
  mintUrl: string
  seed?: string
  balance: number
  lastUpdated: string
}

export class RoutstrCashuWallet {
  private wallet: CashuWallet
  private mint: CashuMint
  private configPath: string

  constructor(mintUrl: string = 'https://mint.minibits.cash/Bitcoin') {
    this.mint = new CashuMint(mintUrl)
    this.configPath = path.join(Global.Path.data, 'wallet.json')
  }

  async initialize(): Promise<void> {
    try {
      const config = await this.loadConfig()
      // Initialize wallet with existing seed if available
      this.wallet = new CashuWallet(this.mint, { 
        seed: config.seed ? Buffer.from(config.seed, 'hex') : undefined 
      })
    } catch {
      // Create new wallet if config doesn't exist
      this.wallet = new CashuWallet(this.mint)
      await this.saveConfig({
        mintUrl: this.mint.mintUrl,
        balance: 0,
        lastUpdated: new Date().toISOString(),
      })
    }
  }

  async receiveToken(encodedToken: string): Promise<number> {
    const decodedToken = getDecodedToken(encodedToken)
    const amount = decodedToken.token.reduce((sum, t) => sum + t.proofs.reduce((s, p) => s + p.amount, 0), 0)
    
    await this.wallet.receive(encodedToken)
    
    // Update config with new balance
    const config = await this.loadConfig()
    config.balance += amount
    config.lastUpdated = new Date().toISOString()
    await this.saveConfig(config)
    
    return amount
  }

  async getBalance(): Promise<number> {
    const config = await this.loadConfig()
    return config.balance
  }

  async createToken(amount: number): Promise<string> {
    const { send } = await this.wallet.send(amount)
    
    // Update config with reduced balance
    const config = await this.loadConfig()
    config.balance -= amount
    config.lastUpdated = new Date().toISOString()
    await this.saveConfig(config)
    
    return getEncodedTokenV4(send)
  }

  async createLightningInvoice(amount: number): Promise<{
    paymentRequest: string
    quote: string
  }> {
    const quote = await this.wallet.createMintQuote(amount)
    return {
      paymentRequest: quote.request,
      quote: quote.quote
    }
  }

  async checkInvoiceStatus(quote: string): Promise<boolean> {
    const quoteStatus = await this.wallet.checkMintQuote(quote)
    if (quoteStatus.paid) {
      // Mint the tokens
      await this.wallet.mintProofs(quoteStatus.amount, quote)
      
      // Update balance
      const config = await this.loadConfig()
      config.balance += quoteStatus.amount
      config.lastUpdated = new Date().toISOString()
      await this.saveConfig(config)
      
      return true
    }
    return false
  }

  private async loadConfig(): Promise<WalletConfig> {
    try {
      const content = await fs.readFile(this.configPath, 'utf8')
      return JSON.parse(content)
    } catch {
      throw new Error('Wallet not initialized')
    }
  }

  private async saveConfig(config: WalletConfig): Promise<void> {
    await fs.writeFile(this.configPath, JSON.stringify(config, null, 2))
    await fs.chmod(this.configPath, 0o600)
  }
}

import { RoutstrCashuWallet } from '../wallet/cashu'
import { Auth } from './index'

export interface RoutstrAuthData {
  type: 'routstr'
  apiKey: string
  baseUrl: string
  balance: number
  lastUpdated: string
}

export namespace RoutstrAuth {
  export async function createWalletFromToken(
    cashuToken: string, 
    baseUrl: string = 'https://api.routstr.com'
  ): Promise<{ apiKey: string; balance: number }> {
    
    // Initialize Cashu wallet
    const wallet = new RoutstrCashuWallet()
    await wallet.initialize()
    
    // Receive the provided token
    const receivedAmount = await wallet.receiveToken(cashuToken)
    
    // Create token for Routstr wallet
    const routstrToken = await wallet.createToken(receivedAmount)
    
    // Create Routstr wallet
    const response = await fetch(`${baseUrl}/v1/wallet/create`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ cashu_token: routstrToken }),
    })
    
    if (!response.ok) {
      throw new Error(`Failed to create Routstr wallet: ${response.status}`)
    }
    
    const result = await response.json()
    
    // Store in auth.json with balance info
    await Auth.set('routstr', {
      type: 'api',
      key: result.api_key,
    })
    
    // Store Routstr-specific metadata including balance
    await Auth.set('routstr-wallet', {
      type: 'routstr',
      apiKey: result.api_key,
      baseUrl,
      balance: result.balance,
      lastUpdated: new Date().toISOString(),
    } as RoutstrAuthData)
    
    return {
      apiKey: result.api_key,
      balance: result.balance,
    }
  }

  export async function getWalletInfo(): Promise<RoutstrAuthData | null> {
    try {
      const info = await Auth.get('routstr-wallet')
      return info as RoutstrAuthData
    } catch {
      return null
    }
  }

  export async function updateBalance(balance: number): Promise<void> {
    const info = await getWalletInfo()
    if (info) {
      info.balance = balance
      info.lastUpdated = new Date().toISOString()
      await Auth.set('routstr-wallet', info)
    }
  }
}

if (provider === "routstr") {
  const baseUrl = await prompts.text({
    message: "Enter Routstr base URL",
    initial: "https://api.routstr.com",
  });
  if (prompts.isCancel(baseUrl)) throw new UI.CancelledError();
  
  const cashuToken = await prompts.password({
    message: "Paste your Cashu token",
    validate: (x) => x?.startsWith("cashu") ? undefined : "Must be a valid Cashu token starting with 'cashu'",
  });
  if (prompts.isCancel(cashuToken)) throw new UI.CancelledError();
  
  const spinner = prompts.spinner();
  spinner.start("Creating wallet and funding Routstr account...");
  
  try {
    const result = await RoutstrAuth.createWalletFromToken(cashuToken, baseUrl);
    
    spinner.stop(`✅ Wallet created with ${result.balance} msats balance`);
    prompts.log.success(`API key: ${result.apiKey.substring(0, 20)}...`);
  } catch (error) {
    spinner.stop("❌ Failed to create wallet", 1);
    throw error;
  }
  
  prompts.outro("Done");
  return;
}

import { RoutstrCashuWallet } from '../../wallet/cashu'
import { RoutstrAuth } from '../../auth/routstr'
import { cmd } from './cmd'
import * as prompts from '@clack/prompts'
import QRCode from 'qrcode'
import { UI } from '../ui'

export const WalletCommand = cmd({
  command: "wallet",
  describe: "manage cashu wallet",
  builder: (yargs) =>
    yargs
      .command(WalletBalanceCommand)
      .command(WalletTopupCommand) 
      .command(WalletWithdrawCommand)
      .command(WalletStatusCommand)
      .demandCommand(),
  async handler() {},
})

export const WalletBalanceCommand = cmd({
  command: "balance",
  describe: "show wallet balance",
  async handler() {
    try {
      const wallet = new RoutstrCashuWallet()
      await wallet.initialize()
      
      const localBalance = await wallet.getBalance()
      const routstrInfo = await RoutstrAuth.getWalletInfo()
      
      prompts.intro("Wallet Balance")
      
      prompts.log.info(`Local Cashu Wallet: ${localBalance} sats`)
      
      if (routstrInfo) {
        prompts.log.info(`Routstr Account: ${routstrInfo.balance} msats`)
        prompts.log.info(`Last updated: ${new Date(routstrInfo.lastUpdated).toLocaleString()}`)
      }
      
      const totalSats = localBalance + (routstrInfo?.balance || 0) / 1000
      prompts.outro(`Total: ${totalSats} sats`)
      
    } catch (error) {
      prompts.log.error(`Error: ${error.message}`)
    }
  },
})

export const WalletTopupCommand = cmd({
  command: "topup [token]",
  describe: "add funds to wallet",
  builder: (yargs) =>
    yargs.positional("token", {
      describe: "cashu token to add, or generate Lightning invoice",
      type: "string",
    }),
  async handler(args) {
    const wallet = new RoutstrCashuWallet()
    await wallet.initialize()
    
    if (args.token) {
      // Add existing Cashu token
      try {
        const amount = await wallet.receiveToken(args.token)
        prompts.log.success(`✅ Added ${amount} sats to wallet`)
      } catch (error) {
        prompts.log.error(`❌ Failed to receive token: ${error.message}`)
      }
    } else {
      // Generate Lightning invoice
      const amount = await prompts.text({
        message: "How many sats to add?",
        initial: "10000",
        validate: (x) => !isNaN(Number(x)) && Number(x) > 0 ? undefined : "Must be a positive number",
      })
      if (prompts.isCancel(amount)) throw new UI.CancelledError()
      
      const satsAmount = parseInt(amount)
      
      try {
        const invoice = await wallet.createLightningInvoice(satsAmount)
        
        prompts.intro(`Lightning Invoice for ${satsAmount} sats`)
        
        // Generate and display QR code
        const qrCode = await QRCode.toString(invoice.paymentRequest, { type: 'terminal' })
        console.log(qrCode)
        
        prompts.log.info("Or copy this invoice:")
        console.log(invoice.paymentRequest)
        
        // Poll for payment
        const spinner = prompts.spinner()
        spinner.start("Waiting for payment...")
        
        const pollInterval = setInterval(async () => {
          try {
            const paid = await wallet.checkInvoiceStatus(invoice.quote)
            if (paid) {
              clearInterval(pollInterval)
              spinner.stop("✅ Payment received!")
              
              // Update Routstr balance
              await RoutstrAuth.updateBalance(await wallet.getBalance())
              
              prompts.outro(`Added ${satsAmount} sats to wallet`)
            }
          } catch (error) {
            clearInterval(pollInterval)
            spinner.stop("❌ Error checking payment", 1)
            prompts.log.error(error.message)
          }
        }, 2000)
        
        // Timeout after 5 minutes
        setTimeout(() => {
          clearInterval(pollInterval)
          spinner.stop("⏰ Payment timeout", 1)
        }, 300000)
        
      } catch (error) {
        prompts.log.error(`❌ Failed to create invoice: ${error.message}`)
      }
    }
  },
})

export const WalletWithdrawCommand = cmd({
  command: "withdraw [amount]",
  describe: "withdraw sats as cashu token",
  builder: (yargs) =>
    yargs.positional("amount", {
      describe: "amount in sats (default: all)",
      type: "number",
    }),
  async handler(args) {
    const wallet = new RoutstrCashuWallet()
    await wallet.initialize()
    
    const balance = await wallet.getBalance()
    if (balance === 0) {
      prompts.log.error("Wallet is empty")
      return
    }
    
    const amount = args.amount || balance
    
    if (amount > balance) {
      prompts.log.error(`Insufficient balance. Available: ${balance} sats`)
      return
    }
    
    try {
      const token = await wallet.createToken(amount)
      
      prompts.intro(`Withdraw ${amount} sats`)
      prompts.log.success("Cashu token:")
      console.log(token)
      prompts.outro("Token can be shared or imported into another wallet")
      
    } catch (error) {
      prompts.log.error(`❌ Failed to withdraw: ${error.message}`)
    }
  },
})

export const WalletStatusCommand = cmd({
  command: "status",
  describe: "show detailed wallet status", 
  async handler() {
    try {
      const wallet = new RoutstrCashuWallet()
      await wallet.initialize()
      
      const localBalance = await wallet.getBalance()
      const routstrInfo = await RoutstrAuth.getWalletInfo()
      
      prompts.intro("Wallet Status")
      
      // Local wallet info
      prompts.log.info(`📱 Local Cashu Wallet`)
      prompts.log.info(`   Balance: ${localBalance} sats`)
      prompts.log.info(`   Mint: ${wallet.mint.mintUrl}`)
      
      // Routstr account info  
      if (routstrInfo) {
        prompts.log.info(`⚡ Routstr Account`) 
        prompts.log.info(`   API Key: ${routstrInfo.apiKey.substring(0, 20)}...`)
        prompts.log.info(`   Balance: ${routstrInfo.balance} msats`)
        prompts.log.info(`   Base URL: ${routstrInfo.baseUrl}`)
        prompts.log.info(`   Last Updated: ${new Date(routstrInfo.lastUpdated).toLocaleString()}`)
      } else {
        prompts.log.warn("No Routstr account configured")
      }
      
      prompts.outro("Use 'opencode wallet balance' for quick balance check")
      
    } catch (error) {
      prompts.log.error(`Error: ${error.message}`)
    }
  },
})

import { RoutstrAuth } from '../auth/routstr'
import { RoutstrCashuWallet } from './cashu'

export class RoutstrBalanceManager {
  private wallet: RoutstrCashuWallet
  private minBalance: number = 5000 // 5k msats minimum

  constructor() {
    this.wallet = new RoutstrCashuWallet()
  }

  async ensureSufficientBalance(requiredAmount: number): Promise<boolean> {
    const routstrInfo = await RoutstrAuth.getWalletInfo()
    if (!routstrInfo) {
      throw new Error('No Routstr account configured. Run: opencode auth login')
    }

    // Check if current balance is sufficient
    if (routstrInfo.balance >= requiredAmount + this.minBalance) {
      return true
    }

    // Need to top up from local wallet
    const localBalance = await this.wallet.getBalance()
    const neededAmount = Math.max(requiredAmount + this.minBalance - routstrInfo.balance, 0)
    const topupAmount = Math.min(neededAmount, localBalance * 1000) // Convert sats to msats

    if (topupAmount === 0) {
      throw new Error(`Insufficient funds. Need ${neededAmount} msats more. Run: opencode wallet topup`)
    }

    // Create token and top up Routstr account
    const tokenAmount = Math.ceil(topupAmount / 1000) // Convert back to sats
    const cashuToken = await this.wallet.createToken(tokenAmount)

    // Send to Routstr
    const response = await fetch(`${routstrInfo.baseUrl}/v1/wallet/topup`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${routstrInfo.apiKey}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ cashu_token: cashuToken }),
    })

    if (!response.ok) {
      throw new Error(`Failed to top up Routstr account: ${response.status}`)
    }

    const result = await response.json()
    
    // Update stored balance
    await RoutstrAuth.updateBalance(result.balance)

    return true
  }

  async getRoutstrBalance(): Promise<number> {
    const routstrInfo = await RoutstrAuth.getWalletInfo()
    if (!routstrInfo) return 0

    try {
      const response = await fetch(`${routstrInfo.baseUrl}/v1/wallet/balance`, {
        headers: { 'Authorization': `Bearer ${routstrInfo.apiKey}` },
      })

      if (response.ok) {
        const result = await response.json()
        await RoutstrAuth.updateBalance(result.balance)
        return result.balance
      }
    } catch {
      // Fall back to cached balance
    }

    return routstrInfo.balance
  }
}

export const WalletBalanceCommand = cmd({
  command: "balance",
  describe: "show wallet balance",
  builder: (yargs) =>
    yargs.option("json", {
      describe: "output as JSON",
      type: "boolean",
      default: false,
    }),
  async handler(args) {
    try {
      const wallet = new RoutstrCashuWallet()
      await wallet.initialize()
      
      const localBalance = await wallet.getBalance()
      const routstrInfo = await RoutstrAuth.getWalletInfo()
      
      if (args.json) {
        // JSON output for TUI consumption
        console.log(JSON.stringify({
          local_balance: localBalance,
          routstr_balance: routstrInfo?.balance || 0,
          total_sats: localBalance + (routstrInfo?.balance || 0) / 1000,
          last_updated: routstrInfo?.lastUpdated || null,
        }))
      } else {
        // Human-friendly output
        prompts.intro("Wallet Balance")
        prompts.log.info(`Local Cashu Wallet: ${localBalance} sats`)
        
        if (routstrInfo) {
          prompts.log.info(`Routstr Account: ${routstrInfo.balance} msats`)
          prompts.log.info(`Last updated: ${new Date(routstrInfo.lastUpdated).toLocaleString()}`)
        }
        
        const totalSats = localBalance + (routstrInfo?.balance || 0) / 1000
        prompts.outro(`Total: ${totalSats} sats`)
      }
      
      // Always update auth.json with latest info
      if (routstrInfo) {
        await RoutstrAuth.updateBalance(routstrInfo.balance)
      }
      
    } catch (error) {
      if (args.json) {
        console.log(JSON.stringify({ error: error.message }))
      } else {
        prompts.log.error(`Error: ${error.message}`)
      }
    }
  },
})