script.js

class NanoSol {
  constructor() {
    // La conexión se inicializará solo si window.solana está disponible.
    // Si no está, se hará más tarde.
    this.connection = null;
    this.wallet = null;
    this.publicKey = null;
    this.transactions = [];
  }

  // Nuevo método para inicializar la conexión, que requiere solanaWeb3
  initializeConnection() {
    if (!this.connection && typeof solanaWeb3 !== 'undefined') {
      try {
        this.connection = new solanaWeb3.Connection(
          'https://api.mainnet-beta.solana.com',
          'confirmed'
        );
        console.log('NanoSol: Conexión a Solana Web3 inicializada.');
      } catch (e) {
        console.error('NanoSol: Error al inicializar solanaWeb3.Connection:', e);
      }
    }
  }

  init() {
    console.log('NanoSol: Inicializando aplicación...');
    this.initializeConnection(); // Intentar inicializar la conexión al principio
    this.setupEventListeners();
    this.checkWalletConnection();
    console.log('NanoSol: Event listeners y chequeo de conexión configurados.');
  }

  setupEventListeners() {
    // Wallet connection
    const connectWalletBtn = document.getElementById('connectWallet');
    if (connectWalletBtn) {
      connectWalletBtn.addEventListener('click', () => {
        this.connectWallet();
      });
    } else {
      console.warn("Elemento 'connectWallet' no encontrado. Verifica index.html.");
    }

    // Copy address
    const copyAddressBtn = document.getElementById('copyAddress');
    if (copyAddressBtn) {
      copyAddressBtn.addEventListener('click', () => {
        this.copyAddress();
      });
    } else {
      console.warn("Elemento 'copyAddress' no encontrado. Verifica index.html.");
    }

    // Send payment
    const sendPaymentBtn = document.getElementById('sendPayment');
    if (sendPaymentBtn) {
      sendPaymentBtn.addEventListener('click', (event) => { // Añadir event para prevenir default
        event.preventDefault(); // Evitar el envío de formulario si está dentro de uno
        this.sendPayment();
      });
    } else {
      console.warn("Elemento 'sendPayment' no encontrado. Verifica index.html.");
    }

    // Generate QR code
    const generateQRBtn = document.getElementById('generateQR');
    if (generateQRBtn) {
      generateQRBtn.addEventListener('click', () => {
        this.generateQRCode();
      });
    } else {
      console.warn("Elemento 'generateQR' no encontrado. Verifica index.html.");
    }

    // Quick amount buttons
    document.querySelectorAll('.amount-btn').forEach(btn => {
      btn.addEventListener('click', (e) => {
        const amount = e.target.dataset.amount;
        this.generateQRCode(amount);
      });
    });

    // Form validation
    const recipientAddressInput = document.getElementById('recipientAddress');
    if (recipientAddressInput) {
      recipientAddressInput.addEventListener('input', () => {
        this.validateForm();
      });
    } else {
      console.warn("Elemento 'recipientAddress' no encontrado. Verifica index.html.");
    }
    
    const amountInput = document.getElementById('amount');
    if (amountInput) {
      amountInput.addEventListener('input', () => {
        this.validateForm();
      });
    } else {
      console.warn("Elemento 'amount' no encontrado. Verifica index.html.");
    }

    // Close notification
    const closeNotificationBtn = document.getElementById('closeNotification');
    if (closeNotificationBtn) {
      closeNotificationBtn.addEventListener('click', () => {
        this.hideNotification();
      });
    } else {
      console.warn("Elemento 'closeNotification' no encontrado. Verifica index.html.");
    }
  }

  async checkWalletConnection() {
    console.log('NanoSol: Chequeando conexión de billetera...');
    if (window.solana && window.solana.isPhantom) {
      try {
        const response = await window.solana.connect({ onlyIfTrusted: true });
        this.handleWalletConnect(response.publicKey);
        console.log('NanoSol: Billetera conectada automáticamente (trusted).');
      } catch (error) {
        console.log('NanoSol: Billetera no conectada o no trusted.');
        // No notificar error si onlyIfTrusted falla, es un comportamiento esperado.
      }
    } else {
      console.log('NanoSol: Phantom Wallet no detectada al inicio (esperando).');
      // No deshabilitamos el botón, permitimos que el usuario intente conectarse.
    }
  }

  async connectWallet() {
    console.log('NanoSol: Intentando conectar billetera...');
    if (!window.solana || !window.solana.isPhantom) {
      this.showNotification('Por favor, instala la extensión Phantom Wallet.', 'error');
      console.error('Phantom Wallet no instalada o no detectada.');
      return;
    }

    try {
      this.showLoading(true);
      const response = await window.solana.connect();
      this.handleWalletConnect(response.publicKey);
      this.showNotification('Billetera conectada con éxito!', 'success');
      console.log('NanoSol: Conexión de billetera exitosa.');
    } catch (error) {
      console.error('NanoSol: Falló la conexión de la billetera:', error);
      this.showNotification(`Falló la conexión: ${error.message || error}`, 'error');
    } finally {
      this.showLoading(false);
    }
  }

  async handleWalletConnect(publicKey) {
    this.publicKey = publicKey;
    this.wallet = window.solana;
    
    const connectWalletBtn = document.getElementById('connectWallet');
    if (connectWalletBtn) {
      connectWalletBtn.textContent = 'Conectado';
      connectWalletBtn.disabled = true;
    }
    
    const walletInfoDiv = document.getElementById('walletInfo');
    if (walletInfoDiv) {
      walletInfoDiv.classList.remove('hidden');
    }
    
    const address = publicKey.toString();
    const walletAddressSpan = document.getElementById('walletAddress');
    if (walletAddressSpan) {
      walletAddressSpan.textContent =
        `${address.slice(0, 8)}...${address.slice(-8)}`;
    }
    
    // Asegurarse de que la conexión esté inicializada antes de usarla
    this.initializeConnection();
    if (this.connection) {
      await this.updateBalance();
    } else {
      console.error('NanoSol: No se pudo actualizar el balance: la conexión a Solana no está lista.');
      this.showNotification('Error: Conexión a Solana no establecida.', 'error');
    }
    
    this.validateForm();
    console.log('NanoSol: UI de billetera actualizada.');
  }

  async updateBalance() {
    if (!this.publicKey || !this.connection) {
      console.log('NanoSol: No hay clave pública o conexión para actualizar el balance.');
      return;
    }

    try {
      const balance = await this.connection.getBalance(this.publicKey);
      const solBalance = balance / solanaWeb3.LAMPORTS_PER_SOL;
      const solBalanceSpan = document.getElementById('solBalance');
      if (solBalanceSpan) {
        solBalanceSpan.textContent = solBalance.toFixed(4);
      }
      console.log(`NanoSol: Balance actualizado: ${solBalance.toFixed(4)} SOL`);
    } catch (error) {
      console.error('NanoSol: Falló la obtención del balance:', error);
      this.showNotification('Falló la obtención del balance.', 'error');
    }
  }

  validateForm() {
    const addressInput = document.getElementById('recipientAddress');
    const amountInput = document.getElementById('amount');
    const sendBtn = document.getElementById('sendPayment');
    
    if (!addressInput || !amountInput || !sendBtn) {
      console.warn("NanoSol: Elementos del formulario no encontrados para validación.");
      return;
    }

    const address = addressInput.value.trim();
    const amount = parseFloat(amountInput.value);
    
    const isValidAddress = this.isValidSolanaAddress(address);
    const isValidAmount = amount > 0 && !isNaN(amount);
    const isWalletConnected = this.publicKey !== null;
    
    sendBtn.disabled = !(isValidAddress && isValidAmount && isWalletConnected);
  }

  isValidSolanaAddress(address) {
    try {
      new solanaWeb3.PublicKey(address);
      return true;
    } catch {
      return false;
    }
  }

  async sendPayment() {
    const recipientAddress = document.getElementById('recipientAddress').value.trim();
    const amount = parseFloat(document.getElementById('amount').value);
    const memo = document.getElementById('memo').value.trim();
    const tokenType = document.getElementById('tokenType').value; // Usado pero no implementado para SPL tokens

    if (!this.publicKey || !this.wallet || !this.connection) {
      this.showNotification('Por favor, conecta tu billetera y asegura la conexión a Solana.', 'error');
      console.warn('NanoSol: Intento de envío de pago sin billetera conectada o conexión a Solana.');
      return;
    }

    try {
      this.showLoading(true);
      
      const recipientPublicKey = new solanaWeb3.PublicKey(recipientAddress);
      const lamports = amount * solanaWeb3.LAMPORTS_PER_SOL;
      
      const transaction = new solanaWeb3.Transaction();
      
      transaction.add(
        solanaWeb3.SystemProgram.transfer({
          fromPubkey: this.publicKey,
          toPubkey: recipientPublicKey,
          lamports: lamports,
        })
      );
      
      if (memo) {
        transaction.add(
          new solanaWeb3.TransactionInstruction({
            keys: [{ pubkey: this.publicKey, isSigner: true, isWritable: false }],
            data: Buffer.from(memo, 'utf-8'),
            programId: new solanaWeb3.PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr'),
          })
        );
      }
      
      const { blockhash } = await this.connection.getLatestBlockhash();
      transaction.recentBlockhash = blockhash;
      transaction.feePayer = this.publicKey;
      
      const signedTransaction = await this.wallet.signTransaction(transaction);
      const signature = await this.connection.sendRawTransaction(signedTransaction.serialize());
      
      console.log('NanoSol: Transacción enviada, firma:', signature);
      this.showNotification('Transacción enviada! Confirmando...', 'info');

      await this.connection.confirmTransaction(signature);
      
      this.addTransaction({
        signature,
        type: 'sent',
        amount,
        address: recipientAddress,
        memo,
        status: 'success',
        timestamp: new Date()
      });
      
      document.getElementById('recipientAddress').value = '';
      document.getElementById('amount').value = '';
      document.getElementById('memo').value = '';
      
      await this.updateBalance();
      
      this.showNotification(`Enviado ${amount} SOL con éxito!`, 'success');
      
    } catch (error) {
      console.error('NanoSol: Transacción fallida:', error);
      this.showNotification(`Transacción fallida: ${error.message || error}`, 'error');
    } finally {
      this.showLoading(false);
      this.validateForm();
    }
  }

  async generateQRCode(amount = null) {
    if (!this.publicKey) {
      this.showNotification('Por favor, conecta tu billetera primero.', 'error');
      return;
    }

    const requestAmount = amount || document.getElementById('amount').value || '0.001';
    const address = this.publicKey.toString();
    
    const solanaPayUrl = `solana:${address}?amount=${requestAmount}&label=NanoSol%20Payment`;
    
    try {
      const canvas = document.getElementById('qrCode');
      if (canvas) {
        await QRCode.toCanvas(canvas, solanaPayUrl, {
          width: 200,
          margin: 2,
          color: {
            dark: '#4c1d95',
            light: '#ffffff'
          }
        });
        this.showNotification(`Código QR generado para ${requestAmount} SOL`, 'success');
        console.log(`NanoSol: QR generado para ${requestAmount} SOL`);
      } else {
        console.warn("Elemento 'qrCode' (canvas) no encontrado. Verifica index.html.");
        this.showNotification('Falló la generación del código QR: elemento QR faltante.', 'error');
      }
    } catch (error) {
      console.error('NanoSol: Falló la generación del código QR:', error);
      this.showNotification('Falló la generación del código QR.', 'error');
    }
  }

  copyAddress() {
    if (!this.publicKey) return;
    
    const address = this.publicKey.toString();
    navigator.clipboard.writeText(address).then(() => {
      this.showNotification('Dirección copiada al portapapeles!', 'success');
      console.log('NanoSol: Dirección copiada.');
    }).catch(() => {
      this.showNotification('Falló al copiar la dirección.', 'error');
      console.error('NanoSol: Falló al copiar la dirección.');
    });
  }

  addTransaction(transaction) {
    this.transactions.unshift(transaction);
    this.updateTransactionHistory();
  }

  updateTransactionHistory() {
    const container = document.getElementById('transactionList');
    
    if (!container) {
      console.warn("Elemento 'transactionList' no encontrado. Verifica index.html.");
      return;
    }

    if (this.transactions.length === 0) {
      container.innerHTML = '<p class="no-transactions">No hay transacciones aún</p>';
      return;
    }
    
    container.innerHTML = this.transactions.map(tx => `
      <div class="transaction-item">
        <div class="transaction-info">
          <div class="transaction-amount">
            ${tx.type === 'sent' ? '-' : '+'}${tx.amount} SOL
          </div>
          <div class="transaction-address">
            ${tx.type === 'sent' ? 'Para: ' : 'De: '}${tx.address.slice(0, 8)}...${tx.address.slice(-8)}
          </div>
          ${tx.memo ? `<div class="transaction-memo">${tx.memo}</div>` : ''}
        </div>
        <div class="transaction-status status-${tx.status}">
          ${tx.status}
        </div>
      </div>
    `).join('');
  }

  showNotification(message, type = 'info') {
    const notification = document.getElementById('notification');
    const text = document.getElementById('notificationText');
    
    if (!notification || !text) {
      console.warn("NanoSol: Elementos de notificación no encontrados.");
      return;
    }

    text.textContent = message;
    notification.className = `notification ${type}`;
    notification.classList.remove('hidden');
    
    setTimeout(() => {
      this.hideNotification();
    }, 5000);
  }

  hideNotification() {
    const notification = document.getElementById('notification');
    if (notification) {
      notification.classList.add('hidden');
    }
  }

  showLoading(show) {
    const overlay = document.getElementById('loadingOverlay');
    if (overlay) {
      if (show) {
        overlay.classList.remove('hidden');
      } else {
        overlay.classList.add('hidden');
      }
    }
  }
}

// =========================================================================
// Inicialización de la aplicación: Estrategia más robusta para Phantom Wallet
// =========================================================================

let nanoSolApp; // Declaramos la instancia fuera para que sea accesible globalmente si es necesario

// Función para inicializar NanoSol una vez que window.solana esté disponible
function tryInitializeNanoSol() {
  if (window.solana && window.solana.isPhantom) {
    console.log('Phantom Wallet detectada. Inicializando NanoSol...');
    if (!nanoSolApp) { // Solo inicializar si no se ha hecho ya
      nanoSolApp = new NanoSol();
      nanoSolApp.init();

      // Configurar listeners de Phantom una vez que la instancia de NanoSol exista
      window.solana.on('connect', (publicKey) => {
        console.log('Evento Phantom: Billetera conectada:', publicKey.toString());
        if (!nanoSolApp.publicKey || nanoSolApp.publicKey.toString() !== publicKey.toString()) {
          nanoSolApp.handleWalletConnect(publicKey);
          nanoSolApp.showNotification('Billetera reconectada!', 'success');
        }
      });
      
      window.solana.on('disconnect', () => {
        console.log('Evento Phantom: Billetera desconectada. Recargando página...');
        location.reload(); // Recargar para limpiar el estado
      });
    }
  } else {
    console.log('Esperando por Phantom Wallet...');
  }
}

// 1. Intentar inicializar inmediatamente al cargar el DOM (antes que 'load')
// Esto captura casos donde Phantom es muy rápido.
document.addEventListener('DOMContentLoaded', tryInitializeNanoSol);

// 2. Intentar inicializar después de que todos los recursos de la página hayan cargado
// Esto da más tiempo a las extensiones.
window.addEventListener('load', () => {
  tryInitializeNanoSol(); // Intentar de nuevo
  
  // Si después de 'load' Phantom aún no se detecta, puedes dar un mensaje al usuario.
  // Pero evita deshabilitar el botón, ya que el usuario puede instalar Phantom después
  // y luego intentar conectar.
  if (!window.solana || !window.solana.isPhantom) {
    console.warn('Phantom Wallet aún no detectada después del evento "load". El usuario necesitará instalarla o recargar.');
    // Podrías mostrar un mensaje persistente en la UI para el usuario aquí.
  }
});

// Opcional: Un pequeño retraso adicional si 'load' no es suficiente.
// No siempre es necesario, pero puede ayudar en ciertos entornos.
setTimeout(() => {
  if (!nanoSolApp && window.solana && window.solana.isPhantom) {
    console.log('Phantom Wallet detectada después de un pequeño retraso. Inicializando NanoSol.');
    tryInitializeNanoSol();
  }
}, 1000); // Intenta de nuevo 1 segundo después del evento 'load'