# BEGIN: user added these matplotlib lines to ensure any plots do not pop-up in their UI
import matplotlib
matplotlib.use('Agg')  # Set the backend to non-interactive
import matplotlib.pyplot as plt
plt.ioff()
import os
os.environ['TERM'] = 'dumb'
# END: user added these matplotlib lines to ensure any plots do not pop-up in their UI
# filename: analiza_avansata.py
# execution: true

import re
import numpy as np
from collections import Counter
import matplotlib.pyplot as plt

def cauta_cuvinte_cunoscute():
    """Caută cuvinte cunoscute în secvențele extrase."""
    try:
        with open('rezultate_extrase.txt', 'r') as f:
            continut = f.read()
        
        # Lista de cuvinte comune în română și engleză
        cuvinte_comune = [
            'si', 'in', 'la', 'de', 'pe', 'cu', 'pentru', 'este', 'sunt', 'au',
            'the', 'and', 'to', 'of', 'in', 'is', 'you', 'that', 'it', 'he',
            'was', 'for', 'on', 'are', 'with', 'as', 'his', 'they', 'at', 'be'
        ]
        
        # Căutăm aceste cuvinte în text
        print("Căutăm cuvinte comune în secvențele extrase:")
        gasit = False
        for cuvant in cuvinte_comune:
            # Căutăm cuvântul ca un cuvânt întreg (cu spații sau semne de punctuație în jur)
            pattern = r'[^a-zA-Z]' + cuvant + r'[^a-zA-Z]|^' + cuvant + r'[^a-zA-Z]|[^a-zA-Z]' + cuvant + r'$|^' + cuvant + r'$'
            matches = re.findall(pattern, continut, re.IGNORECASE)
            if matches:
                print(f"Cuvântul '{cuvant}' apare de {len(matches)} ori")
                gasit = True
        
        if not gasit:
            print("Nu am găsit niciun cuvânt comun în secvențele extrase.")
        
    except Exception as e:
        print(f"Eroare: {e}")

def analizeaza_secvente_repetitive():
    """Analizează dacă există secvențe repetitive în datele extrase."""
    try:
        with open('rezultate_extrase.txt', 'r') as f:
            continut = f.read()
        
        # Extragem toate secvențele de text posibil
        secvente = re.findall(r'Text posibil: (.*)\n', continut)
        
        if not secvente:
            print("\nNu am găsit secvențe de text pentru analiză.")
            return
            
        # Căutăm secvențe repetitive de cel puțin 3 caractere
        print("\nCăutăm secvențe repetitive în datele extrase:")
        secvente_repetitive = {}
        
        for secventa in secvente:
            for i in range(len(secventa)-2):
                for j in range(3, min(10, len(secventa)-i+1)):  # Secvențe între 3 și 9 caractere
                    subsecventa = secventa[i:i+j]
                    if subsecventa not in secvente_repetitive:
                        secvente_repetitive[subsecventa] = 0
                    secvente_repetitive[subsecventa] += 1
        
        # Filtrăm secvențele care apar de mai multe ori
        secvente_repetitive = {k: v for k, v in secvente_repetitive.items() if v > 1}
        
        if secvente_repetitive:
            # Sortăm după frecvență
            secvente_sortate = sorted(secvente_repetitive.items(), key=lambda x: x[1], reverse=True)
            print(f"Top 10 secvențe repetitive (din {len(secvente_repetitive)}):")
            for secventa, count in secvente_sortate[:10]:
                print(f"'{secventa}': {count} apariții")
        else:
            print("Nu am găsit secvențe repetitive semnificative.")
            
    except Exception as e:
        print(f"Eroare: {e}")

def vizualizeaza_distributia():
    """Vizualizează distribuția caracterelor pentru a identifica posibile modele."""
    try:
        with open('rezultate_extrase.txt', 'r') as f:
            continut = f.read()
            
        # Extragem toate caracterele găsite
        caractere = re.findall(r'\t(.)\n', continut)
        
        if not caractere:
            print("\nNu am găsit caractere pentru vizualizare.")
            return
            
        # Calculăm frecvența fiecărui caracter
        frecventa = Counter(caractere)
        
        # Separăm în litere, cifre și semne de punctuație
        litere = {k: v for k, v in frecventa.items() if k.isalpha()}
        cifre = {k: v for k, v in frecventa.items() if k.isdigit()}
        punctuatie = {k: v for k, v in frecventa.items() if not k.isalpha() and not k.isdigit()}
        
        # Creăm un grafic pentru distribuția caracterelor
        plt.figure(figsize=(12, 8))
        
        # Distribuția literelor
        if litere:
            litere_sortate = sorted(litere.items(), key=lambda x: x[1], reverse=True)
            x = [item[0] for item in litere_sortate[:20]]  # Primele 20 de litere
            y = [item[1] for item in litere_sortate[:20]]
            
            plt.subplot(3, 1, 1)
            plt.bar(x, y)
            plt.title('Distribuția literelor (top 20)')
            plt.xlabel('Literă')
            plt.ylabel('Frecvență')
            
        # Distribuția cifrelor
        if cifre:
            cifre_sortate = sorted(cifre.items())
            x = [item[0] for item in cifre_sortate]
            y = [item[1] for item in cifre_sortate]
            
            plt.subplot(3, 1, 2)
            plt.bar(x, y)
            plt.title('Distribuția cifrelor')
            plt.xlabel('Cifră')
            plt.ylabel('Frecvență')
            
        # Distribuția semnelor de punctuație
        if punctuatie:
            punctuatie_sortate = sorted(punctuatie.items(), key=lambda x: x[1], reverse=True)
            x = [item[0] for item in punctuatie_sortate]
            y = [item[1] for item in punctuatie_sortate]
            
            plt.subplot(3, 1, 3)
            plt.bar(x, y)
            plt.title('Distribuția semnelor de punctuație')
            plt.xlabel('Semn')
            plt.ylabel('Frecvență')
            
        plt.tight_layout()
        plt.savefig('distributie_caractere.png')
        print("\nAm generat graficul distribuției caracterelor în fișierul 'distributie_caractere.png'")
        
    except Exception as e:
        print(f"Eroare la generarea graficului: {e}")

if __name__ == "__main__":
    print("=== ANALIZĂ AVANSATĂ A DATELOR EXTRASE ===")
    cauta_cuvinte_cunoscute()
    analizeaza_secvente_repetitive()
    vizualizeaza_distributia()