#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Script simplu integrat pentru extragere litere și detectare cuvinte în ebraică
Citește din: date.txt
Scrie în: result_ascii.txt și result_cuvinte.txt
"""

import re
from collections import defaultdict

# Încarcă bibliotecile NLP dacă sunt disponibile
try:
    import enchant
    ENCHANT_DISPONIBIL = True
except ImportError:
    ENCHANT_DISPONIBIL = False

try:
    from wordfreq import word_frequency
    WORDFREQ_DISPONIBIL = True
except ImportError:
    WORDFREQ_DISPONIBIL = False

# ============= CONFIGURARE =============
FISIER_INTRARE = "date.txt"
FISIER_RESULT_ASCII = "result_ascii.txt"
FISIER_RESULT_CUVINTE = "result_cuvinte.txt"
LIMBA_CUVINTE = "he"  # Ebraică


def extrage_doar_litere(text):
    """Extrage doar literele A-Z, a-z din text"""
    return ''.join(char for char in text if char.isalpha())


def extrage_ascii_din_hex(text):
    """Extrage litere ASCII din date hexazecimale"""
    litere = []
    hex_clean = re.sub(r'[^0-9a-fA-F]', '', text)
    
    for i in range(0, len(hex_clean) - 1, 2):
        try:
            hex_byte = hex_clean[i:i+2]
            char_code = int(hex_byte, 16)
            if (65 <= char_code <= 90) or (97 <= char_code <= 122):
                litere.append(chr(char_code))
        except ValueError:
            continue
    
    return ''.join(litere)


def extrage_ascii_din_binar(text):
    """Extrage litere ASCII din date binare"""
    litere = []
    bin_clean = re.sub(r'[^01]', '', text)
    
    for i in range(0, len(bin_clean) - 7, 8):
        try:
            bin_byte = bin_clean[i:i+8]
            char_code = int(bin_byte, 2)
            if (65 <= char_code <= 90) or (97 <= char_code <= 122):
                litere.append(chr(char_code))
        except ValueError:
            continue
    
    return ''.join(litere)


def detecteaza_si_extrage(text):
    """Detectează tipul de date și extrage literele ASCII"""
    litere_directe = extrage_doar_litere(text)
    
    hex_chars = len(re.findall(r'[0-9a-fA-F]', text))
    bin_chars = len(re.findall(r'[01]', text))
    total_chars = len(text.replace(' ', '').replace('\n', '').replace('\r', ''))
    
    # Dacă peste 50% sunt deja litere, returnează direct
    if len(litere_directe) > total_chars * 0.5:
        return litere_directe
    
    rezultat_hex = ""
    rezultat_bin = ""
    
    if hex_chars > 0:
        rezultat_hex = extrage_ascii_din_hex(text)
    
    if bin_chars > 0:
        rezultat_bin = extrage_ascii_din_binar(text)
    
    # Returnează cel mai lung rezultat
    rezultate = [litere_directe, rezultat_hex, rezultat_bin]
    return max(rezultate, key=len)


class DetectorCuvinte:
    """Detectează cuvinte în ebraică"""
    
    def __init__(self):
        self.verificator_enchant = None
        self.initializeaza()
    
    def initializeaza(self):
        """Inițializează verificatorul pentru ebraică"""
        
        if ENCHANT_DISPONIBIL:
            try:
                self.verificator_enchant = enchant.Dict("he_IL")
                print("✓ Dicționar ebraic încărcat (PyEnchant)")
            except:
                print("⚠ Dicționar ebraic nu este disponibil în PyEnchant")
                print("  Instalează cu: sudo apt-get install aspell-he hspell")
        else:
            print("⚠ PyEnchant nu este instalat")
            print("  Instalează cu: pip install pyenchant")
    
    def este_cuvant_valid(self, cuvant):
        """Verifică dacă un cuvânt este valid în ebraică"""
        
        # Verifică în PyEnchant
        if self.verificator_enchant:
            try:
                if self.verificator_enchant.check(cuvant):
                    return True
            except:
                pass
        
        # Verifică în wordfreq
        if WORDFREQ_DISPONIBIL:
            try:
                freq = word_frequency(cuvant.lower(), 'he')
                if freq > 0:
                    return True
            except:
                pass
        
        return False


def gaseste_cuvinte_ebraice(sir_litere, detector, lungime_minima=2):
    """Găsește cuvinte în ebraică din șirul de litere"""
    
    sir_litere = sir_litere.strip()
    cuvinte_gasite = defaultdict(list)
    
    if len(sir_litere) == 0:
        return dict(cuvinte_gasite)
    
    print(f"Căutare cuvinte ebraice (lungime {lungime_minima}-15)...")
    
    # Caută cuvinte de diferite lungimi
    for lungime in range(lungime_minima, min(len(sir_litere) + 1, 16)):
        for i in range(len(sir_litere) - lungime + 1):
            substring = sir_litere[i:i+lungime]
            
            # Verifică dacă este un cuvânt valid în ebraică
            if detector.este_cuvant_valid(substring):
                pozitie = f"poz {i}-{i+lungime-1}"
                cuvinte_gasite[substring].append(pozitie)
    
    return dict(cuvinte_gasite)


def main():
    print("=" * 60)
    print("🔍 EXTRAGERE LITERE ASCII ȘI DETECTARE CUVINTE EBRAICE")
    print("=" * 60)
    print()
    
    # Verifică dacă există fișierul de intrare
    try:
        with open(FISIER_INTRARE, 'r', encoding='utf-8', errors='ignore') as f:
            continut = f.read()
    except FileNotFoundError:
        print(f"❌ Eroare: Fișierul '{FISIER_INTRARE}' nu există!")
        print()
        print("Creează un fișier 'date.txt' cu:")
        print("  - Date hexazecimale (ex: 48656c6c6f)")
        print("  - Date binare (ex: 01001000 01100101)")
        print("  - Text cu litere amestecate")
        return
    
    print(f"📖 Se citește: {FISIER_INTRARE}")
    print()
    
    # Extrage literele ASCII
    litere = detecteaza_si_extrage(continut)
    
    if not litere:
        print("❌ Nu s-au găsit litere ASCII în fișier!")
        return
    
    # Salvează literele în result_ascii.txt
    with open(FISIER_RESULT_ASCII, 'w', encoding='utf-8') as f:
        f.write(litere)
    
    print(f"✓ Extras {len(litere)} litere ASCII")
    print(f"✓ Salvat în: {FISIER_RESULT_ASCII}")
    print()
    print(f"Șir extras: {litere[:150]}{'...' if len(litere) > 150 else ''}")
    print()
    
    # Inițializează detectorul de cuvinte ebraice
    print("=" * 60)
    print("🔍 DETECTARE CUVINTE EBRAICE")
    print("=" * 60)
    print()
    
    detector = DetectorCuvinte()
    
    if not ENCHANT_DISPONIBIL and not WORDFREQ_DISPONIBIL:
        print()
        print("⚠ ATENȚIE: Nu este instalată nicio bibliotecă NLP!")
        print()
        print("Pentru detectare cuvinte ebraice, instalează:")
        print("  pip install pyenchant wordfreq")
        print("  sudo apt-get install aspell-he hspell  # Linux")
        print()
        print("Scriptul va salva doar literele extrase.")
        
        # Salvează un fișier gol pentru cuvinte
        with open(FISIER_RESULT_CUVINTE, 'w', encoding='utf-8') as f:
            f.write("Nu s-au putut detecta cuvinte - biblioteci NLP lipsă\n")
            f.write(f"Șir extras: {litere}\n")
        
        return
    
    print()
    
    # Caută cuvinte ebraice
    cuvinte = gaseste_cuvinte_ebraice(litere, detector, lungime_minima=2)
    
    # Sortează cuvintele după lungime
    cuvinte_sortate = sorted(cuvinte.items(), key=lambda x: len(x[0]), reverse=True)
    
    # Salvează rezultatele în result_cuvinte.txt
    with open(FISIER_RESULT_CUVINTE, 'w', encoding='utf-8') as f:
        f.write("CUVINTE EBRAICE DETECTATE\n")
        f.write("=" * 60 + "\n\n")
        f.write(f"Șir original: {litere}\n\n")
        f.write("=" * 60 + "\n\n")
        
        if cuvinte_sortate:
            # Grupează după lungime
            lungimi = defaultdict(list)
            for cuvant, pozitii in cuvinte_sortate:
                lungimi[len(cuvant)].append((cuvant, pozitii))
            
            for lungime in sorted(lungimi.keys(), reverse=True):
                f.write(f"\nCuvinte de {lungime} litere:\n")
                f.write("-" * 40 + "\n")
                for cuvant, pozitii in lungimi[lungime]:
                    pozitii_str = ', '.join(pozitii[:3])
                    if len(pozitii) > 3:
                        pozitii_str += f" (+ {len(pozitii) - 3} repetări)"
                    f.write(f"  {cuvant:20} -> {pozitii_str}\n")
            
            f.write(f"\n{'=' * 60}\n")
            f.write(f"TOTAL: {len(cuvinte_sortate)} cuvinte unice găsite\n")
        else:
            f.write("Nu s-au găsit cuvinte ebraice în șir.\n")
            f.write("\nPosibile cauze:\n")
            f.write("  - Șirul nu conține cuvinte ebraice valide\n")
            f.write("  - Dicționarul ebraic nu este instalat complet\n")
    
    print(f"✓ {len(cuvinte_sortate)} cuvinte ebraice detectate")
    print(f"✓ Salvat în: {FISIER_RESULT_CUVINTE}")
    print()
    
    # Afișează primele rezultate
    if cuvinte_sortate:
        print("Primele cuvinte găsite:")
        for cuvant, pozitii in cuvinte_sortate[:15]:
            print(f"  🇮🇱 {cuvant:15} ({len(cuvant)} litere)")
        
        if len(cuvinte_sortate) > 15:
            print(f"  ... și încă {len(cuvinte_sortate) - 15} cuvinte")
    else:
        print("Nu s-au găsit cuvinte ebraice în șirul extras.")
        print()
        print("Tips:")
        print("  - Verifică dacă dicționarul ebraic este instalat")
        print("  - Încearcă să adaugi mai multe date în date.txt")
    
    print()
    print("=" * 60)
    print("✅ FINALIZAT")
    print("=" * 60)
    print()
    print(f"📄 Rezultate salvate în:")
    print(f"   - {FISIER_RESULT_ASCII}")
    print(f"   - {FISIER_RESULT_CUVINTE}")
    print()


if __name__ == "__main__":
    main()