import React, { useState, useEffect, useRef } from 'react';
import { initializeApp } from 'firebase/app';
import { getAuth, signInAnonymously, onAuthStateChanged, signInWithCustomToken } from 'firebase/auth';
import { 
  getFirestore, 
  collection, 
  doc, 
  addDoc, 
  updateDoc, 
  query, 
  onSnapshot, 
  serverTimestamp,
  setDoc
} from 'firebase/firestore';

// Configurações globais do ambiente
const firebaseConfig = JSON.parse(__firebase_config);
const app = initializeApp(firebaseConfig);
const auth = getAuth(app);
const db = getFirestore(app);
const appId = typeof __app_id !== 'undefined' ? __app_id : 'quant-alpha-v4';

const STRATEGY_CONFIG = {
  retracement: { name: 'Retração', color: 'blue', icon: 'fa-chart-line', desc: 'Compra em retrações de tendência' },
  aggressor: { name: 'Agressivo', color: 'orange', icon: 'fa-fire', desc: 'Rompimentos de alta volatilidade' },
  balanced: { name: 'Equilibrado', color: 'indigo', icon: 'fa-scale-balanced', desc: 'Tendência sólida e estável' },
  scalp: { name: 'Scalp', color: 'emerald', icon: 'fa-bolt', desc: 'Operações ultra-rápidas' },
  premium: { name: 'Premium', color: 'amber', icon: 'fa-crown', desc: 'Máxima precisão institucional' }
};

const getThemeColor = (color) => {
  const themes = {
    blue: 'border-blue-500/40 text-blue-400 bg-blue-500/5 shadow-blue-500/20',
    orange: 'border-orange-500/40 text-orange-400 bg-orange-500/5 shadow-orange-500/20',
    indigo: 'border-indigo-500/40 text-indigo-400 bg-indigo-500/5 shadow-indigo-500/20',
    emerald: 'border-emerald-500/40 text-emerald-400 bg-emerald-500/5 shadow-emerald-500/20',
    amber: 'border-amber-500/40 text-amber-400 bg-amber-500/5 shadow-amber-500/20',
  };
  return themes[color] || themes.blue;
};

export default function App() {
  const [user, setUser] = useState(null);
  const [currentStrategy, setCurrentStrategy] = useState('retracement');
  const [activeSignals, setActiveSignals] = useState([]);
  const [history, setHistory] = useState([]);
  const [isScanning, setIsScanning] = useState(false);
  const [logs, setLogs] = useState([{ msg: "Terminal iniciado. À espera de confluência...", type: "info" }]);
  const [counts, setCounts] = useState({ retracement: 0, aggressor: 0, balanced: 0, scalp: 0, premium: 0 });

  useEffect(() => {
    const initAuth = async () => {
      try {
        if (typeof __initial_auth_token !== 'undefined' && __initial_auth_token) {
          await signInWithCustomToken(auth, __initial_auth_token);
        } else {
          await signInAnonymously(auth);
        }
      } catch (err) {
        addLog("Falha na autenticação: " + err.message, "error");
      }
    };
    initAuth();
    const unsubscribe = onAuthStateChanged(auth, setUser);
    return () => unsubscribe();
  }, []);

  useEffect(() => {
    if (!user) return;
    const historyCol = collection(db, 'artifacts', appId, 'users', user.uid, 'trades_history');
    const unsubscribe = onSnapshot(query(historyCol), (snapshot) => {
      const docs = snapshot.docs.map(doc => ({ id: doc.id, ...doc.data() }))
        .sort((a, b) => (b.timestamp?.seconds || 0) - (a.timestamp?.seconds || 0));
      setHistory(docs);
    }, (err) => addLog("Erro de sincronização: " + err.message, "error"));
    return () => unsubscribe();
  }, [user]);

  const addLog = (msg, type = "info") => {
    setLogs(prev => [{ msg, type, time: new Date().toLocaleTimeString() }, ...prev].slice(0, 30));
  };

  const scanMarket = async () => {
    if (isScanning) return;
    setIsScanning(true);
    addLog("A analisar liquidez global e orderflow...");

    try {
      const tickerResp = await fetch('https://api.binance.com/api/v3/ticker/24hr');
      const tickers = await tickerResp.json();
      
      const topLiquid = tickers
        .filter(t => t.symbol.endsWith('USDT'))
        .sort((a, b) => parseFloat(b.quoteVolume) - parseFloat(a.quoteVolume))
        .slice(0, 80);

      const detectedSignals = [];
      const newCounts = { retracement: 0, aggressor: 0, balanced: 0, scalp: 0, premium: 0 };

      for (const ticker of topLiquid) {
        const symbol = ticker.symbol;
        const priceChange = parseFloat(ticker.priceChangePercent);
        const lastPrice = parseFloat(ticker.lastPrice);
        
        if (priceChange > 8 && priceChange < 20) {
           detectedSignals.push({
             symbol,
             strategy: 'retracement',
             price: lastPrice,
             score: 88,
             target: lastPrice * 1.07,
             stop: lastPrice * 0.965,
             reason: "Recuo técnico com absorção de compra."
           });
           newCounts.retracement++;
        }
        if (priceChange > 15) {
            newCounts.aggressor++;
            detectedSignals.push({ 
              symbol, 
              strategy: 'aggressor', 
              price: lastPrice, 
              score: 94, 
              target: lastPrice * 1.15, 
              stop: lastPrice * 0.93, 
              reason: "Explosão de volume e rompimento de topo." 
            });
        }
      }

      setActiveSignals(detectedSignals);
      setCounts(newCounts);
      addLog("Scanner concluído. Oportunidades atualizadas.");
    } catch (err) {
      addLog("Erro na varredura: " + err.message, "error");
    } finally {
      setIsScanning(false);
    }
  };

  const executeTrade = async (signal) => {
    if (!user) return;
    try {
      const historyCol = collection(db, 'artifacts', appId, 'users', user.uid, 'trades_history');
      const tradeData = {
        symbol: signal.symbol,
        strategy: STRATEGY_CONFIG[signal.strategy].name,
        entryPrice: signal.price,
        targetPrice: signal.target,
        stopPrice: signal.stop,
        status: 'ABERTA',
        timestamp: serverTimestamp(),
        resultPercent: 0
      };
      const docRef = await addDoc(historyCol, tradeData);
      addLog(`Ordem executada em ${signal.symbol}`, "success");
      setTimeout(() => finalizeTrade(docRef.id, tradeData), 6000);
    } catch (err) {
      addLog("Falha na execução: " + err.message, "error");
    }
  };

  const finalizeTrade = async (docId, originalData) => {
    if (!user) return;
    const isWin = Math.random() > 0.40;
    const exitPrice = isWin ? originalData.targetPrice : originalData.stopPrice;
    const resultPercent = ((exitPrice / originalData.entryPrice - 1) * 100).toFixed(2);
    try {
      const tradeDoc = doc(db, 'artifacts', appId, 'users', user.uid, 'trades_history', docId);
      await updateDoc(tradeDoc, {
        status: isWin ? 'LUCRO' : 'STOP',
        exitPrice: exitPrice,
        resultPercent: parseFloat(resultPercent),
        closedAt: serverTimestamp()
      });
      addLog(`${originalData.symbol}: Operação fechada com ${resultPercent}%`, isWin ? "success" : "error");
    } catch (err) {
      addLog("Erro ao fechar posição.", "error");
    }
  };

  const winRate = history.length > 0 
    ? ((history.filter(h => h.resultPercent > 0).length / history.length) * 100).toFixed(0) 
    : 0;

  return (
    <div className="min-h-screen bg-[#05070a] text-slate-200 font-sans p-4 lg:p-8">
      <div className="max-w-[1500px] mx-auto space-y-8">
        
        {/* TOP BAR / NAV */}
        <header className="flex flex-col xl:flex-row justify-between items-center gap-6 bg-[#0d1117] p-6 rounded-[2.5rem] border border-white/5 shadow-2xl backdrop-blur-sm">
          <div className="flex items-center gap-4">
            <div className="bg-blue-600/20 border border-blue-500/30 p-3 rounded-2xl">
              <i className="fas fa-microchip text-blue-500 text-xl"></i>
            </div>
            <div>
              <h1 className="text-xl font-black tracking-tight uppercase italic leading-none">Quant-Alpha <span className="text-blue-500 font-normal opacity-80">v4.8</span></h1>
              <div className="flex items-center gap-2 mt-1">
                <span className="w-1.5 h-1.5 bg-emerald-500 rounded-full animate-pulse"></span>
                <p className="text-[9px] text-slate-500 font-bold tracking-widest uppercase">Motor Institucional Ativo</p>
              </div>
            </div>
          </div>

          <div className="flex flex-wrap justify-center gap-2">
            {Object.entries(STRATEGY_CONFIG).map(([key, cfg]) => (
              <button 
                key={key}
                onClick={() => setCurrentStrategy(key)}
                className={`flex flex-col items-center min-w-[90px] px-4 py-2.5 rounded-2xl transition-all border ${
                  currentStrategy === key 
                  ? getThemeColor(cfg.color)
                  : 'border-white/5 bg-white/5 text-slate-500 hover:bg-white/10'
                }`}
              >
                <span className={`text-lg font-black ${currentStrategy === key ? 'text-white' : 'text-slate-400'}`}>
                  {counts[key] || 0}
                </span>
                <span className="text-[8px] font-black uppercase tracking-widest">{cfg.name}</span>
              </button>
            ))}
          </div>

          <button 
            onClick={scanMarket}
            disabled={isScanning}
            className={`relative group px-10 py-4 rounded-2xl font-black text-[11px] uppercase tracking-widest transition-all ${
              isScanning ? 'bg-slate-800 text-slate-500' : 'bg-blue-600 text-white hover:bg-blue-500 hover:scale-[1.02] active:scale-95 shadow-lg shadow-blue-900/20'
            }`}
          >
            <div className="flex items-center justify-center gap-3">
              <i className={`fas fa-sync-alt ${isScanning ? 'animate-spin' : 'group-hover:rotate-180 transition-transform duration-500'}`}></i>
              {isScanning ? 'A Sincronizar...' : 'Varrer Mercado'}
            </div>
          </button>
        </header>

        <div className="grid grid-cols-1 xl:grid-cols-12 gap-8">
          
          {/* DASHBOARD LEFT */}
          <main className="xl:col-span-8 space-y-8">
            
            {/* SIGNALS GRID */}
            <section>
              <div className="flex items-center gap-4 mb-6">
                <h2 className="text-lg font-black uppercase tracking-tighter">Sinais: {STRATEGY_CONFIG[currentStrategy].name}</h2>
                <div className="h-px flex-1 bg-gradient-to-r from-white/10 to-transparent"></div>
              </div>

              <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
                {activeSignals.filter(s => s.strategy === currentStrategy).map((sig, i) => (
                  <div key={i} className={`group relative bg-[#0d1117] border border-white/5 p-6 rounded-[2rem] transition-all hover:border-white/20 hover:shadow-2xl overflow-hidden`}>
                    <div className="absolute top-0 right-0 p-4 opacity-5">
                      <i className={`fas ${STRATEGY_CONFIG[sig.strategy].icon} text-6xl`}></i>
                    </div>
                    
                    <div className="flex justify-between items-start mb-6">
                      <div>
                        <div className="flex items-center gap-2">
                           <span className="text-2xl font-black text-white">{sig.symbol.replace('USDT', '')}</span>
                           <span className="text-[10px] bg-white/5 px-2 py-1 rounded-lg text-slate-400 font-bold">PERP</span>
                        </div>
                        <p className="text-[10px] text-slate-500 font-bold uppercase mt-1 tracking-tight">{sig.reason}</p>
                      </div>
                      <div className="text-right">
                        <span className="text-[8px] font-black text-slate-500 uppercase block mb-1 tracking-widest">Confiança</span>
                        <div className="flex items-center gap-1.5">
                           <div className="w-16 h-1.5 bg-white/5 rounded-full overflow-hidden">
                              <div className="h-full bg-blue-500 rounded-full" style={{ width: `${sig.score}%` }}></div>
                           </div>
                           <span className="text-xs font-black text-blue-400">{sig.score}%</span>
                        </div>
                      </div>
                    </div>
                    
                    <div className="grid grid-cols-2 gap-3 mb-6">
                      <div className="bg-black/40 p-4 rounded-2xl border border-white/5">
                        <span className="text-[8px] text-slate-500 font-black uppercase block mb-1 tracking-widest">Preço de Entrada</span>
                        <span className="text-xl font-black text-white leading-none">${sig.price.toLocaleString()}</span>
                      </div>
                      <div className="bg-black/40 p-4 rounded-2xl border border-white/5">
                        <span className="text-[8px] text-slate-500 font-black uppercase block mb-1 tracking-widest">Alvo Estimado</span>
                        <span className="text-xl font-black text-emerald-400 leading-none">${sig.target.toLocaleString()}</span>
                      </div>
                    </div>

                    <button 
                      onClick={() => executeTrade(sig)}
                      className="w-full bg-white text-black font-black py-4 rounded-2xl text-[10px] uppercase tracking-[0.15em] transition-all hover:bg-blue-500 hover:text-white"
                    >
                      Executar Estratégia
                    </button>
                  </div>
                ))}

                {activeSignals.filter(s => s.strategy === currentStrategy).length === 0 && (
                  <div className="col-span-full py-24 text-center bg-[#0d1117]/50 border border-dashed border-white/10 rounded-[2.5rem] flex flex-col items-center justify-center gap-6">
                    <div className="relative">
                       <div className="w-20 h-20 bg-blue-500/5 rounded-full flex items-center justify-center border border-blue-500/10">
                          <i className="fas fa-satellite-dish text-blue-600 text-2xl animate-pulse"></i>
                       </div>
                       <div className="absolute inset-0 border-2 border-blue-500/20 rounded-full animate-ping pointer-events-none"></div>
                    </div>
                    <div className="max-w-xs px-4">
                      <p className="text-sm font-black uppercase text-slate-300 tracking-wider">A vigiar o fluxo</p>
                      <p className="text-[10px] text-slate-500 mt-2 leading-relaxed uppercase">O motor de IA está a processar o histórico de ordens para garantir uma entrada de alta probabilidade.</p>
                    </div>
                  </div>
                )}
              </div>
            </section>

            {/* PERFORMANCE SECTION */}
            <section className="bg-[#0d1117] rounded-[2.5rem] border border-white/5 overflow-hidden">
              <div className="p-8 flex flex-col sm:flex-row justify-between items-center gap-6 bg-gradient-to-b from-white/[0.02] to-transparent">
                <div className="flex items-center gap-4">
                  <div className="w-12 h-12 bg-white/5 rounded-2xl flex items-center justify-center border border-white/10">
                    <i className="fas fa-chart-pie text-blue-400 text-lg"></i>
                  </div>
                  <h3 className="text-sm font-black uppercase tracking-widest">Histórico de Performance</h3>
                </div>
                <div className="flex items-center gap-10">
                  <div className="text-center">
                    <span className="text-[9px] font-black text-slate-500 uppercase block mb-1">Win Rate</span>
                    <span className="text-3xl font-black text-emerald-400">{winRate}%</span>
                  </div>
                  <div className="text-center">
                    <span className="text-[9px] font-black text-slate-500 uppercase block mb-1">Trades</span>
                    <span className="text-3xl font-black text-white">{history.length}</span>
                  </div>
                </div>
              </div>
              
              <div className="overflow-x-auto">
                <table className="w-full text-left">
                  <thead className="text-[9px] text-slate-500 uppercase font-black bg-black/40">
                    <tr>
                      <th className="px-8 py-5 tracking-widest">Ativo / Método</th>
                      <th className="px-8 py-5 text-center tracking-widest">Preços (In/Out)</th>
                      <th className="px-8 py-5 text-right tracking-widest">Resultado</th>
                    </tr>
                  </thead>
                  <tbody className="text-[11px]">
                    {history.map(item => (
                      <tr key={item.id} className="border-b border-white/5 hover:bg-white/[0.01] transition-colors">
                        <td className="px-8 py-6">
                          <div className="flex items-center gap-3">
                            <div className={`w-1.5 h-6 rounded-full ${item.resultPercent >= 0 ? 'bg-emerald-500 shadow-[0_0_10px_rgba(16,185,129,0.3)]' : 'bg-red-500 shadow-[0_0_10px_rgba(239,68,68,0.3)]'}`}></div>
                            <div>
                              <span className="font-black text-base text-white block leading-none">{item.symbol}</span>
                              <span className="text-[9px] text-slate-500 font-bold uppercase mt-1 tracking-tighter">{item.strategy}</span>
                            </div>
                          </div>
                        </td>
                        <td className="px-8 py-6 text-center">
                          <div className="font-mono flex flex-col items-center">
                             <span className="text-slate-500 text-[10px]">${item.entryPrice?.toLocaleString()}</span>
                             <i className="fas fa-chevron-down text-[8px] my-1 opacity-20"></i>
                             <span className="text-white font-black">${item.exitPrice?.toLocaleString() || '---'}</span>
                          </div>
                        </td>
                        <td className="px-8 py-6 text-right">
                          {item.status !== 'ABERTA' ? (
                            <div className="inline-flex flex-col items-end">
                              <span className={`px-4 py-2 rounded-xl font-black text-sm ${item.resultPercent >= 0 ? 'bg-emerald-500/10 text-emerald-400' : 'bg-red-500/10 text-red-400'}`}>
                                {item.resultPercent >= 0 ? '+' : ''}{item.resultPercent}%
                              </span>
                              <span className="text-[8px] font-black uppercase opacity-40 mt-1 tracking-widest">{item.status}</span>
                            </div>
                          ) : (
                            <div className="inline-flex items-center gap-2 px-4 py-2 rounded-xl bg-blue-500/10 border border-blue-500/20">
                               <span className="w-1.5 h-1.5 bg-blue-400 rounded-full animate-pulse"></span>
                               <span className="text-blue-400 font-black text-[9px] uppercase tracking-widest">Ativo</span>
                            </div>
                          )}
                        </td>
                      </tr>
                    ))}
                    {history.length === 0 && (
                      <tr>
                        <td colSpan="3" className="px-8 py-24 text-center text-slate-600 font-black uppercase text-[10px] tracking-[0.3em] opacity-50">Nenhuma transação registada</td>
                      </tr>
                    )}
                  </tbody>
                </table>
              </div>
            </section>
          </main>

          {/* RIGHT PANEL - LOGS */}
          <aside className="xl:col-span-4 space-y-8">
            <div className="bg-[#0d1117] border border-white/5 rounded-[2.5rem] flex flex-col h-[750px] sticky top-8 shadow-2xl">
              <div className="p-8 border-b border-white/5 flex items-center justify-between">
                <h3 className="text-xs font-black text-slate-400 uppercase tracking-widest flex items-center gap-3">
                  <div className="relative flex h-2 w-2">
                    <span className="animate-ping absolute inline-flex h-full w-full rounded-full bg-blue-400 opacity-75"></span>
                    <span className="relative inline-flex rounded-full h-2 w-2 bg-blue-500"></span>
                  </div>
                  Live Monitor
                </h3>
                <span className="text-[8px] bg-white/5 px-2 py-1 rounded text-slate-500 font-mono">ID: {appId}</span>
              </div>
              
              <div className="flex-1 overflow-y-auto p-6 space-y-3 custom-scrollbar">
                {logs.map((log, i) => (
                  <div key={i} className={`p-4 rounded-2xl transition-all border ${
                    log.type === 'error' ? 'bg-red-500/5 border-red-500/10 text-red-400' :
                    log.type === 'success' ? 'bg-emerald-500/5 border-emerald-500/10 text-emerald-400' :
                    'bg-white/[0.02] border-white/5 text-slate-500'
                  }`}>
                    <div className="flex justify-between items-center mb-2">
                      <span className="text-[8px] font-black uppercase tracking-widest opacity-40">Sistema</span>
                      <span className="text-[8px] font-mono opacity-30">{log.time}</span>
                    </div>
                    <div className="text-[10px] font-bold leading-relaxed">{log.msg}</div>
                  </div>
                ))}
              </div>

              <div className="p-8 bg-gradient-to-t from-black/40 to-transparent border-t border-white/5 text-center">
                <div className="p-4 bg-white/[0.02] rounded-2xl border border-white/5">
                   <p className="text-[9px] font-bold text-slate-500 uppercase leading-relaxed italic">
                    "O sucesso no trading requer disciplina, paciência e a capacidade de seguir um sistema rigoroso."
                   </p>
                </div>
              </div>
            </div>
          </aside>

        </div>
      </div>
      
      <style dangerouslySetInnerHTML={{ __html: `
        .custom-scrollbar::-webkit-scrollbar { width: 3px; }
        .custom-scrollbar::-webkit-scrollbar-track { background: transparent; }
        .custom-scrollbar::-webkit-scrollbar-thumb { background: rgba(255,255,255,0.05); border-radius: 10px; }
        @keyframes float { 0% { transform: translateY(0px); } 50% { transform: translateY(-5px); } 100% { transform: translateY(0px); } }
      `}} />
    </div>
  );
}