Update app.py

app.py

@@ -1,480 +1,490 @@
 import streamlit as st
-import time
-import google.generativeai as genai
-from pydantic import ValidationError
-import mimetypes
+from openai import OpenAI
+import openpyxl
+from openpyxl.styles import Font, PatternFill, Border, Side, Alignment
 import os
-import settings_ai
-from settings_ai import Documento, Articolo
-import pandas as pd
-from PyPDF2 import PdfReader, PdfWriter
-import json
-from azure.core.credentials import AzureKeyCredential
-from azure.ai.documentintelligence import DocumentIntelligenceClient
-from azure.ai.documentintelligence.models import AnalyzeDocumentRequest
-from streamlit_pdf_viewer import pdf_viewer
-import io
-from PyPDF2 import PdfReader, PdfWriter
-import fitz
-import re
 import io
-from collections import Counter
-
-st.set_page_config(page_title="Import Fatture AI✨")
-st.title("Import Fatture AI ✨")
-
-# Gestionione LOGIN
-if "logged" not in st.session_state:
-    st.session_state.logged = False
-    st.session_state.model = "gemini-2.0-flash"
-if st.session_state.logged == False:
-    login_placeholder = st.empty()
-    with login_placeholder.container():
-        container = st.container(border=True)
-        username = container.text_input('Username')
-        password = container.text_input('Passowrd', type='password')
-        login = container.button('  Login  ', type='primary')
-    if not login or username != os.getenv("LOGIN_USER") or  password != os.getenv("LOGIN_PASSWORD"):
-        if login:
-            st.error('Password Errata')
-        st.stop()
-    st.session_state.logged = True
-    login_placeholder.empty()
-
-with st.expander("Guida completa"):
-    st.write("""Questa applicazione Python, basata su Streamlit, integra servizi di intelligenza artificiale di Gemini per automatizzare l'estrazione e la validazione dei dati dalle fatture. Il sistema gestisce documenti in vari formati (PDF, immagini) e li elabora in maniera modulare per facilitare la conversione e la verifica delle informazioni.
-
-## Funzionalità Principali
-
-- **Caricamento e Gestione dei Documenti**
-    - Supporta il caricamento di file PDF, JPG, JPEG e PNG tramite un’interfaccia Streamlit.
-    - Se il file è un PDF con più pagine, viene suddiviso in sezioni (configurabile tramite uno slider) per una gestione più efficace. Più il numero è basso più il risultato è preciso.
-
-- **Conversione dei Dati**
-    - **Upload e Inoltro a Gemini**: I file vengono caricati e inviati al rispettivo servizio AI.
-    - **Estrazione dei Dati**: Il sistema invia il documento a un modello di generazione AI per ottenere una rappresentazione JSON contenente i dati (ad es. numero di documento, data, totale imponibile e articoli).
-
-- **Validazione e Verifica**
-    - **Validazione JSON**: Utilizza Pydantic per verificare la correttezza della struttura e dei dati estratti. In caso di errori, il documento viene riprocessato fino a 3 volte per cercare di correggere le anomalie.
-    - **Verifica Incrociata dei Contenuti**: Per i PDF, viene estratto il testo con PyPDF2 e confrontato con i codici articolo per assicurarsi che i dati siano effettivamente presenti nel documento.
-    - **Filtraggio Articoli**: Vengono mantenuti solo gli articoli compatibili con i criteri specifici (codici articolo e importi non nulli).
-
-- **Visualizzazione e Highlighting**
-    - I dati validati vengono mostrati in formato tabellare e in JSON.
-    - Se il documento è un PDF, il sistema evidenzia graficamente (con rettangoli rossi) i testi relativi agli articoli compatibili, semplificando il controllo visivo.
-
-## Avvertenze per l'Operatore
-
-- **Controllo Manuale Obbligatorio**:  
-L'operatore **deve sempre verificare** i dati elaborati.  
-Nonostante il riprocessamento automatico in caso di errori, è fondamentale controllare la correttezza dei dati estratti e la validità degli articoli.
-
-- **Validazione dei Dati**:  
-L'operazione di validazione tramite Pydantic e la verifica incrociata sul contenuto del PDF sono cruciali.  
-Assicurarsi che non vi siano discrepanze, specialmente nei casi in cui alcuni articoli risultino non verificati.
-""")
-
-st.write("📄 **Legge più PDF:** Carica più file PDF contemporaneamente")
-st.write("🤖 **Sfrutta l'AI di Gemini:** Per ogni documento, estrae i dati in formato JSON e in formato tabellare.")
-st.write("✅ **Mostra Articoli Compatibili:** Filtra e visualizza solo gli articoli che rispettano i criteri richiesti.")
-st.write("🔍 **Anteprima Documento:** Visualizza un'anteprima del documento evidenziando gli articoli compatibili.")
-
-
-GENERATION_CONFIG = settings_ai.GENERATION_CONFIG
-SYSTEM_INSTRUCTION = settings_ai.SYSTEM_INSTRUCTION
-USER_MESSAGE = settings_ai.USER_MESSAGE
-API_KEY_GEMINI = settings_ai.API_KEY_GEMINI
-
-# Configura il modello Gemini
-genai.configure(api_key=API_KEY_GEMINI)
-model = genai.GenerativeModel(
-    model_name=st.session_state.model,
-    generation_config=GENERATION_CONFIG,
-    system_instruction=SYSTEM_INSTRUCTION
-)
-
-# Upload File a GEMINI
-def upload_to_gemini(path: str, mime_type: str = None):
-    """Carica un file su Gemini e ne ritorna l'oggetto file."""
-    file = genai.upload_file(path, mime_type=mime_type)
-    print(f"Uploaded file '{file.display_name}' as: {file.uri}")
-    return file
-
-# Attesa Upload Files
-def wait_for_files_active(files):
-    """Attende che i file siano nello stato ACTIVE su Gemini."""
-    print("Waiting for file processing...")
-    for name in (f.name for f in files):
-        file_status = genai.get_file(name)
-        while file_status.state.name == "PROCESSING":
-            print(".", end="", flush=True)
-            time.sleep(10)
-            file_status = genai.get_file(name)
-        if file_status.state.name != "ACTIVE":
-            raise Exception(f"File {file_status.name} failed to process")
-    print("\n...all files ready")
-
-# Chiamata API Gemini
-def send_message_to_gemini(chat_session, message, max_attempts=5):
-    """Tenta di inviare il messaggio tramite la chat_session, riprovando fino a max_attempts in caso di eccezioni, con un delay di 10 secondi tra i tentativi. """
-    for attempt in range(max_attempts):
-        try:
-            print(f"Generazione AI con PROMPT: {message}")
-            response_local = chat_session.send_message(message)
-            return response_local
-        except Exception as e:
-            print(f"Errore in send_message (tentativo {attempt+1}/{max_attempts}): {e}")
-            if attempt < max_attempts - 1:
-                print("Riprovo tra 10 secondi...")
-                time.sleep(10)
-    raise RuntimeError(f"Invio messaggio fallito dopo {max_attempts} tentativi.")
-
-# Unisce i rettangoli evidenziati (se codice e descrizione stanno su linee diverse viene mostrato un solo rettangolo evidenziato)
-def merge_intervals(intervals):
-    """Unisce gli intervalli sovrapposti. Gli intervalli sono tuple (y0, y1)."""
-    if not intervals:
-        return []
-    intervals.sort(key=lambda x: x[0])
-    merged = [intervals[0]]
-    for current in intervals[1:]:
-        last = merged[-1]
-        if current[0] <= last[1]:  
-            merged[-1] = (last[0], max(last[1], current[1]))
+import traceback
+import sys
+from dotenv import load_dotenv
+import json
+
+st.set_page_config(layout="wide", page_title="Generatore Excel AI")
+
+load_dotenv()
+API_KEY = os.getenv("API_HUGGINGFACE")
+BASE_URL = "https://matteoscript-ai.hf.space/v1/"
+MODEL_NAME = "gemini-2.5-flash-preview-05-20" # Sostituisci con il tuo modello preferito
+
+if not API_KEY:
+    st.error("API Key Hugging Face non trovata. Assicurati che il file .env sia configurato correttamente con API_HUGGINGFACE.")
+    st.stop()
+
+client = OpenAI(api_key=API_KEY, base_url=BASE_URL)
+
+DEFAULT_EXCEL_FILENAME = "excel_ai.xlsx"
+MAX_CORRECTION_ATTEMPTS = 5 
+PROMPT_FOR_SHEET_PLANNER = """
+Sei un assistente AI specializzato nella pianificazione di documenti Excel multi-foglio.
+Data una richiesta generale dell'utente e un numero di fogli desiderato, il tuo compito è proporre:
+1. Un nome univoco e descrittivo per ciascun foglio (massimo 30 caratteri, evita caratteri speciali non ammessi nei nomi dei fogli Excel come / ? * [ ]).
+2. Una breve descrizione (1-3 frasi) dello scopo, del contenuto principale di ciascun foglio e delle possibili interazioni/collegamenti con altri fogli. Questa descrizione verrà poi usata come base per generare il contenuto dettagliato del foglio.
+La tua risposta DEVE essere un array JSON di oggetti. Ogni oggetto rappresenta un foglio e DEVE avere i campi "sheet_name" (stringa) e "sheet_purpose" (stringa).
+Il numero di oggetti nell'array DEVE corrispondere esattamente al numero di fogli specificato dall'utente.
+Esempio di richiesta utente: "Report vendite trimestrale (3 fogli): 1. Input dati grezzi vendite. 2. Riepilogo vendite per prodotto, che legga da input. 3. Riepilogo vendite per regione, che legga anch'esso da input."
+Esempio di TUA risposta JSON:
+[
+  {"sheet_name": "Input Vendite", "sheet_purpose": "Foglio per l'inserimento manuale o l'importazione dei dati grezzi di vendita, includendo data, ID prodotto, quantità, prezzo, regione."},
+  {"sheet_name": "Riep Prodotti", "sheet_purpose": "Analizza i dati dal foglio 'Input Vendite' per mostrare un riepilogo delle vendite per prodotto. Include totali, medie e forse grafici. Utilizza formule per aggregare i dati da 'Input Vendite'."},
+  {"sheet_name": "Riep Regioni", "sheet_purpose": "Analizza i dati dal foglio 'Input Vendite' per visualizzare le performance di vendita per regione. Potrebbe includere somme condizionali basate sui dati di 'Input Vendite'."}
+]
+Non includere ```json o ``` all'inizio o alla fine della tua risposta. Fornisci solo l'array JSON.
+"""
+
+BASE_PROMPT_NO_BACKTICKS = """
+Sei un esperto generatore di SCRIPT PYTHON per MODIFICARE un oggetto Workbook openpyxl esistente (fornito in una variabile chiamata wb). Il tuo compito è aggiungere e popolare UN SINGOLO FOGLIO in questo Workbook, usando la libreria openpyxl.
+
+IL TUO SCRIPT NON DEVE ASSOLUTAMENTE:
+- Creare un nuovo Workbook (NON usare openpyxl.Workbook()). L'oggetto Workbook ti viene fornito e si chiama wb.
+- Salvare il Workbook (NON usare wb.save()). Il salvataggio sarà gestito esternamente.
+- Includere istruzioni di import globali. Le funzioni e classi necessarie (wb, Font, PatternFill, Border, Side, Alignment) saranno già disponibili nello scope.
+
+IL TUO SCRIPT PYTHON DEVE:
+- Aspettarsi che un oggetto openpyxl.Workbook (wb) sia già definito.
+- Creare un nuovo foglio o accedere a uno esistente usando il TITOLO_FOGLIO_RICHIESTO:
+  sheet_title = "TITOLO_FOGLIO_RICHIESTO" # Questo sarà il nome fornito
+  if sheet_title in wb.sheetnames:
+     sheet = wb[sheet_title]
+     # Pulisci il foglio se deve essere sovrascritto (valori e stili)
+     for row_idx in range(1, sheet.max_row + 1):
+        for col_idx in range(1, sheet.max_column + 1):
+            cell = sheet.cell(row=row_idx, column=col_idx)
+            cell.value = None
+            cell.style = openpyxl.styles.Style() # Reset stile base
+  else:
+     sheet = wb.create_sheet(title=sheet_title)
+- Popolare l'oggetto sheet con dati, header, formule e formattazione come da richiesta.
+- Usare stili Material Design e font moderni.
+- Includere FORMULE Excel, specialmente se la richiesta implica calcoli o aggregazioni.
+
+CONTESTO DEI FOGLI PRECEDENTI (SE FORNITO):
+Se nella richiesta utente qui sotto trovi una sezione "CONTESTO DEI FOGLI PRECEDENTI", essa conterrà gli script Python usati per generare i fogli precedenti.
+Usa questo per creare FORMULE EXCEL CHE COLLEGANO IL FOGLIO CORRENTE AI FOGLI PRECEDENTI.
+Esempio: sheet['B1'].value = "='DatiVendite'!E10"
+Analizza gli script precedenti per nomi dei fogli e struttura dati. I nomi dei fogli nelle formule DEVONO CORRISPONDERE ESATTAMENTE.
+
+REQUISITI CODICE GENERATO:
+- SENZA commenti python (#).
+- Massimo un ritorno a capo vuoto consecutivo.
+- Gestione errori interni al try/except (usare 'pass', non 'raise e').
+- NON impostare sola lettura.
+- NON usare Alignment se non strettamente necessario.
+- Genera dati di esempio realistici (5-10 righe) se non diversamente specificato.
+- Applica formattazione ad header e celle chiave.
+"""
+
+PROMPT_FOR_SCRIPT_CORRECTION = """
+Sei un esperto programmatore Python specializzato nella libreria openpyxl e nel debugging di script che manipolano file Excel.
+Ti è stato fornito uno script Python che ha fallito durante l'esecuzione mentre tentava di aggiungere e popolare un foglio in un workbook openpyxl esistente ('wb').
+Ti sono stati forniti anche l'errore esatto e il traceback.
+
+IL TUO COMPITO È:
+1. Analizzare attentamente lo script originale, l'errore e il traceback.
+2. Identificare la causa dell'errore.
+3. Correggere lo script Python. Lo script corretto deve ancora rispettare TUTTE le seguenti regole originali:
+    - DEVE operare su un oggetto Workbook openpyxl esistente chiamato 'wb'.
+    - NON DEVE creare un nuovo Workbook (NON usare openpyxl.Workbook()).
+    - NON DEVE salvare il Workbook (NON usare wb.save()).
+    - NON DEVE includere istruzioni di import globali (es. 'import openpyxl'). Le classi necessarie (wb, Font, PatternFill, Border, Side, Alignment) sono già nello scope.
+    - DEVE creare/accedere al foglio specificato da TITOLO_FOGLIO_RICHIESTO. Il nome del foglio è critico, non alterarlo a meno che l'errore non sia specificamente legato ad esso e la correzione sia ovvia.
+    - DEVE popolare il foglio come descritto in DESCRIZIONE_ORIGINALE_FOGLIO.
+    - Se era presente un CONTESTO_FOGLI_PRECEDENTI, lo script corretto deve ancora poter utilizzare quel contesto per eventuali formule inter-foglio.
+    - DEVE essere SENZA commenti python (#).
+    - DEVE avere al massimo un ritorno a capo vuoto consecutivo.
+    - DEVE gestire gli errori specifici del foglio internamente con un blocco try/except che termina con 'pass' (non 'raise e'). L'intero script dovrebbe essere avvolto in un try/except.
+    - NON DEVE usare la classe Alignment esplicitamente a meno che non sia fondamentale e parte della descrizione originale.
+    - DEVE mantenere l'obiettivo originale del foglio. Non rimuovere funzionalità a meno che non siano la causa diretta dell'errore e non ci sia una correzione ovvia.
+4. Restituisci SOLO lo script Python CORRETTO E COMPLETO, senza alcuna spiegazione aggiuntiva, commenti o ```python.
+
+INFORMAZIONI FORNITE:
+- TITOLO_FOGLIO_RICHIESTO: "{sheet_name}"
+- DESCRIZIONE_ORIGINALE_FOGLIO: "{sheet_purpose}"
+- CONTESTO_FOGLI_PRECEDENTI (se applicabile):
+{previous_scripts_context}
+- SCRIPT_ORIGINALE_FALLITO:
+---
+{original_script}
+---
+- ERRORE_E_TRACEBACK:
+---
+{error_traceback}
+---
+
+Restituisci solo il codice Python corretto. Non aggiungere spiegazioni prima o dopo il codice. Assicurati che lo script sia completo e pronto per essere eseguito.
+"""
+
+def initialize_session_state():
+    defaults = {
+        "initial_excel_request": "Business Plan di lancio prodotto per un'azienda Loyalty specializzata nella GDO",
+        "num_sheets_requested": 1,
+        "ai_sheet_plan": None,
+        "workbook_object": None,
+        "generated_scripts_for_sheets": [],
+        "final_excel_file_path": None,
+        "final_excel_filename": DEFAULT_EXCEL_FILENAME,
+        "process_log": [],
+        "error_message": "",
+        "warning_message": "",
+        "generation_started": False
+    }
+    for key, value in defaults.items():
+        if key not in st.session_state:
+            st.session_state[key] = value
+
+def log_message(message, level="info"):
+    log_entry = f"[{level.upper()}] {message}\n"
+    st.session_state.process_log.append(log_entry)
+    if level == "error":
+        st.session_state.error_message += message + "\n"
+    elif level == "warning":
+        st.session_state.warning_message += message + "\n"
+
+def call_openai_for_sheet_plan(overall_request, num_sheets):
+    st.session_state.error_message = ""
+    st.session_state.warning_message = ""
+    try:
+        user_content = f"Richiesta generale dell'utente: \"{overall_request}\"\nNumero di fogli desiderato: {num_sheets}"
+        completion = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "system", "content": PROMPT_FOR_SHEET_PLANNER},
+                {"role": "user", "content": user_content}
+            ],
+            temperature=0.3,
+            response_format={"type": "json_object"}
+        )
+        response_content = completion.choices[0].message.content.strip()
+        log_message(f"Risposta grezza AI (piano fogli): {response_content}")
+        planned_sheets = json.loads(response_content)
+        if isinstance(planned_sheets, list) and all(isinstance(item, dict) and "sheet_name" in item and "sheet_purpose" in item for item in planned_sheets):
+            if len(planned_sheets) == num_sheets: return planned_sheets
+            else:
+                msg = f"AI ha proposto {len(planned_sheets)} fogli, richiesti {num_sheets}. Verifica."
+                log_message(msg, level="warning"); st.session_state.warning_message = msg
+                return planned_sheets
         else:
-            merged.append(current)
-    return merged
-
-# Evidenzia le corrispondenze
-def highlight_text_in_pdf(input_pdf_bytes, text_list):
-    """Crea rettangoli rossi che evidenziano i testi trovati, unendo gli intervalli sovrapposti in un unico rettangolo. """
-    pdf_document = fitz.open(stream=input_pdf_bytes, filetype="pdf")
-    patterns = []
-    for text in text_list:
-        text_pattern = re.escape(text).replace(r'\ ', r'\s*')
-        patterns.append(text_pattern)
-    pattern = r'\b(' + '|'.join(patterns) + r')\b'
-    regex = re.compile(pattern, re.IGNORECASE)
-    highlight_color = (1, 0, 0)  # rosso
-    for page in pdf_document:
-        page_text = page.get_text()
-        matches = list(regex.finditer(page_text))
-        intervals = []
-        for match in matches:
-            match_text = match.group(0)
-            text_instances = page.search_for(match_text)
-            for inst in text_instances:
-                text_height = inst.y1 - inst.y0
-                new_y0 = inst.y0 - 0.1 * text_height
-                new_y1 = inst.y1 + 0.1 * text_height
-                intervals.append((new_y0, new_y1))
-        merged_intervals = merge_intervals(intervals)
-        for y0, y1 in merged_intervals:
-            full_width_rect = fitz.Rect(page.rect.x0, y0, page.rect.x1, y1)
-            rect_annot = page.add_rect_annot(full_width_rect)
-            rect_annot.set_colors(stroke=highlight_color, fill=highlight_color)
-            rect_annot.set_opacity(0.15)
-            rect_annot.update()
-    output_stream = io.BytesIO()
-    pdf_document.save(output_stream)
-    pdf_document.close()
-    output_stream.seek(0)
-    return output_stream
-
-# Formattazione Euro 
-def format_euro(amount):
-    formatted = f"{amount:,.2f}"
-    formatted = formatted.replace(",", "X").replace(".", ",").replace("X", ".")
-    return f"€ {formatted}"
-
-# Testo da PDF
-def pdf_to_text(path_file: str) -> str:
-    """ Estrae e concatena il testo da tutte le pagine del PDF. """
-    reader = PdfReader(path_file)
-    full_text = ""
-    for page in reader.pages:
-        page_text = page.extract_text() or ""
-        full_text += page_text + "\n"
-    return full_text
-
-# Funzione che verifica se gli articoli sono corretti (facendo un partsing PDF to TEXT)
-def verify_articles(file_path: str, chunk_document):
-    ''' La funzione trasforma il PDF in TESTO e cerca se ogni articolo è presente (al netto degli spazi) '''
-    if not file_path.lower().endswith(".pdf"):
-        for articolo in chunk_document.Articoli:
-            articolo.Verificato = 2
+            msg = "Struttura JSON piano fogli AI non valida."
+            log_message(msg, level="error"); st.session_state.error_message = msg
+            return None
+    except json.JSONDecodeError as e:
+        msg = f"Errore decodifica JSON piano fogli: {e}. Risposta: {response_content}"
+        log_message(msg, level="error"); st.session_state.error_message = msg
         return None
-    pdf_text = pdf_to_text(file_path)
-    if  '□' in pdf_text:
-        for articolo in chunk_document.Articoli:
-            articolo.Verificato = 2
+    except Exception as e:
+        log_message(f"Errore OpenAI piano fogli: {e}", level="error"); st.session_state.error_message = f"Errore OpenAI pianificazione: {e}"
         return None
-    for articolo in chunk_document.Articoli:
-        articolo.Verificato = 1 if articolo.CodiceArticolo and (articolo.CodiceArticolo in pdf_text) else 0
-        if articolo.Verificato == 0:
-            articolo.Verificato = 1 if articolo.CodiceArticolo and (articolo.CodiceArticolo.replace(" ", "") in pdf_text.replace(" ", "")) else 0
-    if not any(articolo.Verificato == 0 for articolo in chunk_document.Articoli):
+
+def call_openai_for_sheet_script(sheet_purpose, sheet_name, prev_scripts_ctx):
+    st.session_state.error_message = ""
+    try:
+        user_content = (
+            f"TITOLO_FOGLIO_RICHIESTO: '{sheet_name}'.\n"
+            f"Descrizione per '{sheet_name}':\n{sheet_purpose}\n\n"
+        )
+        if prev_scripts_ctx:
+            user_content += f"CONTESTO_FOGLI_PRECEDENTI:\n{prev_scripts_ctx}\n"
+        
+        completion = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "system", "content": BASE_PROMPT_NO_BACKTICKS},
+                {"role": "user", "content": user_content}
+            ],
+            temperature=0.1,
+        )
+        script = completion.choices[0].message.content.strip()
+        if script.startswith("```python"): script = script[9:]
+        if script.endswith("```"): script = script[:-3]
+        return script.strip()
+    except Exception as e:
+        st.session_state.error_message = f"Errore OpenAI script foglio '{sheet_name}': {e}"
+        log_message(st.session_state.error_message, level="error")
         return None
-    unverified_articles = [articolo for articolo in chunk_document.Articoli if articolo.Verificato == 0]
-    json_unverified_articles = json.dumps([articolo.model_dump() for articolo in unverified_articles])
-    return json_unverified_articles
-
-# Funzione ausiliaria che elabora un file (o un chunk) inviandolo tramite send_message_to_gemini
-def process_document_splitted(file_path: str, chunk_label: str, use_azure: bool = False) -> Documento:
-    """ Elabora il file (o il chunk) inviandolo a Gemini e processando la risposta:
-    - Determina il mime type.
-    - Effettua l'upload tramite upload_to_gemini e attende che il file sia attivo.
-    - Avvia una chat con il file caricato e invia il messaggio utente.
-    - Tenta fino a 3 volte di validare il JSON ottenuto, filtrando gli Articoli.
-    - Se presenti errori, RIPROCESSA il documento 3 volta passando il risultato precedente, In questo modo riesce a gestire gli errori in modo più preciso!
-    Ritorna l'istanza di Documento validata. """
-    mime_type, _ = mimetypes.guess_type(file_path)
-    if mime_type is None:
-        mime_type = "application/octet-stream"
-    if not use_azure:
-        files = [upload_to_gemini(file_path, mime_type=mime_type)]
-        wait_for_files_active(files)
-        chat_history = [{ "role": "user","parts": [files[0]]}]
-        for attempt in range(3):
-            try:
-                chat_session = model.start_chat(history=chat_history)
-                break  
-            except Exception as e:
-                print(f"Errore nello Start chat") 
-                time.sleep(10)
-
-    max_validation_attempts = 3
-    max_number_reprocess = 3
-    chunk_document = None
-
-    for i in range(max_number_reprocess):
-        print(f"Reprocessamento {i+1} di {max_number_reprocess} per il chunk {chunk_label}")
-        response = None
-        for attempt in range(max_validation_attempts):
-            message = USER_MESSAGE
-            if i > 0:
-                message += f". Attenzione, RIPROVA perché i seguenti articoli sono da ESCLUDERE in quanto ERRATI! {json_unverified_articles}"
-            if not use_azure:
-                response = send_message_to_gemini(chat_session, message)
+
+def call_openai_for_script_correction(original_script, error_traceback, sheet_name, sheet_purpose, prev_scripts_ctx):
+    st.session_state.error_message = "" # Resetta per la chiamata di correzione
+    log_message(f"Tentativo di correzione AI per foglio '{sheet_name}'.")
+    try:
+        prompt = PROMPT_FOR_SCRIPT_CORRECTION.format(
+            sheet_name=sheet_name,
+            sheet_purpose=sheet_purpose,
+            previous_scripts_context=prev_scripts_ctx if prev_scripts_ctx else "Nessuno.",
+            original_script=original_script,
+            error_traceback=error_traceback
+        )
+        completion = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[{"role": "user", "content": prompt}], # Il system prompt è inglobato per semplicità qui
+            temperature=0.2, # Leggermente più creativo per trovare soluzioni
+        )
+        corrected_script = completion.choices[0].message.content.strip()
+        if corrected_script.startswith("```python"): corrected_script = corrected_script[9:]
+        if corrected_script.endswith("```"): corrected_script = corrected_script[:-3]
+        log_message(f"Script corretto proposto dall'AI per '{sheet_name}'.")
+        return corrected_script.strip()
+    except Exception as e:
+        st.session_state.error_message = f"Errore OpenAI correzione script per '{sheet_name}': {e}"
+        log_message(st.session_state.error_message, level="error")
+        return None
+
+def execute_single_sheet_script(script_code, workbook_obj, sheet_name_being_processed):
+    #st.session_state.error_message = "" # Non resettare qui, l'errore può venire da OpenAI
+    current_error_message_for_exec = ""
+    capture_out = io.StringIO()
+    original_stdout = sys.stdout
+    sys.stdout = capture_out
+    execution_success = False
+    script_globals = {
+        'wb': workbook_obj, 'openpyxl': openpyxl,
+        'Font': Font, 'PatternFill': PatternFill,
+        'Border': Border, 'Side': Side, 'Alignment': Alignment
+    }
+    detailed_error_for_correction = ""
+    try:
+        exec(script_code, script_globals)
+        execution_success = True
+    except Exception as e:
+        tb_str = traceback.format_exc()
+        current_error_message_for_exec = f"Errore esecuzione script per foglio '{sheet_name_being_processed}':\n{type(e).__name__}: {e}\nTraceback:\n{tb_str}"
+        detailed_error_for_correction = f"{type(e).__name__}: {e}\n{tb_str}"
+        # Non loggare qui come errore fatale subito, potrebbe essere corretto
+    finally:
+        sys.stdout = original_stdout
+        execution_log = capture_out.getvalue()
+        capture_out.close()
+    
+    if not execution_success: # Solo se fallisce, aggiorna l'errore di session_state
+        st.session_state.error_message += current_error_message_for_exec + "\n"
+
+
+    return execution_success, execution_log, detailed_error_for_correction
+
+
+def render_sidebar():
+    with st.sidebar:
+        st.header("🤖 Input per l'AI")
+        st.session_state.initial_excel_request = st.text_area(
+            "📝 Descrivi l'Excel",
+            value=st.session_state.initial_excel_request, height=200,
+            help="Sii descrittivo. Specifica se i fogli devono leggere dati da altri."
+        )
+        st.session_state.num_sheets_requested = st.number_input(
+            "🔢 Numero di fogli:", min_value=1, max_value=20,
+            value=st.session_state.num_sheets_requested, step=1
+        )
+
+def render_main_content():
+    st.title("📊 Generatore Excel AI")
+    st.markdown("Definisci richiesta e numero Fogli, poi l'AI **pianificherà, genererà, collegherà** e tenterà di auto-correggere gli script dei fogli")
+
+    if st.sidebar.button("💡 Pianifica Fogli con AI", type="primary", use_container_width=True):
+        st.session_state.ai_sheet_plan = None
+        st.session_state.generated_scripts_for_sheets = []
+        st.session_state.process_log = []
+        st.session_state.error_message = ""
+        st.session_state.warning_message = ""
+        st.session_state.final_excel_file_path = None
+        st.session_state.generation_started = False
+        log_message("Avvio pianificazione fogli...")
+        with st.spinner("L'AI sta pianificando i fogli..."):
+            plan = call_openai_for_sheet_plan(st.session_state.initial_excel_request, st.session_state.num_sheets_requested)
+            if plan:
+                st.session_state.ai_sheet_plan = plan
+                log_message(f"Piano fogli ricevuto: {len(plan)} fogli.")
+                st.success(f"✅ L'AI ha pianificato {len(plan)} fogli! Rivedi/modifica descrizioni.")
             else:
-                chunk_document = analyze_invoice_azure(file_path)
-            try:
-                if not use_azure:
-                    chunk_document = Documento.model_validate_json(response.text)
-                chunk_document.Articoli = [
-                    art for art in chunk_document.Articoli
-                    if art.CodiceArticolo.startswith(("AVE", "AV", "3V", "44"))
-                    and art.TotaleNonIvato != 0
-                    and art.CodiceArticolo not in ("AVE", "AV", "3V", "44")
-                ]
-                break 
-            except ValidationError as ve:
-                print(f"Errore di validazione {chunk_label} (tentativo {attempt+1}/{max_validation_attempts}): {ve}")
-                if attempt < max_validation_attempts - 1:
-                    print("Riprovo tra 5 secondi...")
-                    time.sleep(5)
-                else:
-                    raise RuntimeError(f"Superato il numero massimo di tentativi di validazione {chunk_label}.")
-
-        json_unverified_articles = verify_articles(file_path, chunk_document)
-        if not json_unverified_articles:
-            return chunk_document
-    return chunk_document
-
-# Funzione principale che elabora il documento
-def process_document(path_file: str, number_pages_split: int, use_azure: bool = False) -> Documento:
-    """ Elabora il documento in base al tipo di file:
-    1. Se il file non è un PDF, lo tratta "così com'è" (ad esempio, come immagine) e ne processa il contenuto tramite process_document_splitted.
-    2. Se il file è un PDF e contiene più di 5 pagine, lo divide in chunk da 5 pagine.
-       Per ogni chunk viene effettuato l’upload, viene elaborato il JSON e validato.
-       I chunk successivi vengono aggregati nel Documento finale e, se il PDF ha più
-       di 5 pagine, al termine il campo TotaleMerce viene aggiornato con il valore riportato dall’ultimo chunk. """
-    mime_type, _ = mimetypes.guess_type(path_file)
-    if mime_type is None:
-        mime_type = "application/octet-stream"
-    if use_azure:
-        number_pages_split = 1
-    if not path_file.lower().endswith(".pdf"):
-        print("File non PDF: elaborazione come immagine.")
-        documento_finale = process_document_splitted(path_file, chunk_label="(immagine)", use_azure=use_azure)
-        return documento_finale
-
-    reader = PdfReader(path_file)
-    total_pages = len(reader.pages)
-    documento_finale = None
-    ultimo_totale_merce = None
-
-    for chunk_index in range(0, total_pages, number_pages_split):
-        writer = PdfWriter()
-        for page in reader.pages[chunk_index:chunk_index + number_pages_split]:
-            writer.add_page(page)
-        temp_filename = "temp_chunk_"
-        if use_azure:
-            temp_filename+="azure_"
-        temp_filename += f"{chunk_index // number_pages_split}.pdf"
-        with open(temp_filename, "wb") as temp_file:
-            writer.write(temp_file)
-        chunk_label = f"(chunk {chunk_index // number_pages_split})"
-        chunk_document = process_document_splitted(temp_filename, chunk_label=chunk_label, use_azure=use_azure)
-        if hasattr(chunk_document, "TotaleImponibile"):
-            ultimo_totale_merce = chunk_document.TotaleImponibile
-        if documento_finale is None:
-            documento_finale = chunk_document
-        else:
-            documento_finale.Articoli.extend(chunk_document.Articoli)
-        os.remove(temp_filename)
-
-    if total_pages > number_pages_split and ultimo_totale_merce is not None:
-        documento_finale.TotaleImponibile = ultimo_totale_merce
-    if documento_finale is None:
-        raise RuntimeError("Nessun documento elaborato.")
-
-    # Controlli aggiuntivi: Se esiste un AVE non possono esistere altri articoli non ave. 
-    if any(articolo.CodiceArticolo.startswith("AVE") for articolo in documento_finale.Articoli):
-        documento_finale.Articoli = [articolo for articolo in documento_finale.Articoli if articolo.CodiceArticolo.startswith("AVE")]
-    # Controllo occorrenze di doppioni 
-    if path_file.lower().endswith(".pdf"):
-        pdf_text = pdf_to_text(path_file)
-        pdf_text = pdf_text.replace(" ", "")
-        occorrenze = {}
-        for articolo in documento_finale.Articoli:
-            codice_clean = articolo.CodiceArticolo.replace(" ", "")
-            if codice_clean not in occorrenze:
-                occorrenze[codice_clean] = pdf_text.count(codice_clean)
-        articoli_contati = {}
-        for articolo in documento_finale.Articoli:
-            codice_clean = articolo.CodiceArticolo.replace(" ", "")
-            if codice_clean in pdf_text:
-                print(codice_clean)
-                print(occorrenze[codice_clean])
-                articoli_contati[codice_clean] = articoli_contati.get(codice_clean, 0) + 1
-                if articoli_contati[codice_clean] <= occorrenze.get(codice_clean, 0):
-                    articolo.Verificato = True
-                else:
-                    articolo.Verificato = False
+                log_message("Fallimento pianificazione.", level="error")
+                st.error(f"Impossibile pianificare. {st.session_state.error_message}")
+        st.rerun()
+
+    if st.session_state.ai_sheet_plan:
+        st.markdown("---")
+        st.subheader("📋 Piano Fogli Proposto dall'AI (Modificabile)")
+        st.caption("Modifica descrizioni se necessario, specialmente per chiarire collegamenti.")
+        for i, sheet_def in enumerate(st.session_state.ai_sheet_plan):
+            with st.expander(f"Foglio {i+1}: **{sheet_def['sheet_name']}**", expanded=True):
+                new_purpose = st.text_area(
+                    f"Scopo/Contenuto per '{sheet_def['sheet_name']}':",
+                    value=sheet_def['sheet_purpose'], key=f"sheet_purpose_edit_{i}", height=120
+                )
+                if new_purpose != sheet_def['sheet_purpose']:
+                    st.session_state.ai_sheet_plan[i]['sheet_purpose'] = new_purpose
+
+        if st.button("✨ Genera, Assembla e Auto-Correggi Excel ✨", type="primary", use_container_width=True, disabled=st.session_state.generation_started):
+            st.session_state.generation_started = True
+            # Conserva log pianificazione, pulisce log di vecchie generazioni
+            planning_logs = [log for log in st.session_state.process_log if "pianificazione" in log.lower() or "piano fogli ricevuto" in log.lower()]
+            st.session_state.process_log = planning_logs
+            st.session_state.error_message = ""
+            st.session_state.warning_message = ""
+            st.session_state.generated_scripts_for_sheets = [] # Visualizzazione finale
+            st.session_state.final_excel_file_path = None
+
+            st.session_state.workbook_object = openpyxl.Workbook()
+            if st.session_state.workbook_object.sheetnames:
+                st.session_state.workbook_object.remove(st.session_state.workbook_object.active)
+            log_message("Workbook inizializzato per generazione.")
+
+            generated_scripts_history_for_context = [] # Per passare contesto all'AI
+            all_sheets_successful = True
+            progress_bar = st.progress(0)
+            num_total_sheets = len(st.session_state.ai_sheet_plan)
+
+            for i, sheet_def in enumerate(st.session_state.ai_sheet_plan):
+                sheet_name = sheet_def["sheet_name"]
+                sheet_purpose = sheet_def["sheet_purpose"]
+                progress_text = f"Foglio {i+1}/{num_total_sheets}: '{sheet_name}'"
+                log_message(f"--- Inizio {progress_text} ---")
+                progress_bar.progress((i + 1) / num_total_sheets, text=f"Generando: {progress_text}")
+
+                previous_scripts_context_str = ""
+                if generated_scripts_history_for_context:
+                    parts = ["'''\nScript fogli precedenti (riferimento/collegamenti):\n"]
+                    for idx, prev_info in enumerate(generated_scripts_history_for_context):
+                        parts.append(f"--- Script Foglio '{prev_info['name']}' (Indice {idx}) ---\n{prev_info['script']}\n")
+                    parts.append("'''\n")
+                    previous_scripts_context_str = "\n".join(parts)
+
+                current_script_for_sheet = None
+                correction_attempts = 0
+                sheet_successfully_processed = False
+
+                # Tentativo iniziale di generazione script
+                spinner_msg = f"🤖 AI genera script per '{sheet_name}' (contesto: {len(generated_scripts_history_for_context)} fogli)..."
+                with st.spinner(spinner_msg):
+                    current_script_for_sheet = call_openai_for_sheet_script(sheet_purpose, sheet_name, previous_scripts_context_str)
+
+                if current_script_for_sheet:
+                    log_message(f"Script iniziale per '{sheet_name}' generato.")
+                    
+                    # Ciclo di esecuzione e correzione
+                    while correction_attempts <= MAX_CORRECTION_ATTEMPTS and not sheet_successfully_processed:
+                        exec_spinner_msg = f"⚙️ Esecuzione script per '{sheet_name}'"
+                        if correction_attempts > 0:
+                            exec_spinner_msg += f" (tentativo correzione {correction_attempts})"
+                        
+                        with st.spinner(exec_spinner_msg):
+                            success, exec_log, error_details_for_correction = execute_single_sheet_script(
+                                current_script_for_sheet, st.session_state.workbook_object, sheet_name
+                            )
+                        if exec_log: log_message(f"Log esecuzione per '{sheet_name}':\n{exec_log}")
+
+                        if success:
+                            log_message(f"Foglio '{sheet_name}' aggiunto/modificato con successo.")
+                            st.session_state.generated_scripts_for_sheets.append({"name": sheet_name, "script": current_script_for_sheet, "status": "Successo"})
+                            generated_scripts_history_for_context.append({"name": sheet_name, "script": current_script_for_sheet})
+                            sheet_successfully_processed = True
+                        else:
+                            log_message(f"⚠️ Fallimento esecuzione script per '{sheet_name}'. Errore: {error_details_for_correction}", level="warning")
+                            correction_attempts += 1
+                            if correction_attempts <= MAX_CORRECTION_ATTEMPTS:
+                                log_message(f"Tentativo {correction_attempts}/{MAX_CORRECTION_ATTEMPTS} di auto-correzione AI per '{sheet_name}'.")
+                                with st.spinner(f"🤖 AI tenta correzione per '{sheet_name}' (errore: {error_details_for_correction.splitlines()[0]}..."):
+                                    corrected_script_candidate = call_openai_for_script_correction(
+                                        current_script_for_sheet, error_details_for_correction,
+                                        sheet_name, sheet_purpose, previous_scripts_context_str
+                                    )
+                                if corrected_script_candidate:
+                                    log_message(f"Nuovo script corretto proposto per '{sheet_name}'.")
+                                    current_script_for_sheet = corrected_script_candidate
+                                    # Loop rieseguirà execute_single_sheet_script
+                                else:
+                                    log_message(f"AI non ha fornito script corretto per '{sheet_name}'. Tentativo {correction_attempts} fallito.", level="error")
+                                    st.session_state.generated_scripts_for_sheets.append({"name": sheet_name, "script": current_script_for_sheet, "status": f"Fallito dopo correzione (AI non ha corretto)", "error": error_details_for_correction})
+                                    break # Esce dal ciclo di correzione se AI non dà nulla
+                            else:
+                                log_message(f"Limite tentativi ({MAX_CORRECTION_ATTEMPTS}) di correzione raggiunto per '{sheet_name}'. Errore finale: {error_details_for_correction}", level="error")
+                                st.session_state.generated_scripts_for_sheets.append({"name": sheet_name, "script": current_script_for_sheet, "status": f"Fallito (max tentativi)", "error": error_details_for_correction})
+                else: # Fallimento generazione script iniziale
+                    log_message(f"⚠️ Fallimento generazione script iniziale per '{sheet_name}'. {st.session_state.error_message}", level="error")
+                    st.session_state.generated_scripts_for_sheets.append({"name": sheet_name, "script": "# ERRORE GENERAZIONE SCRIPT", "status": "Fallimento Generazione", "error": st.session_state.error_message})
+                
+                if not sheet_successfully_processed:
+                    all_sheets_successful = False
+                    break # Interrompe generazione se un foglio fallisce definitivamente
+                log_message(f"--- Fine Foglio {i+1}: '{sheet_name}' ---")
+            progress_bar.empty()
+
+            if all_sheets_successful and st.session_state.workbook_object:
+                try:
+                    if os.path.exists(st.session_state.final_excel_filename): os.remove(st.session_state.final_excel_filename)
+                    st.session_state.workbook_object.save(st.session_state.final_excel_filename)
+                    st.session_state.final_excel_file_path = st.session_state.final_excel_filename
+                    log_message(f"Workbook '{st.session_state.final_excel_filename}' salvato.")
+                    st.success(f"✅ Excel '{st.session_state.final_excel_filename}' generato!")
+                except Exception as e:
+                    log_message(f"❌ Errore salvataggio Workbook: {e}", level="error"); st.session_state.error_message = f"Errore salvataggio: {e}"
+            elif not all_sheets_successful:
+                st.error(f"Processo interrotto. Excel non salvato. {st.session_state.error_message}")
             else:
-                articolo.Verificato = False
-    return documento_finale
-
-# Analizza Fattura con AZURE 
-def analyze_invoice_azure(file_path: str):
-    """Invia il file (dal percorso specificato) al servizio prebuilt-invoice e restituisce il risultato dell'analisi."""
-    # Apri il file in modalità binaria e leggi il contenuto
-    with open(file_path, "rb") as file:
-        file_data = file.read()
-    client = DocumentIntelligenceClient(endpoint=settings_ai.ENDPOINT_AZURE, credential=AzureKeyCredential(settings_ai.API_AZURE))
-    poller = client.begin_analyze_document("prebuilt-invoice", body=file_data)
-    result = poller.result()
-    return parse_invoice_to_documento_azure(result)
-
-# Parsing Fattura con AZURE 
-def parse_invoice_to_documento_azure(result) -> Documento:
-    """ Parssa il risultato dell'analisi e mappa i campi rilevanti nel modello Pydantic Documento. """
-    if not result.documents:
-        raise ValueError("Nessun documento analizzato trovato.")
-    invoice = result.documents[0]
-    invoice_id_field = invoice.fields.get("InvoiceId")
-    numero_documento = invoice_id_field.value_string if invoice_id_field and invoice_id_field.value_string else ""
-    invoice_date_field = invoice.fields.get("InvoiceDate")
-    data_str = invoice_date_field.value_date.isoformat() if invoice_date_field and invoice_date_field.value_date else ""
-    subtotal_field = invoice.fields.get("SubTotal")
-    if subtotal_field and subtotal_field.value_currency:
-        totale_imponibile = subtotal_field.value_currency.amount
-    else:
-        invoice_total_field = invoice.fields.get("InvoiceTotal")
-        totale_imponibile = invoice_total_field.value_currency.amount if invoice_total_field and invoice_total_field.value_currency else 0.0
-    articoli = []
-    items_field = invoice.fields.get("Items")
-    if items_field and items_field.value_array:
-        for item in items_field.value_array:
-            product_code_field = item.value_object.get("ProductCode")
-            description_field = str(item.value_object.get("Description").get("content"))
-            if not description_field:
-                description_field = ""
-            codice_articolo = product_code_field.value_string if product_code_field and product_code_field.value_string else ""
-            amount_field = item.value_object.get("Amount")
-            totale_non_ivato = amount_field.value_currency.amount if amount_field and amount_field.value_currency else 0.0
-            articolo = Articolo(
-                CodiceArticolo=codice_articolo,
-                DescrizioneArticolo=description_field,
-                TotaleNonIvato=totale_non_ivato,
-                Verificato=None
+                st.warning("Nessun foglio elaborato o problema sconosciuto.")
+            st.session_state.generation_started = False
+            st.rerun()
+
+    if st.session_state.warning_message: st.warning(st.session_state.warning_message)
+    # Mostra errore principale solo se non c'è un file di successo e non siamo in fase di generazione attiva
+    if st.session_state.error_message and not st.session_state.final_excel_file_path and not st.session_state.generation_started:
+        st.error(f"Si sono verificati errori durante l'ultimo processo: {st.session_state.error_message}")
+
+    if st.session_state.generated_scripts_for_sheets:
+        st.markdown("---")
+        with st.expander("🔍 Vedi Script Generati per i Fogli (e Stato Esecuzione)"):
+            for item in st.session_state.generated_scripts_for_sheets:
+                # Modifica questa riga:
+                sheet_name_display = item.get('name', 'Nome Foglio Mancante')
+                status_display = item.get('status', 'Stato Sconosciuto')
+                script_display = item.get('script', '# Script non disponibile')
+                error_display = item.get('error', None)
+
+                st.subheader(f"Script per '{sheet_name_display}' - Stato: {status_display}")
+                st.code(script_display, language="python")
+                if error_display: # Controlla se la chiave 'error' esiste e ha un valore
+                    st.error(f"Dettaglio Errore Finale per '{sheet_name_display}':\n{error_display}")
+
+    if st.session_state.process_log:
+        st.markdown("---")
+        with st.expander("📝 Log del Processo Dettagliato", expanded=False):
+            st.text_area("Log:", "".join(st.session_state.process_log), height=300, disabled=True)
+
+    render_download_section()
+    render_footer()
+
+def render_download_section():
+    if st.session_state.final_excel_file_path and os.path.exists(st.session_state.final_excel_file_path):
+        st.markdown("---")
+        st.header("📥 Download File Excel Finale")
+        try:
+            with open(st.session_state.final_excel_file_path, "rb") as fp: excel_bytes = fp.read()
+            st.download_button(
+                label=f"💾 Scarica {st.session_state.final_excel_filename}", data=excel_bytes,
+                file_name=st.session_state.final_excel_filename,
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                use_container_width=True, type="primary"
             )
-            articoli.append(articolo)
-
-    documento = Documento(
-        TipoDocumento="Fattura", 
-        NumeroDocumento=numero_documento,
-        Data=data_str,
-        TotaleImponibile=totale_imponibile,
-        Articoli=articoli
-    )
-    return documento
-
-# Front-End con Streamlit
+        except Exception as e:
+            st.error(f"Impossibile leggere il file per il download: {e}")
+            log_message(f"Errore lettura file per download: {e}", level="error")
+    elif st.session_state.ai_sheet_plan and not st.session_state.generation_started:
+        st.info("Una volta generato l'Excel, il download apparirà qui.")
+
+def render_footer():
+    st.markdown("---")
+    st.markdown("💡 **Nota:** L'AI tenta di collegare i fogli e auto-correggere errori. Verifica sempre i risultati e le formule.")
+
 def main():
-    #st.set_page_config(page_title="Import Fatture AI", page_icon="✨")
-    st.sidebar.title("Caricamento File")
-    uploaded_files = st.sidebar.file_uploader("Seleziona uno o più PDF", type=["pdf", "jpg", "jpeg", "png"], accept_multiple_files=True)
-    model_ai = st.sidebar.selectbox("Modello", ['Gemini Flash 2.0', #'Gemini 2.5 Pro', 
-                                                'Azure Intelligence'])
-    if model_ai == 'Gemini 2.5 Pro':
-        st.session_state.model = "gemini-2.5-pro-exp-03-25"
-    use_azure = True if model_ai == 'Azure Intelligence' else False
-    number_pages_split = st.sidebar.slider('Split Pagine', 1, 30, 1, help="Numero suddivisione pagine del PDF. Più il numero è basso e più il modello AI è preciso, più è alto più è veloce")
-    if st.sidebar.button("Importa", type="primary", use_container_width=True):
-        if not uploaded_files:
-            st.warning("Nessun file caricato!")
-        else:
-            for uploaded_file in uploaded_files:
-                st.subheader(f"📄 {uploaded_file.name}")
-                file_path = uploaded_file.name
-                with open(file_path, "wb") as f:
-                    f.write(uploaded_file.getbuffer())
-
-                with st.spinner(f"Elaborazione in corso"):
-                    try:
-                        doc = process_document(uploaded_file.name, number_pages_split, use_azure=use_azure)
-                        totale_non_ivato_verificato = sum(articolo.TotaleNonIvato for articolo in doc.Articoli if articolo.Verificato == 1)
-                        totale_non_ivato_non_verificato = sum(articolo.TotaleNonIvato for articolo in doc.Articoli if articolo.Verificato != 1)
-                        totale_non_ivato = totale_non_ivato_verificato + totale_non_ivato_non_verificato
-                        st.write(
-                            f"- **Tipo**: {doc.TipoDocumento}\n"
-                            f"- **Numero**: {doc.NumeroDocumento}\n"
-                            f"- **Data**: {doc.Data}\n"
-                            f"- **Articoli Compatibili**: {len(doc.Articoli)}\n"
-                            f"- **Totale Documento**: {format_euro(doc.TotaleImponibile)}\n"
-                        )
-                        if totale_non_ivato > doc.TotaleImponibile and doc.TotaleImponibile > 0:
-                            st.warning("Totale Ave maggiore di Totale Merce")
-                        if totale_non_ivato_non_verificato > 0:
-                            st.error(f"Totale Ave Non Verificato: {format_euro(totale_non_ivato_non_verificato)}")
-                        if totale_non_ivato > 0:
-                            st.success(f"Totale Ave Verificato: {format_euro(totale_non_ivato_verificato)}")
-                        df = pd.DataFrame([{k: v for k, v in Articolo.model_dump().items() if k != ""} for Articolo in doc.Articoli])                                       
-                        if 'Verificato' in df.columns:
-                            df['Verificato'] = df['Verificato'].apply(lambda x: "✅" if x == 1 else "❌" if x == 0 else "❓" if x == 2 else x)
-                        if totale_non_ivato > 0:
-                            df["TotaleNonIvato"] = df["TotaleNonIvato"].apply(format_euro)
-                            st.dataframe(df, use_container_width=True)
-                        st.json(doc.model_dump(), expanded=False)
-                        if totale_non_ivato == 0:
-                            st.info(f"Non sono presenti articoli 'AVE'")
-                        if uploaded_file and file_path.lower().endswith(".pdf"):
-                            list_art = list_art = [articolo.CodiceArticolo for articolo in doc.Articoli] + [articolo.DescrizioneArticolo for articolo in doc.Articoli]
-                            if list_art: 
-                                new_pdf = highlight_text_in_pdf(uploaded_file.getvalue(), list_art) 
-                                pdf_viewer(input=new_pdf.getvalue(), width=1200)
-                            else:
-                                pdf_viewer(input=uploaded_file.getvalue(), width=1200)
-                        else:
-                            st.image(file_path)
-                        st.divider()
-                    except Exception as e:
-                        st.error(f"Errore durante l'elaborazione di {uploaded_file.name}: {e}")
-                    finally:
-                        if os.path.exists(file_path):
-                            os.remove(file_path)
+    initialize_session_state()
+    render_sidebar()
+    render_main_content()
 
 if __name__ == "__main__":
-    st.divider()
-    main()
+    main()