const { v4: uuidv4 } = require('uuid');
const crypto = require('crypto');
const cashu = require('./cashu');
const lightning = require('./lightning');

class RedemptionComponent {
  constructor() {
    this.redemptions = new Map();
    this.tokenHashes = new Map();
  }

  /**
   * Generate a simple hash for a token (for duplicate detection)
   */
  generateTokenHash(token) {
    return crypto.createHash('sha256').update(token).digest('hex').substring(0, 16);
  }

  /**
   * Store redemption status
   */
  storeRedemption(redeemId, status) {
    this.redemptions.set(redeemId, {
      ...status,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString()
    });
  }

  /**
   * Update redemption status
   */
  updateRedemption(redeemId, updates) {
    const existing = this.redemptions.get(redeemId);
    if (existing) {
      this.redemptions.set(redeemId, {
        ...existing,
        ...updates,
        updatedAt: new Date().toISOString()
      });
    }
  }

  /**
   * Get redemption status by ID
   */
  getRedemption(redeemId) {
    return this.redemptions.get(redeemId) || null;
  }

  /**
   * Get redemption ID by token hash
   */
  getRedemptionByTokenHash(tokenHash) {
    const redeemId = this.tokenHashes.get(tokenHash);
    return redeemId ? this.getRedemption(redeemId) : null;
  }

  /**
   * Check if a token has already been redeemed
   */
  checkExistingRedemption(token) {
    const tokenHash = this.generateTokenHash(token);
    return this.getRedemptionByTokenHash(tokenHash);
  }

  /**
   * Validate redemption request
   */
  async validateRedemptionRequest(token, lightningAddress) {
    const errors = [];

    if (!token || typeof token !== 'string') {
      errors.push('Token is required and must be a string');
    }

    let addressToUse = null;
    try {
      addressToUse = lightning.getLightningAddressToUse(lightningAddress);
      
      if (!lightning.validateLightningAddress(addressToUse)) {
        errors.push('Invalid Lightning address format');
      }
    } catch (error) {
      errors.push(error.message);
    }

    if (token) {
      const existing = this.checkExistingRedemption(token);
      if (existing && existing.status === 'paid') {
        errors.push('Token has already been redeemed');
      }
    }

    let tokenData = null;
    if (token && errors.length === 0) {
      try {
        tokenData = await cashu.parseToken(token);
        if (tokenData.totalAmount <= 0) {
          errors.push('Token has no value');
        }
      } catch (error) {
        errors.push(`Invalid token: ${error.message}`);
      }
    }

    return {
      valid: errors.length === 0,
      errors,
      tokenData,
      lightningAddressToUse: addressToUse
    };
  }

  /**
   * Perform the complete redemption process
   */
  async performRedemption(token, lightningAddress) {
    const redeemId = uuidv4();
    const tokenHash = this.generateTokenHash(token);

    try {
      const lightningAddressToUse = lightning.getLightningAddressToUse(lightningAddress);
      const isUsingDefault = !lightningAddress || !lightningAddress.trim();

      this.storeRedemption(redeemId, {
        status: 'processing',
        token: token.substring(0, 50) + '...',
        tokenHash,
        lightningAddress: lightningAddressToUse,
        usingDefaultAddress: isUsingDefault,
        amount: null,
        paid: false,
        error: null
      });

      this.tokenHashes.set(tokenHash, redeemId);

      // Step 1: Parse and validate token
      this.updateRedemption(redeemId, { status: 'parsing_token' });
      const tokenData = await cashu.parseToken(token);

      this.updateRedemption(redeemId, { 
        amount: tokenData.totalAmount,
        mint: tokenData.mint,
        numProofs: tokenData.numProofs,
        format: tokenData.format
      });

      // Check if token is spendable
      this.updateRedemption(redeemId, { status: 'checking_spendability' });
      try {
        const spendabilityCheck = await cashu.checkTokenSpendable(token);
        if (!spendabilityCheck.spendable || spendabilityCheck.spendable.length === 0) {
          throw new Error('Token proofs are not spendable - they have already been used or are invalid');
        }
      } catch (spendError) {
        if (spendError.message.includes('not spendable') || 
            spendError.message.includes('already been used') ||
            spendError.message.includes('invalid proofs') ||
            spendError.message.includes('422')) {
          throw new Error('This token has already been spent and cannot be redeemed again');
        }
        console.warn('Spendability check failed:', spendError.message);
        console.log('Continuing with redemption despite spendability check failure...');
      }

      // Step 2: Get melt quote first to determine exact fees
      this.updateRedemption(redeemId, { status: 'getting_melt_quote' });
      
      console.log(`Getting melt quote for ${tokenData.totalAmount} sats to determine exact fees`);
      const tempInvoiceData = await lightning.resolveInvoice(
        lightningAddressToUse, 
        tokenData.totalAmount,
        'Cashu redemption'
      );
      
      const meltQuote = await cashu.getMeltQuote(token, tempInvoiceData.bolt11);
      const exactFee = meltQuote.fee_reserve;
      const finalInvoiceAmount = tokenData.totalAmount - exactFee;
      
      console.log(`Melt quote: amount=${meltQuote.amount}, fee=${exactFee}, net to user=${finalInvoiceAmount}`);
      
      // Step 3: Create final invoice for the correct amount
      this.updateRedemption(redeemId, { status: 'resolving_invoice' });
      
      if (finalInvoiceAmount <= 0) {
        throw new Error(`Token amount (${tokenData.totalAmount} sats) is insufficient to cover the fee (${exactFee} sats)`);
      }
      
      console.log(`Creating final invoice for ${finalInvoiceAmount} sats (${tokenData.totalAmount} - ${exactFee} fee)`);
      
      const invoiceData = await lightning.resolveInvoice(
        lightningAddressToUse, 
        finalInvoiceAmount,
        'Cashu redemption'
      );

      this.updateRedemption(redeemId, { 
        bolt11: invoiceData.bolt11.substring(0, 50) + '...',
        domain: invoiceData.domain,
        invoiceAmount: finalInvoiceAmount,
        exactFee
      });

      const invoiceVerified = lightning.verifyInvoiceDestination(invoiceData.bolt11, lightningAddressToUse, finalInvoiceAmount);
      if (!invoiceVerified) {
        throw new Error('Invoice verification failed - invalid invoice or amount mismatch');
      }

      // Step 4: Melt the token to pay the invoice
      this.updateRedemption(redeemId, { status: 'melting_token' });
      const meltResult = await cashu.meltToken(token, invoiceData.bolt11);

      console.log(`Redemption ${redeemId}: Melt result:`, {
        paid: meltResult.paid,
        hasPreimage: !!meltResult.preimage,
        amount: meltResult.amount,
        fee: meltResult.fee
      });

      const paymentSuccessful = meltResult.paid || !!meltResult.preimage;

      this.updateRedemption(redeemId, {
        status: paymentSuccessful ? 'paid' : 'failed',
        paid: paymentSuccessful,
        preimage: meltResult.preimage,
        fee: meltResult.fee,
        actualFee: meltResult.actualFee,
        netAmount: meltResult.netAmount,
        change: meltResult.change,
        paidAt: paymentSuccessful ? new Date().toISOString() : null,
        rawMeltResponse: meltResult.rawMeltResponse
      });

      return {
        success: true,
        redeemId,
        paid: paymentSuccessful,
        amount: tokenData.totalAmount,
        invoiceAmount: finalInvoiceAmount,
        to: lightningAddressToUse,
        usingDefaultAddress: isUsingDefault,
        fee: exactFee,
        actualFee: meltResult.actualFee,
        netAmount: finalInvoiceAmount,
        preimage: meltResult.preimage,
        change: meltResult.change,
        mint: tokenData.mint,
        format: tokenData.format
      };

    } catch (error) {
      this.updateRedemption(redeemId, {
        status: 'failed',
        paid: false,
        error: error.message
      });

      // Remove token hash so the token can be retried after a failed redemption
      this.tokenHashes.delete(tokenHash);

      return {
        success: false,
        redeemId,
        error: error.message
      };
    }
  }

  /**
   * Get redemption status for API response
   */
  getRedemptionStatus(redeemId) {
    const redemption = this.getRedemption(redeemId);
    
    if (!redemption) return null;

    const response = {
      success: true,
      status: redemption.status,
      details: {
        amount: redemption.amount,
        to: redemption.lightningAddress,
        paid: redemption.paid,
        createdAt: redemption.createdAt,
        updatedAt: redemption.updatedAt
      }
    };

    if (redemption.paidAt) response.details.paidAt = redemption.paidAt;
    if (redemption.fee) response.details.fee = redemption.fee;
    if (redemption.error) response.details.error = redemption.error;
    if (redemption.mint) response.details.mint = redemption.mint;
    if (redemption.domain) response.details.domain = redemption.domain;

    return response;
  }

  /**
   * Get all redemptions (for admin/debugging)
   */
  getAllRedemptions() {
    return Array.from(this.redemptions.entries()).map(([id, data]) => ({
      redeemId: id,
      ...data
    }));
  }

  /**
   * Clean up old redemptions (should be called periodically)
   */
  cleanupOldRedemptions(maxAgeMs = 24 * 60 * 60 * 1000) {
    const cutoff = new Date(Date.now() - maxAgeMs);
    
    for (const [redeemId, redemption] of this.redemptions.entries()) {
      const createdAt = new Date(redemption.createdAt);
      if (createdAt < cutoff) {
        this.redemptions.delete(redeemId);
        if (redemption.tokenHash) {
          this.tokenHashes.delete(redemption.tokenHash);
        }
      }
    }
  }
}

module.exports = new RedemptionComponent();