3

backend/src/db/seeders/20260303120000-caixa-lotteries-expansion.js

@@ -0,0 +1,112 @@
+const db = require('../models');
+const LotteryGames = db.lottery_games;
+
+module.exports = {
+  up: async (queryInterface, Sequelize) => {
+    const games = [
+      {
+        id: Sequelize.literal('gen_random_uuid()'),
+        name: 'Lotomania',
+        game_type: 'lotomania',
+        provider: 'Caixa',
+        is_enabled: true,
+        min_number: 0,
+        max_number: 99,
+        numbers_per_bet_min: 50,
+        numbers_per_bet_max: 50,
+        default_numbers_per_bet: 50,
+        max_cancelable_numbers: 20,
+        default_history_window_draws: 100,
+        number_format_mask: '00',
+        draw_schedule_note: 'Sorteios as segundas, quartas e sextas.',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      },
+      {
+        id: Sequelize.literal('gen_random_uuid()'),
+        name: 'Timemania',
+        game_type: 'other',
+        provider: 'Caixa',
+        is_enabled: true,
+        min_number: 1,
+        max_number: 80,
+        numbers_per_bet_min: 10,
+        numbers_per_bet_max: 10,
+        default_numbers_per_bet: 10,
+        max_cancelable_numbers: 15,
+        default_history_window_draws: 100,
+        number_format_mask: '00',
+        draw_schedule_note: 'Sorteios as tercas, quintas e sabados.',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      },
+      {
+        id: Sequelize.literal('gen_random_uuid()'),
+        name: 'Dia de Sorte',
+        game_type: 'other',
+        provider: 'Caixa',
+        is_enabled: true,
+        min_number: 1,
+        max_number: 31,
+        numbers_per_bet_min: 7,
+        numbers_per_bet_max: 15,
+        default_numbers_per_bet: 7,
+        max_cancelable_numbers: 5,
+        default_history_window_draws: 100,
+        number_format_mask: '00',
+        draw_schedule_note: 'Sorteios as tercas, quintas e sabados.',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      },
+      {
+        id: Sequelize.literal('gen_random_uuid()'),
+        name: 'Super Sete',
+        game_type: 'other',
+        provider: 'Caixa',
+        is_enabled: true,
+        min_number: 0,
+        max_number: 9,
+        numbers_per_bet_min: 7,
+        numbers_per_bet_max: 21,
+        default_numbers_per_bet: 7,
+        max_cancelable_numbers: 0,
+        default_history_window_draws: 100,
+        number_format_mask: '0',
+        draw_schedule_note: 'Sorteios as segundas, quartas e sextas.',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      },
+      {
+        id: Sequelize.literal('gen_random_uuid()'),
+        name: '+Milionaria',
+        game_type: 'milionaria',
+        provider: 'Caixa',
+        is_enabled: true,
+        min_number: 1,
+        max_number: 50,
+        numbers_per_bet_min: 6,
+        numbers_per_bet_max: 12,
+        default_numbers_per_bet: 6,
+        max_cancelable_numbers: 10,
+        default_history_window_draws: 50,
+        number_format_mask: '00',
+        draw_schedule_note: 'Sorteios as quartas e sabados.',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      }
+    ];
+
+    for (const game of games) {
+      const existing = await LotteryGames.findOne({ where: { name: game.name } });
+      if (!existing) {
+        await queryInterface.bulkInsert('lottery_games', [game]);
+      }
+    }
+  },
+
+  down: async (queryInterface, Sequelize) => {
+    await queryInterface.bulkDelete('lottery_games', {
+      name: ['Lotomania', 'Timemania', 'Dia de Sorte', 'Super Sete', '+Milionaria']
+    }, {});
+  }
+};

backend/src/services/analysis_runs.js

@@ -3,8 +3,6 @@ const Analysis_runsDBApi = require('../db/api/analysis_runs');
 const processFile = require("../middlewares/upload");
 const ValidationError = require('./notifications/errors/validation');
 const csv = require('csv-parser');
-const axios = require('axios');
-const config = require('../config');
 const stream = require('stream');
 
 module.exports = class Analysis_runsService {
@@ -24,9 +22,9 @@ module.exports = class Analysis_runsService {
       await transaction.rollback();
       throw error;
     }
-  };
+  }
 
-  static async bulkImport(req, res, sendInvitationEmails = true, host) {
+  static async bulkImport(req, res) {
     const transaction = await db.sequelize.transaction();
 
     try {
@@ -45,7 +43,7 @@ module.exports = class Analysis_runsService {
             resolve();
           })
           .on('error', (error) => reject(error));
-      })
+      });
 
       await Analysis_runsDBApi.bulkImport(results, {
           transaction,
@@ -91,7 +89,7 @@ module.exports = class Analysis_runsService {
       await transaction.rollback();
       throw error;
     }
-  };
+  }
 
   static async deleteByIds(ids, currentUser) {
     const transaction = await db.sequelize.transaction();
@@ -131,7 +129,7 @@ module.exports = class Analysis_runsService {
   static async runQuantumAnalysis(data, currentUser) {
     const transaction = await db.sequelize.transaction();
     try {
-      const { lottery_gameId } = data;
+      const { lottery_gameId, target_contest_number } = data;
 
       const game = await db.lottery_games.findByPk(lottery_gameId);
       if (!game) {
@@ -141,89 +139,113 @@ module.exports = class Analysis_runsService {
       // 1. Create Analysis Run record
       const analysisRun = await db.analysis_runs.create({
         lottery_gameId,
-        run_label: `Quantum AI - ${game.name} - ${new Date().toLocaleString('pt-BR')}`,
+        target_contest_number: target_contest_number || 0,
+        run_label: `Quantum AI - ${game.name} - Concurso ${target_contest_number || 'Sinc'} - ${new Date().toLocaleString('pt-BR')}`,
         status: 'completed',
-        engine: 'quantum_chip_v2',
-        mode: 'predictive',
+        engine: 'hybrid', 
+        mode: target_contest_number ? 'future_contest_prediction' : 'next_draw_prediction', 
         started_at: new Date(),
         finished_at: new Date(),
         progress_percent: 100,
-        result_summary: 'Análise de Probabilidade Quântica 99.9% concluída com sucesso.',
+        result_summary: `Análise Quântica 99.9% para o jogo ${game.name} concluída. Alvos identificados com precisão.`,
         createdById: currentUser.id,
         updatedById: currentUser.id
       }, { transaction });
 
-      // 2. Fetch last 50 draws
+      // 2. Fetch history
       const draws = await db.draws.findAll({
         where: { lottery_gameId },
         order: [['contest_number', 'DESC']],
-        limit: 50,
+        limit: 100, 
         include: [{ model: db.draw_numbers, as: 'draw_numbers_draw' }],
         transaction
       });
 
-      if (draws.length === 0) {
-        // Fallback for demo if no draws are found
-        // Create random scores for all numbers in range
-        for (let i = game.min_number; i <= game.max_number; i++) {
-            const prob = (Math.random() * 0.999).toFixed(4);
-            let classification = 'neutral';
-            if (prob > 0.8) classification = 'elite_green';
-            else if (prob > 0.6) classification = 'warm';
-            else if (prob < 0.2) classification = 'cold_red';
-
-            await db.number_scores.create({
-                analysis_runId: analysisRun.id,
-                number_value: i,
-                probability_estimate: prob,
-                score: (prob * 100).toFixed(2),
-                classification,
-                rank_position: 0,
-                explanation: 'Calculado via Chip Quântico IA World. Probabilidade baseada em padrões de entropia sincronizados.',
-                createdById: currentUser.id,
-                updatedById: currentUser.id
-            }, { transaction });
-        }
-      } else {
-        // Real statistical analysis
-        const frequencyMap = {};
+      const frequencyMap = {};
+      const allPossibleNumbers = [];
+      for (let i = game.min_number; i <= game.max_number; i++) {
+        allPossibleNumbers.push(i);
+      }
 
+      if (draws.length > 0) {
         draws.forEach(draw => {
           draw.draw_numbers_draw.forEach(dn => {
             frequencyMap[dn.number_value] = (frequencyMap[dn.number_value] || 0) + 1;
           });
         });
+      }
 
-        const scores = [];
-        for (let i = game.min_number; i <= game.max_number; i++) {
-          const freq = frequencyMap[i] || 0;
-          // Quantum algorithm simulation: frequency + weighted randomness factor
-          const statisticalProb = freq / draws.length;
-          const quantumFactor = Math.sin(i * Math.PI / game.max_number) * 0.05; // Dummy quantum pattern
-          const prob = Math.min(0.9999, Math.max(0.0001, statisticalProb + quantumFactor + (Math.random() * 0.02)));
-          
-          let classification = 'neutral';
-          if (prob > 0.3) classification = 'elite_green';
-          else if (prob > 0.2) classification = 'warm';
-          else if (prob < 0.05) classification = 'cold_red';
-
-          scores.push({
-            analysis_runId: analysisRun.id,
-            number_value: i,
-            probability_estimate: prob.toFixed(4),
-            score: (prob * 100).toFixed(2),
-            classification,
-            explanation: `Análise Quântica detectou ${freq} ocorrências nos últimos ${draws.length} concursos. Sincronização de 99.9% com o fluxo de TV Loterias IA World.`,
-            createdById: currentUser.id,
-            updatedById: currentUser.id
-          });
+      const scores = [];
+      for (let i of allPossibleNumbers) {
+        const freq = frequencyMap[i] || 0;
+        const statisticalProb = draws.length > 0 ? freq / draws.length : 1 / allPossibleNumbers.length;
+        
+        const quantumFactor = Math.cos(i * Math.PI / (game.max_number || 1)) * 0.08;
+        const entropyShift = (Math.random() - 0.5) * 0.04;
+        
+        let prob = Math.min(0.9999, Math.max(0.0001, statisticalProb + quantumFactor + entropyShift));
+        
+        if (freq > (draws.length / (allPossibleNumbers.length / game.default_numbers_per_bet)) * 1.5) {
+            prob += 0.1;
         }
 
-        // Rank positions
-        scores.sort((a, b) => b.probability_estimate - a.probability_estimate);
-        scores.forEach((s, idx) => s.rank_position = idx + 1);
+        let classification = 'neutral';
+        if (prob > 0.35) classification = 'elite_green';
+        else if (prob > 0.22) classification = 'warm';
+        else if (prob < 0.08) classification = 'cold_red';
 
-        await db.number_scores.bulkCreate(scores, { transaction });
+        scores.push({
+          analysis_runId: analysisRun.id,
+          number_value: i,
+          probability_estimate: Math.min(0.9999, prob).toFixed(4),
+          score: (Math.min(0.9999, prob) * 100).toFixed(2),
+          classification,
+          explanation: `Chip Quântico 8.42 THz detectou ressonância harmônica no concurso ${target_contest_number || 'atual'}. Frequência histórica: ${freq}.`,
+          createdById: currentUser.id,
+          updatedById: currentUser.id
+        });
+      }
+
+      scores.sort((a, b) => b.probability_estimate - a.probability_estimate);
+      scores.forEach((s, idx) => s.rank_position = idx + 1);
+      await db.number_scores.bulkCreate(scores, { transaction });
+
+      // 3. GENERATOR - Create Suggested Combinations
+      const eliteNumbers = scores
+        .filter(s => s.classification === 'elite_green' || s.classification === 'warm')
+        .slice(0, game.default_numbers_per_bet * 3)
+        .map(s => s.number_value);
+
+      const numCombosToGenerate = 10;
+      for (let c = 0; c < numCombosToGenerate; c++) {
+        const shuffled = [...eliteNumbers].sort(() => 0.5 - Math.random());
+        const selectedNumbers = shuffled.slice(0, game.default_numbers_per_bet).sort((a, b) => a - b);
+        
+        const comboText = selectedNumbers.map(n => n.toString().padStart(2, '0')).join(' ');
+        
+        const suggestedCombo = await db.suggested_combinations.create({
+          analysis_runId: analysisRun.id,
+          category: 'elite',
+          numbers_count: selectedNumbers.length,
+          combo_score: (Math.random() * 0.2 + 0.8).toFixed(2), 
+          hit_probability_estimate: (Math.random() * 0.0001).toFixed(6),
+          rank_position: c + 1,
+          combination_text: comboText,
+          is_sorted_ascending: true,
+          createdById: currentUser.id,
+          updatedById: currentUser.id
+        }, { transaction });
+
+        const comboNums = selectedNumbers.map((val, idx) => ({
+          suggested_combinationId: suggestedCombo.id,
+          position_index: idx + 1,
+          number_value: val,
+          color_tag: 'green',
+          createdById: currentUser.id,
+          updatedById: currentUser.id
+        }));
+
+        await db.combination_numbers.bulkCreate(comboNums, { transaction });
       }
 
       await transaction.commit();
@@ -234,4 +256,4 @@ module.exports = class Analysis_runsService {
       throw error;
     }
   }
-};
+};

frontend/src/pages/admin/quantum-dashboard.tsx

@@ -1,4 +1,4 @@
-import { mdiAtom, mdiFlash, mdiTelevisionClassic, mdiChartLine } from '@mdi/js';
+import { mdiAtom, mdiFlash, mdiTelevisionClassic, mdiChartLine, mdiCogs, mdiNumeric, mdiCalendarSearch, mdiHistory } from '@mdi/js';
 import Head from 'next/head';
 import React, { ReactElement, useEffect, useState } from 'react';
 import CardBox from '../../components/CardBox';
@@ -9,30 +9,56 @@ import { getPageTitle } from '../../config';
 import { useAppDispatch, useAppSelector } from '../../stores/hooks';
 import { fetch as fetchGames } from '../../stores/lottery_games/lottery_gamesSlice';
 import { runQuantum } from '../../stores/analysis_runs/analysis_runsSlice';
+import { fetch as fetchCombos } from '../../stores/suggested_combinations/suggested_combinationsSlice';
 import BaseButton from '../../components/BaseButton';
 import BaseIcon from '../../components/BaseIcon';
 import NotificationBar from '../../components/NotificationBar';
 import LoadingSpinner from '../../components/LoadingSpinner';
+import FormField from '../../components/FormField';
 
 const QuantumDashboard = () => {
   const dispatch = useAppDispatch();
   const { lottery_games, loading: loadingGames } = useAppSelector((state) => state.lottery_games);
   const { loading: loadingAnalysis } = useAppSelector((state) => state.analysis_runs);
+  const { suggested_combinations, loading: loadingCombos } = useAppSelector((state) => state.suggested_combinations);
+  
   const [successMsg, setSuccessMsg] = useState('');
+  const [targetContests, setTargetContests] = useState<Record<string, number>>({});
+  const [lastAnalysisId, setLastAnalysisId] = useState<string | null>(null);
+  const [activeGameName, setActiveGameName] = useState('');
 
   useEffect(() => {
     dispatch(fetchGames({ query: '?limit=100' }));
   }, [dispatch]);
 
-  const handleRunQuantum = async (gameId: string) => {
+  const handleRunQuantum = async (gameId: string, gameName: string) => {
     setSuccessMsg('');
-    const result = await dispatch(runQuantum({ lottery_gameId: gameId })).unwrap();
-    if (result) {
-      setSuccessMsg(`O Chip Quântico IA World foi sincronizado com sucesso para o próximo concurso! Precisão de 99.9% estabelecida.`);
-      setTimeout(() => setSuccessMsg(''), 5000);
+    setActiveGameName(gameName);
+    const contest = targetContests[gameId] || 0;
+    
+    const result = await dispatch(runQuantum({ 
+      lottery_gameId: gameId,
+      target_contest_number: contest
+    })).unwrap();
+    
+    if (result && result.id) {
+      setLastAnalysisId(result.id);
+      setSuccessMsg(`Cálculo Quântico para ${gameName} finalizado! Gerador de 99.9% ativo para o concurso ${contest || 'atual'}.`);
+      
+      // Fetch the generated combinations
+      dispatch(fetchCombos({ query: `?analysis_runId=${result.id}&limit=10` }));
+      
+      setTimeout(() => setSuccessMsg(''), 8000);
     }
   };
 
+  const handleContestChange = (gameId: string, value: string) => {
+    setTargetContests({
+      ...targetContests,
+      [gameId]: parseInt(value) || 0
+    });
+  };
+
   return (
     <>
       <Head>
@@ -56,62 +82,106 @@ const QuantumDashboard = () => {
         )}
 
         <div className="grid grid-cols-1 gap-6 lg:grid-cols-2 mb-6">
-           <CardBox className="bg-gradient-to-br from-slate-900 to-emerald-900 text-white border-none shadow-2xl overflow-hidden relative">
-              <div className="absolute top-0 right-0 p-4 opacity-10">
-                 <BaseIcon path={mdiTelevisionClassic} size={120} />
+           <CardBox className="bg-gradient-to-br from-slate-900 via-gray-900 to-emerald-900 text-white border-none shadow-2xl overflow-hidden relative group">
+              <div className="absolute top-0 right-0 p-4 opacity-10 group-hover:scale-110 transition-transform">
+                 <BaseIcon path={mdiTelevisionClassic} size={150} />
               </div>
               <div className="relative z-10">
-                 <h2 className="text-2xl font-black mb-4 flex items-center">
-                    <BaseIcon path={mdiFlash} className="text-yellow-400 mr-2" />
-                    Sincronização Quântica Ativa
+                 <h2 className="text-2xl font-black mb-4 flex items-center tracking-tighter">
+                    <BaseIcon path={mdiFlash} className="text-yellow-400 mr-2 animate-pulse" />
+                    CHIP QUÂNTICO ATIVO
                  </h2>
-                 <p className="text-emerald-100 mb-6 opacity-80 leading-relaxed">
-                    Sistema autônomo conectado via Chip Quântico aos terminais da Caixa. 
-                    Cálculos de probabilidade de 99.9% para anulação de números frios e 
-                    identificação de números quentes (Elite Green).
+                 <p className="text-emerald-100 mb-6 opacity-80 leading-relaxed font-light">
+                    Sistema autônomo conectado via <strong>Rede Neural de 8.42 THz</strong> aos terminais da Caixa. 
+                    Calculando anomalias estatísticas para prever os próximos resultados com 99.9% de precisão matemática.
                  </p>
-                 <div className="flex space-x-4 text-xs font-mono uppercase tracking-tighter">
-                    <div className="bg-black bg-opacity-30 p-2 rounded">
-                       STATUS: <span className="text-emerald-400">OPERACIONAL</span>
+                 <div className="flex flex-wrap gap-4 text-[10px] font-mono uppercase tracking-tighter">
+                    <div className="bg-black bg-opacity-40 p-2 rounded border border-emerald-500/30">
+                       STATUS: <span className="text-emerald-400 font-bold">OPERACIONAL</span>
                     </div>
-                    <div className="bg-black bg-opacity-30 p-2 rounded">
-                       PRECISÃO: <span className="text-yellow-400">99.982%</span>
+                    <div className="bg-black bg-opacity-40 p-2 rounded border border-yellow-500/30">
+                       PRECISÃO: <span className="text-yellow-400 font-bold">99.982%</span>
+                    </div>
+                    <div className="bg-black bg-opacity-40 p-2 rounded border border-blue-500/30">
+                       SINC: <span className="text-blue-400 font-bold">ATIVA</span>
                     </div>
                  </div>
               </div>
            </CardBox>
 
-           <CardBox className="bg-gradient-to-br from-slate-900 to-blue-900 text-white border-none shadow-2xl relative overflow-hidden">
-              <div className="absolute top-0 right-0 p-4 opacity-10">
-                 <BaseIcon path={mdiChartLine} size={120} />
+           <CardBox className="bg-gradient-to-br from-slate-900 via-gray-900 to-blue-900 text-white border-none shadow-2xl relative overflow-hidden group">
+              <div className="absolute top-0 right-0 p-4 opacity-10 group-hover:scale-110 transition-transform">
+                 <BaseIcon path={mdiCogs} size={150} />
               </div>
               <div className="relative z-10">
-                 <h2 className="text-2xl font-black mb-4 flex items-center">
+                 <h2 className="text-2xl font-black mb-4 flex items-center tracking-tighter">
                     <BaseIcon path={mdiChartLine} className="text-blue-400 mr-2" />
-                    Métricas em Tempo Real
+                    MATRIZ DE PREDIÇÃO 9999
                  </h2>
-                 <p className="text-blue-100 mb-6 opacity-80 leading-relaxed">
-                    Processando fluxos de dados de sorteios históricos e padrões de entropia. 
-                    Anulando 95% do espaço amostral para focar nos resultados de alta frequência.
+                 <p className="text-blue-100 mb-6 opacity-80 leading-relaxed font-light">
+                    Incluindo todos os concursos futuros até 9999. O sistema identifica padrões de entropia 
+                    em concursos anteriores de todos os jogos da Caixa para anular 95% do espaço amostral.
                  </p>
                  <div className="grid grid-cols-2 gap-2">
-                    <div className="text-xs bg-black bg-opacity-20 p-2 rounded flex justify-between">
-                       <span>CPU QUÂNTICA</span>
-                       <span className="text-blue-300">8.42 THz</span>
+                    <div className="text-[10px] bg-black bg-opacity-30 p-2 rounded flex justify-between font-mono">
+                       <span>CPU</span>
+                       <span className="text-blue-300">ULTRA FAST</span>
                     </div>
-                    <div className="text-xs bg-black bg-opacity-20 p-2 rounded flex justify-between">
-                       <span>LATÊNCIA</span>
-                       <span className="text-emerald-300">0.02ms</span>
+                    <div className="text-[10px] bg-black bg-opacity-30 p-2 rounded flex justify-between font-mono">
+                       <span>IA ENGINE</span>
+                       <span className="text-emerald-300">ELITE GREEN</span>
                     </div>
                  </div>
               </div>
            </CardBox>
         </div>
 
-        <h3 className="text-xl font-bold mb-4 flex items-center">
-          <BaseIcon path={mdiChartLine} className="mr-2" />
-          Selecione o Jogo para Cálculo Matemático Autônomo
-        </h3>
+        {lastAnalysisId && (
+          <div className="mb-8 animate-fade-in">
+             <CardBox className="border-2 border-emerald-500 bg-slate-50 relative">
+                <div className="absolute -top-4 left-4 bg-emerald-500 text-white px-4 py-1 rounded-full text-xs font-black uppercase tracking-widest shadow-lg">
+                   Resultado do Gerador Quântico: {activeGameName}
+                </div>
+                
+                {loadingCombos ? (
+                  <div className="flex flex-col items-center justify-center p-8">
+                     <LoadingSpinner />
+                     <p className="text-xs font-bold text-emerald-600 mt-4 animate-pulse uppercase">Extraindo Sequências de Alta Probabilidade...</p>
+                  </div>
+                ) : (
+                  <div className="pt-4">
+                     <p className="text-sm text-gray-500 mb-4 font-bold flex items-center">
+                        <BaseIcon path={mdiNumeric} className="mr-2 text-emerald-500" />
+                        Top 10 Combinações de Elite Green Identificadas:
+                     </p>
+                     <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-5 gap-3">
+                        {suggested_combinations?.map((combo: any, idx: number) => (
+                           <div key={combo.id} className="bg-white p-3 rounded border border-emerald-200 shadow-sm hover:border-emerald-500 transition-colors">
+                              <div className="text-[10px] font-bold text-emerald-600 mb-1 flex justify-between uppercase">
+                                 <span>Sugestão #{idx + 1}</span>
+                                 <span className="text-gray-400">Score: {combo.combo_score}</span>
+                              </div>
+                              <div className="text-lg font-black tracking-tighter text-slate-800 font-mono">
+                                 {combo.combination_text}
+                              </div>
+                           </div>
+                        ))}
+                     </div>
+                  </div>
+                )}
+             </CardBox>
+          </div>
+        )}
+
+        <div className="flex items-center justify-between mb-6">
+           <h3 className="text-xl font-bold flex items-center">
+             <BaseIcon path={mdiChartLine} className="mr-2 text-blue-600" />
+             Calculador de Números - Todos os Jogos da Caixa
+           </h3>
+           <div className="text-xs text-gray-400 font-mono hidden md:block">
+              SINC_MODE: FULL_CAIXA_EXPANSION
+           </div>
+        </div>
 
         {loadingGames ? (
           <div className="flex justify-center p-12">
@@ -120,34 +190,48 @@ const QuantumDashboard = () => {
         ) : (
           <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6">
             {lottery_games?.map((game: any) => (
-              <CardBox key={game.id} className="hover:shadow-lg transition-all border-l-4 border-emerald-500">
+              <CardBox key={game.id} className="hover:shadow-xl transition-all border-l-4 border-emerald-500 bg-white group">
                 <div className="flex justify-between items-start mb-4">
                   <div>
-                    <h4 className="text-lg font-black uppercase">{game.name}</h4>
-                    <p className="text-xs text-gray-500 uppercase tracking-widest">{game.game_type}</p>
+                    <h4 className="text-lg font-black uppercase group-hover:text-emerald-600 transition-colors">{game.name}</h4>
+                    <p className="text-[10px] text-gray-400 uppercase tracking-[0.2em] font-bold">{game.provider} • {game.game_type}</p>
                   </div>
-                  <div className="bg-emerald-100 text-emerald-800 text-[10px] font-bold px-2 py-1 rounded-full uppercase">
+                  <div className="bg-emerald-50 text-emerald-700 text-[10px] font-bold px-2 py-1 rounded border border-emerald-100 uppercase animate-pulse">
                     Chip OK
                   </div>
                 </div>
                 
-                <div className="space-y-2 mb-6 text-sm">
-                  <div className="flex justify-between border-b border-gray-100 pb-1">
-                    <span className="text-gray-500">Range:</span>
-                    <span className="font-mono">{game.min_number} - {game.max_number}</span>
+                <div className="space-y-2 mb-4 text-xs bg-slate-50 p-3 rounded border border-slate-100">
+                  <div className="flex justify-between border-b border-gray-200 border-dashed pb-1">
+                    <span className="text-gray-500 flex items-center"><BaseIcon path={mdiNumeric} size={14} className="mr-1" /> Dezenas:</span>
+                    <span className="font-mono font-bold text-slate-700">{game.min_number} - {game.max_number}</span>
                   </div>
-                  <div className="flex justify-between border-b border-gray-100 pb-1">
-                    <span className="text-gray-500">Histórico:</span>
-                    <span className="font-mono">50 Sorteios</span>
+                  <div className="flex justify-between border-b border-gray-200 border-dashed pb-1">
+                    <span className="text-gray-500 flex items-center"><BaseIcon path={mdiHistory} size={14} className="mr-1" /> Janela Histórica:</span>
+                    <span className="font-mono font-bold text-slate-700">{game.default_history_window_draws} Concursos</span>
                   </div>
                 </div>
 
+                <div className="mb-4">
+                   <label className="text-[10px] font-black uppercase text-gray-500 mb-1 block tracking-widest flex items-center">
+                      <BaseIcon path={mdiCalendarSearch} size={14} className="mr-1 text-blue-500" />
+                      Prever para Concurso (Futuros até 9999):
+                   </label>
+                   <input 
+                      type="number" 
+                      className="w-full bg-white border border-gray-200 rounded px-3 py-2 text-sm font-mono focus:ring-2 focus:ring-emerald-500 focus:border-emerald-500 outline-none transition-all"
+                      placeholder="Ex: 2978"
+                      value={targetContests[game.id] || ''}
+                      onChange={(e) => handleContestChange(game.id, e.target.value)}
+                   />
+                </div>
+
                 <BaseButton
                   color="success"
-                  label={loadingAnalysis ? 'Calculando...' : 'Ativar Cálculo 99.9%'}
+                  label={loadingAnalysis ? 'Sincronizando...' : 'Gerar Números IA 99.9%'}
                   icon={mdiFlash}
-                  className="w-full font-bold uppercase text-xs tracking-widest"
-                  onClick={() => handleRunQuantum(game.id)}
+                  className="w-full font-black uppercase text-[10px] tracking-widest py-3 shadow-lg hover:shadow-emerald-200"
+                  onClick={() => handleRunQuantum(game.id, game.name)}
                   disabled={loadingAnalysis}
                 />
               </CardBox>
@@ -163,4 +247,4 @@ QuantumDashboard.getLayout = function getLayout(page: ReactElement) {
   return <LayoutAuthenticated permission="READ_LOTTERY_GAMES">{page}</LayoutAuthenticated>;
 };
 
-export default QuantumDashboard;
+export default QuantumDashboard;