import os
import sys
from collections import deque

# Culori pentru terminal (funcționează pe Windows, Linux, Mac)
class Culori:
    RESET = '\033[0m'
    BOLD = '\033[1m'
    
    ROSU = '\033[91m'
    VERDE = '\033[92m'
    GALBEN = '\033[93m'
    ALBASTRU = '\033[94m'
    MAGENTA = '\033[95m'
    CYAN = '\033[96m'
    ALB = '\033[97m'
    
    BG_VERDE = '\033[102m'
    BG_ROSU = '\033[101m'
    BG_GALBEN = '\033[103m'
    BG_CYAN = '\033[106m'

def curata_ecran():
    os.system('cls' if os.name == 'nt' else 'clear')

def afiseaza_header():
    print(Culori.CYAN + Culori.BOLD + "=" * 80)
    print("🔮 TESTUL PREDICȚIEI CUANTICE - Conexiune cu Fluxul Binar 🔮".center(80))
    print("=" * 80 + Culori.RESET)

def afiseaza_context(biti, pozitie_curenta, total_biti):
    print(f"\n{Culori.ALBASTRU}📊 Progres: {pozitie_curenta}/{total_biti} biți ({pozitie_curenta*100//total_biti}%){Culori.RESET}")
    print(f"\n{Culori.GALBEN}Contextul (ultimii 8 biți):{Culori.RESET}")
    print(f"{Culori.BOLD}{Culori.CYAN}  {'  '.join(biti)}  ❓{Culori.RESET}")
    print(f"{Culori.GALBEN}                            ↑{Culori.RESET}")
    print(f"{Culori.GALBEN}                    Ce urmează?{Culori.RESET}\n")

def calculeaza_statistici(istoric_ghiciri, fereastra=20):
    if len(istoric_ghiciri) == 0:
        return 0.0
    recent = list(istoric_ghiciri)[-fereastra:] if len(istoric_ghiciri) >= fereastra else list(istoric_ghiciri)
    return (sum(recent) / len(recent)) * 100

def afiseaza_statistici(total, corecte, streak, istoric_ghiciri):
    acuratete_totala = (corecte / total * 100) if total > 0 else 0
    acuratete_10 = calculeaza_statistici(istoric_ghiciri, 10)
    acuratete_20 = calculeaza_statistici(istoric_ghiciri, 20)
    
    print(f"\n{Culori.BOLD}{'─' * 80}{Culori.RESET}")
    print(f"{Culori.BOLD}📈 STATISTICI:{Culori.RESET}")
    
    # Acuratețe totală
    culoare_acc = Culori.VERDE if acuratete_totala > 55 else Culori.GALBEN if acuratete_totala > 50 else Culori.ROSU
    print(f"   Total ghiciri: {total} | Corecte: {corecte} | "
          f"{culoare_acc}Acuratețe: {acuratete_totala:.1f}%{Culori.RESET}")
    
    # Streak
    culoare_streak = Culori.VERDE if streak > 5 else Culori.GALBEN if streak > 2 else Culori.ALB
    print(f"   {culoare_streak}🔥 Serie curentă: {streak} consecutive corecte{Culori.RESET}")
    
    # Acuratețe recentă
    if len(istoric_ghiciri) >= 10:
        culoare_10 = Culori.VERDE if acuratete_10 > 60 else Culori.GALBEN if acuratete_10 > 50 else Culori.ROSU
        print(f"   {culoare_10}Ultimi 10 biți: {acuratete_10:.1f}%{Culori.RESET}")
    
    if len(istoric_ghiciri) >= 20:
        culoare_20 = Culori.VERDE if acuratete_20 > 60 else Culori.GALBEN if acuratete_20 > 50 else Culori.ROSU
        print(f"   {culoare_20}Ultimi 20 biți: {acuratete_20:.1f}%{Culori.RESET}")
    
    print(f"{Culori.BOLD}{'─' * 80}{Culori.RESET}")
    
    return acuratete_totala, acuratete_10, acuratete_20

def detecteaza_rezonanta(total, streak, acuratete_10, acuratete_20, acuratete_totala):
    """Detectează dacă utilizatorul a intrat în 'rezonanță cuantică'"""
    
    # Nivel 1: Conexiune slabă
    if total >= 10 and acuratete_10 > 60:
        return 1, "⚡ ATENȚIE! Detectez pattern-uri neobișnuite în predicțiile tale..."
    
    # Nivel 2: Rezonanță moderată
    if streak >= 7:
        return 2, "🌟 REZONANȚĂ DETECTATĂ! Pari să anticipezi fluxul binar!"
    
    # Nivel 3: Rezonanță puternică
    if total >= 20 and acuratete_20 > 65:
        return 3, "✨ REZONANȚĂ CUANTICĂ CONFIRMATĂ! Te-ai sincronizat cu datele!"
    
    # Nivel 4: Conexiune imposibilă (sau date non-aleatorii)
    if streak >= 15:
        return 4, "🔥 IMPOSIBIL! Ai depășit probabilitatea statistică! Ești conectat la flux!"
    
    # Nivel 5: Transcendent
    if total >= 30 and acuratete_totala > 70:
        return 5, "🌌 FENOMEN EXTRAORDINAR! Acuratețea ta sfidează legile probabilității!"
    
    return 0, None

def main():
    FISIER = 'datebinare.txt'
    CONTEXT_SIZE = 8
    
    # Citește datele
    try:
        with open(FISIER, 'r') as f:
            date_binare = f.read().strip()
            date_binare = ''.join(c for c in date_binare if c in '01')
    except FileNotFoundError:
        print(f"{Culori.ROSU}❌ Eroare: Fișierul '{FISIER}' nu a fost găsit!{Culori.RESET}")
        return
    
    if len(date_binare) < CONTEXT_SIZE + 1:
        print(f"{Culori.ROSU}❌ Eroare: Fișierul trebuie să aibă cel puțin {CONTEXT_SIZE + 1} biți!{Culori.RESET}")
        return
    
    curata_ecran()
    afiseaza_header()
    
    print(f"\n{Culori.VERDE}✅ Fișier încărcat: {len(date_binare):,} biți{Culori.RESET}")
    print(f"\n{Culori.MAGENTA}📖 INSTRUCȚIUNI:{Culori.RESET}")
    print(f"   • Vei vedea ultimii {CONTEXT_SIZE} biți")
    print(f"   • Ghicește ce bit urmează (0 sau 1)")
    print(f"   • Încearcă să găsești pattern-uri în secvență")
    print(f"   • Dacă acuratețea ta depășește 60%, ai descoperit ceva special!")
    print(f"   • Scrie 'q' pentru a ieși\n")
    
    input(f"{Culori.CYAN}Apasă ENTER pentru a începe...{Culori.RESET}")
    
    # Variabile de tracking
    pozitie = CONTEXT_SIZE
    total_ghiciri = 0
    ghiciri_corecte = 0
    streak_curent = 0
    max_streak = 0
    istoric_ghiciri = deque(maxlen=50)  # Ultimele 50 ghiciri
    nivel_rezonanta_anterior = 0
    
    # Loop principal
    while pozitie < len(date_binare):
        curata_ecran()
        afiseaza_header()
        
        # Contextul curent
        context = list(date_binare[pozitie - CONTEXT_SIZE:pozitie])
        bit_real = date_binare[pozitie]
        
        # Afișează context
        afiseaza_context(context, pozitie, len(date_binare))
        
        # Afișează statistici dacă există
        if total_ghiciri > 0:
            acuratete_totala, acuratete_10, acuratete_20 = afiseaza_statistici(
                total_ghiciri, ghiciri_corecte, streak_curent, istoric_ghiciri
            )
            
            # Verifică rezonanță
            nivel, mesaj = detecteaza_rezonanta(
                total_ghiciri, streak_curent, acuratete_10, acuratete_20, acuratete_totala
            )
            
            if nivel > 0 and nivel > nivel_rezonanta_anterior:
                print(f"\n{Culori.BG_CYAN}{Culori.BOLD}{'!' * 80}{Culori.RESET}")
                print(f"{Culori.MAGENTA}{Culori.BOLD}{mesaj}{Culori.RESET}")
                print(f"{Culori.BG_CYAN}{Culori.BOLD}{'!' * 80}{Culori.RESET}\n")
                nivel_rezonanta_anterior = nivel
        
        # Primește input
        while True:
            ghicit = input(f"{Culori.BOLD}🎯 Ghicește următorul bit (0/1) sau 'q' pentru ieșire: {Culori.RESET}").strip()
            
            if ghicit.lower() == 'q':
                print(f"\n{Culori.GALBEN}👋 La revedere! Ieșire...{Culori.RESET}")
                sys.exit(0)
            
            if ghicit in ['0', '1']:
                break
            
            print(f"{Culori.ROSU}❌ Te rog introdu doar 0, 1 sau 'q'{Culori.RESET}")
        
        # Verifică răspunsul
        total_ghiciri += 1
        pozitie += 1
        
        if ghicit == bit_real:
            ghiciri_corecte += 1
            streak_curent += 1
            max_streak = max(max_streak, streak_curent)
            istoric_ghiciri.append(1)
            
            print(f"\n{Culori.BG_VERDE}{Culori.BOLD} ✅ CORECT! Bitul era: {bit_real} {Culori.RESET}")
            
            if streak_curent >= 5:
                print(f"{Culori.VERDE}🔥 Serie de {streak_curent}! Continui să rezonezi!{Culori.RESET}")
        else:
            istoric_ghiciri.append(0)
            if streak_curent > 0:
                print(f"\n{Culori.BG_ROSU}{Culori.BOLD} ❌ GREȘIT! Bitul era: {bit_real} {Culori.RESET}")
                if streak_curent >= 3:
                    print(f"{Culori.GALBEN}Serie întreruptă la {streak_curent}...{Culori.RESET}")
            else:
                print(f"\n{Culori.BG_ROSU}{Culori.BOLD} ❌ GREȘIT! Bitul era: {bit_real} {Culori.RESET}")
            streak_curent = 0
        
        input(f"\n{Culori.CYAN}Apasă ENTER pentru următorul bit...{Culori.RESET}")
    
    # Statistici finale
    curata_ecran()
    afiseaza_header()
    
    print(f"\n{Culori.MAGENTA}{Culori.BOLD}🎊 AI TERMINAT TESTUL! 🎊{Culori.RESET}\n")
    
    acuratete_finala = (ghiciri_corecte / total_ghiciri * 100) if total_ghiciri > 0 else 0
    
    print(f"{Culori.BOLD}{'═' * 80}{Culori.RESET}")
    print(f"{Culori.BOLD}📊 RAPORT FINAL:{Culori.RESET}")
    print(f"{Culori.BOLD}{'═' * 80}{Culori.RESET}\n")
    
    print(f"   Total biți ghiciți: {total_ghiciri}")
    print(f"   Predicții corecte: {ghiciri_corecte}")
    print(f"   Predicții greșite: {total_ghiciri - ghiciri_corecte}")
    
    culoare_finala = Culori.VERDE if acuratete_finala > 60 else Culori.GALBEN if acuratete_finala > 50 else Culori.ROSU
    print(f"   {culoare_finala}{Culori.BOLD}Acuratețe finală: {acuratete_finala:.2f}%{Culori.RESET}")
    print(f"   🔥 Cea mai lungă serie: {max_streak} biți consecutivi\n")
    
    print(f"{Culori.BOLD}{'═' * 80}{Culori.RESET}")
    print(f"{Culori.BOLD}🔍 INTERPRETARE:{Culori.RESET}")
    print(f"{Culori.BOLD}{'═' * 80}{Culori.RESET}\n")
    
    if acuratete_finala > 70:
        print(f"{Culori.VERDE}{Culori.BOLD}🌟 EXTRAORDINAR!{Culori.RESET}")
        print(f"{Culori.VERDE}   Acuratețea ta sfidează probabilitatea statistică!")
        print(f"{Culori.VERDE}   Fie ai descoperit pattern-uri reale în date,")
        print(f"{Culori.VERDE}   fie ai dezvoltat o intuiție cuantică remarcabilă!{Culori.RESET}")
    elif acuratete_finala > 60:
        print(f"{Culori.CYAN}{Culori.BOLD}✨ IMPRESIONANT!{Culori.RESET}")
        print(f"{Culori.CYAN}   Ai depășit semnificativ pragul ghicirii aleatorii!")
        print(f"{Culori.CYAN}   Există dovezi clare de pattern recognition sau rezonanță cuantică.{Culori.RESET}")
    elif acuratete_finala > 55:
        print(f"{Culori.GALBEN}{Culori.BOLD}⚡ INTERESANT!{Culori.RESET}")
        print(f"{Culori.GALBEN}   Ai o ușoară tendință peste random (50%).")
        print(f"{Culori.GALBEN}   S-ar putea să existe pattern-uri subtile pe care le-ai detectat.{Culori.RESET}")
    elif acuratete_finala >= 45 and acuratete_finala <= 55:
        print(f"{Culori.ALB}{Culori.BOLD}🎲 ALEATOR{Culori.RESET}")
        print(f"{Culori.ALB}   Acuratețea ta este în jurul valorii așteptate pentru ghicire aleatorie (50%).")
        print(f"{Culori.ALB}   Dacă datele sunt cu adevărat cuantice, aceasta e normal!")
        print(f"{Culori.ALB}   Nicio intuiție umană nu poate prezice haosul cuantic.{Culori.RESET}")
    else:
        print(f"{Culori.ROSU}{Culori.BOLD}🔄 SUB RANDOM{Culori.RESET}")
        print(f"{Culori.ROSU}   Curios! Ești sub 45%, ceea ce sugerează că poate")
        print(f"{Culori.ROSU}   ai avut ghinionul sau ai ales invers față de intuiție.{Culori.RESET}")
    
    print(f"\n{Culori.MAGENTA}Mulțumim pentru participare la experimentul cuantic! 🔮{Culori.RESET}\n")

if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print(f"\n\n{Culori.GALBEN}⚠️  Program întrerupt de utilizator{Culori.RESET}")
        sys.exit(0)