Update src/streamlit_app.py

src/streamlit_app.py

@@ -6,16 +6,12 @@ import numpy as np # Importa numpy per np.nan
 
 # --- Dati di Configurazione del Tracciato ---
 # Dizionario per i valori di default/fissi per i campi specifici del .dat
-# Basato sull'ultimo tracciato fornito dall'utente.
 fixed_and_default_values = {
     # Campi fissi Mittente (Campi 1-18) - Valori dalla tabella utente
     'codice_identificativo_cliente': '1040453', # Campo 1
-    # 'id_ldv': non è più fisso, viene da shippingMark
     'tipo_spedizione': 'N',                   # Campo 3
     'attivazione_ritiro': 'N',                      # Campo 4
     'stampa_ldv': 'N',                              # Campo 5
-    # Campo 6 (Numero Riferimento Spedizione) dal file shippingMark
-    # Campo 7 (Data Spedizione) dal file shipmentOrder.orderDate
     'ritiro_mp': 'P',                         # Campo 8
     'codice_indirizzo_mittente': '',          # Campo 9
     'ragione_sociale_mittente': 'Poste Logistics x Technolt', # Campo 10
@@ -27,7 +23,6 @@ fixed_and_default_values = {
     'cap_mittente': '27018',                  # Campo 16
     'localita_mittente': 'Vidigulfo',         # Campo 17
     'provincia_mittente': 'PV',               # Campo 18
-
     # Altri campi fissi o con default obbligatorio
     'tipo_via_destinatario': '-',             # Campo 22 (nuovo fisso)
     'provincia_destinatario': '-',            # Campo 28 (nuovo fisso)
@@ -37,20 +32,6 @@ fixed_and_default_values = {
 }
 
 # Definizione dettagliata del layout del file .dat.
-# INCLUDE SOLO I CAMPI DALL'ULTIMO TRACCIATO FORNITO DALL'UTENTE.
-# 'name': Nome interno per il campo nel codice.
-# 'length': Lunghezza fissa del campo.
-# 'numeric_pad_zero': True se il campo è numerico e va riempito con '0' a sinistra.
-# 'decimals': Numero di decimali (per campi numerici di valuta, non usati nel nuovo tracciato).
-# 'mandatory': True se il campo è obbligatorio (*) o (**) nel tracciato.
-# 'source': Indica la fonte del valore: 'fixed' (da fixed_and_default_values),
-#           'shipping_mark_file' (dal DataFrame shippingMark),
-#           'shipment_order_file' (dal DataFrame shipmentOrder),
-#           'filler' (gap nel tracciato).
-# 'excel_col': Il nome esatto della colonna nel file Excel di origine (se 'source' è 'shipping_mark_file' o 'shipment_order_file').
-# 'description': Descrizione del campo (per il file di specifiche).
-# 'start_pos': Posizione iniziale del campo (per il file di specifiche).
-# 'end_pos': Posizione finale del campo (per il file di specifiche).
 dat_format_spec = [
     # Id | Nome                        | Obbl | Tipo  | Lungh | Inizio | Descrizione                                                               | Default             | Campi
     {'id': '1', 'name': 'codice_identificativo_cliente', 'length': 12, 'numeric_pad_zero': False, 'decimals': 0, 'mandatory': True, 'source': 'fixed', 'excel_col': None, 'description': "Valore costante che identifica il cliente, viene comunicato al cliente al momento dell'attivazione del servizio, un esempio di codice è CLI 000000009", 'start_pos': 1},
@@ -71,23 +52,23 @@ dat_format_spec = [
     {'id': '16', 'name': 'cap_mittente',                'length': 9,  'numeric_pad_zero': False, 'decimals': 0, 'mandatory': True, 'source': 'fixed', 'excel_col': None, 'description': "Ignorato se è valorizzato il campo 9", 'start_pos': 214},
     {'id': '17', 'name': 'localita_mittente',           'length': 30, 'numeric_pad_zero': False, 'decimals': 0, 'mandatory': True, 'source': 'fixed', 'excel_col': None, 'description': "Ignorato se è valorizzato il campo 9", 'start_pos': 223},
     {'id': '18', 'name': 'provincia_mittente',          'length': 2,  'numeric_pad_zero': False, 'decimals': 0, 'mandatory': True, 'source': 'fixed', 'excel_col': None, 'description': "Ignorato se è valorizzato il campo 9", 'start_pos': 253},
-    
     # Filler per il gap tra Campo 18 (fine a 254) e Campo 20 (inizio a 275)
     {'id': '', 'name': 'filler_gap_18_20',             'length': 20, 'numeric_pad_zero': False, 'decimals': 0, 'mandatory': False, 'source': 'filler', 'excel_col': None, 'description': "Gap tra i campi 18 e 20", 'start_pos': 255},
-
     # Campi Destinatario e Colli
+    # NOTA: Per risolvere il problema di recupero dei dati del destinatario,
+    # 'consegnee.partner.name' verrà utilizzato direttamente per entrambi i campi 20 e 21,
+    # e non verrà rinominato nella mappatura iniziale.
     {'id': '20', 'name': 'ragione_sociale_destinatario', 'length': 40, 'numeric_pad_zero': False, 'decimals': 0, 'mandatory': True, 'source': 'shipment_order_file', 'excel_col': 'consegnee.partner.name', 'description': "Ragione sociale del destinatario", 'start_pos': 275},
     {'id': '21', 'name': 'contatto_destinatario',       'length': 20, 'numeric_pad_zero': False, 'decimals': 0, 'mandatory': True, 'source': 'shipment_order_file', 'excel_col': 'consegnee.partner.name', 'description': "Nome Contatto presso il Destinatario", 'start_pos': 315},
-    {'id': '22', 'name': 'tipo_via_destinatario',       'length': 5,  'numeric_pad_zero': False, 'decimals': 0, 'mandatory': True, 'source': 'fixed', 'excel_col': None, 'description': "Descrizione tipo via", 'start_pos': 335}, # Ora fisso
+    {'id': '22', 'name': 'tipo_via_destinatario',       'length': 5,  'numeric_pad_zero': False, 'decimals': 0, 'mandatory': True, 'source': 'fixed', 'excel_col': None, 'description': "Descrizione tipo via", 'start_pos': 335},
     {'id': '23', 'name': 'via_destinatario',            'length': 30, 'numeric_pad_zero': False, 'decimals': 0, 'mandatory': True, 'source': 'shipment_order_file', 'excel_col': 'consegnee.partner.address.address', 'description': "Indirizzo del destinatario", 'start_pos': 340},
     {'id': '24', 'name': 'numero_civico_destinatario',  'length': 5,  'numeric_pad_zero': False, 'decimals': 0, 'mandatory': True, 'source': 'shipment_order_file', 'excel_col': 'consegnee.partner.address.addressnumber', 'description': "Numero Civico Destinatario allineato a sinistra", 'start_pos': 370},
     {'id': '25', 'name': 'numero_telefono_destinatario','length': 15, 'numeric_pad_zero': False, 'decimals': 0, 'mandatory': True, 'source': 'shipment_order_file', 'excel_col': 'consegnee.partner.phonenumber', 'description': "Numero di telefono Destinatario", 'start_pos': 375},
     {'id': '26', 'name': 'cap_destinatario',            'length': 9,  'numeric_pad_zero': False, 'decimals': 0, 'mandatory': True, 'source': 'shipment_order_file', 'excel_col': 'consegnee.partner.address.zipcode', 'description': "CAP del destinatario allineato a sinistra", 'start_pos': 390},
     {'id': '27', 'name': 'localita_destinatario',       'length': 30, 'numeric_pad_zero': False, 'decimals': 0, 'mandatory': True, 'source': 'shipment_order_file', 'excel_col': 'consegnee.partner.address.city', 'description': "Località del destinatario", 'start_pos': 399},
-    {'id': '28', 'name': 'provincia_destinatario',      'length': 2,  'numeric_pad_zero': False, 'decimals': 0, 'mandatory': True, 'source': 'fixed', 'excel_col': None, 'description': "Provincia del destinatario", 'start_pos': 429}, # Ora fisso
+    {'id': '28', 'name': 'provincia_destinatario',      'length': 2,  'numeric_pad_zero': False, 'decimals': 0, 'mandatory': True, 'source': 'fixed', 'excel_col': None, 'description': "Provincia del destinatario", 'start_pos': 429},
     {'id': '29', 'name': 'numero_colli',                'length': 3,  'numeric_pad_zero': True, 'decimals': 0, 'mandatory': True, 'source': 'shipping_mark_file', 'excel_col': 'totalldv', 'description': "Numero dei colli totali che compongono la spedizione", 'start_pos': 431},
     {'id': '30', 'name': 'peso_colli',                  'length': 7,  'numeric_pad_zero': True, 'decimals': 0, 'mandatory': True, 'source': 'shipping_mark_file', 'excel_col': 'totalweight', 'description': "Peso espresso in grammi del singolo collo", 'start_pos': 434},
-    
     # Altri Campi Obbligatori dal tracciato
     {'id': '34', 'name': 'codice_servizio',             'length': 3,  'numeric_pad_zero': False, 'decimals': 0, 'mandatory': True, 'source': 'fixed', 'excel_col': None, 'description': "Vedi codifica", 'start_pos': 456},
     {'id': '42', 'name': 'identificativo_collo',        'length': 25, 'numeric_pad_zero': False, 'decimals': 0, 'mandatory': True, 'source': 'shipping_mark_file', 'excel_col': 'shippingmark', 'description': "Identificativo del singolo collo (barcode)", 'start_pos': 553},
@@ -99,13 +80,11 @@ dat_format_spec = [
 def generate_poste_dat_file(df_shipping_mark_input, df_shipment_order_input):
     """
     Genera un file .dat per Poste Italiane unendo i dati da due DataFrame.
-
     Args:
         df_shipping_mark_input (pd.DataFrame): DataFrame contenente le shipping mark e i riferimenti d'ordine.
                                              Deve contenere le colonne 'shippingMark', 'totalWeight', 'totalVolume'.
         df_shipment_order_input (pd.DataFrame): DataFrame contenente i dettagli dell'ordine.
                                               Deve contenere 'orderRef', 'orderDate' e i campi relativi al destinatario.
-
     Returns:
         tuple: (str, str) contenente i percorsi dei file .dat e .dis generati, o (None, None) in caso di errore.
     """
@@ -115,45 +94,61 @@ def generate_poste_dat_file(df_shipping_mark_input, df_shipment_order_input):
         df_shipment_order = df_shipment_order_input.copy()
 
         # Assicurati che i nomi delle colonne siano in minuscolo per una maggiore robustezza
-        # Nota: per nomi con punti come 'consegnee.partner.address.address', .lower() li mantiene così.
+        # I nomi con punti come 'consegnee.partner.address.address' rimarranno con i punti dopo .lower()
         df_shipping_mark.columns = df_shipping_mark.columns.str.lower()
         df_shipment_order.columns = df_shipment_order.columns.str.lower()
 
+        # Mappatura delle colonne di df_shipment_order che verranno rinominate PRIMA della join.
+        # 'consegnee.partner.name' non è incluso qui per permettere l'accesso diretto ai campi 20 e 21.
+        excel_col_mapping_for_rename = {
+            'orderdate': 'order_date',
+            'consegnee.partner.businessname': 'ragione_sociale_destinatario_from_excel',
+            'consegnee.partner.address.streettype': 'tipo_via_destinatario_from_excel',
+            'consegnee.partner.address.address': 'via_destinatario',
+            'consegnee.partner.address.addressnumber': 'numero_civico_destinatario',
+            'consegnee.partner.phonenumber': 'numero_telefono_destinatario',
+            'consegnee.partner.address.zipcode': 'cap_destinatario',
+            'consegnee.partner.address.city': 'localita_destinatario',
+            'consegnee.partner.address.country': 'provincia_destinatario_from_excel',
+        }
+        # Applica il mapping solo se la colonna originale (in minuscolo) esiste nel DataFrame
+        df_shipment_order.rename(columns={k.lower(): v for k, v in excel_col_mapping_for_rename.items() if k.lower() in df_shipment_order.columns}, inplace=True)
+
+
         # Verifica la presenza delle colonne necessarie nel file shipping mark
-        required_shipping_mark_cols = ['shippingmark', 'orderref', 'totalweight', 'totalldv', 'requestedshipment'] # Added requestedshipment
+        required_shipping_mark_cols = ['shippingmark', 'orderref', 'totalweight', 'totalldv', 'requestedshipment']
         if not all(col in df_shipping_mark.columns for col in required_shipping_mark_cols):
             st.error(f"Errore: Il file delle shipping mark deve contenere le colonne: {required_shipping_mark_cols}")
             return None, None
 
-        # Applica il mapping delle colonne a df_shipment_order.
-        # Le chiavi del mapping DEVONO corrispondere esattamente ai nomi delle colonne (in minuscolo)
-        # nel tuo file Excel.
-        excel_col_mapping = {
-            'orderdate': 'order_date', # Per Campo 7 - Still here for robustness even if not primary source
-            'consegnee.partner.businessname': 'ragione_sociale_destinatario_from_excel', # Changed name to avoid conflict if 'consegnee.partner.name' is used directly
-            'consegnee.partner.name': 'contatto_destinatario', # Campo 21 and 20 are both using this source
-            'consegnee.partner.address.streettype': 'tipo_via_destinatario_from_excel', # Campo 22 - now fixed, but still good to have a mapping for potential future use or debugging
-            'consegnee.partner.address.address': 'via_destinatario', # Campo 23
-            'consegnee.partner.address.addressnumber': 'numero_civico_destinatario', # Campo 24
-            'consegnee.partner.phonenumber': 'numero_telefono_destinatario', # Campo 25
-            'consegnee.partner.address.zipcode': 'cap_destinatario', # Campo 26
-            'consegnee.partner.address.city': 'localita_destinatario', # Campo 27
-            'consegnee.partner.address.country': 'provincia_destinatario_from_excel', # Campo 28 - now fixed, but keeping mapping
-        }
-        df_shipment_order = df_shipment_order.rename(columns=lambda x: excel_col_mapping.get(x, x))
-
-        # Assicurati che 'orderref' sia presente in df_shipment_order per la join
-        required_shipment_order_cols = ['orderref'] # 'order_date' is now from shipping_mark_file
-        if not all(col in df_shipment_order.columns for col in required_shipment_order_cols):
-            st.error(f"Errore: Il file degli ordini deve contenere la colonna: {required_shipment_order_cols} (anche dopo il mapping).")
+        # Verifica le colonne necessarie nel file shipment order
+        # Queste sono le colonne che saranno ACCESSE dopo il rename (se applicato) e la join.
+        # 'consegnee.partner.name' è incluso qui con il suo nome originale perché non viene rinominato.
+        required_shipment_order_final_cols = [
+            'orderref', # Per la join
+            'consegnee.partner.name', # Per ragione_sociale_destinatario e contatto_destinatario
+            'via_destinatario',
+            'numero_civico_destinatario',
+            'numero_telefono_destinatario',
+            'cap_destinatario',
+            'localita_destinatario',
+        ]
+        # Converte i nomi delle colonne finali che dovrebbero essere presenti nel df_shipment_order
+        # dopo il renaming (ma prima della join) e verifica la loro esistenza.
+        df_shipment_order_cols_after_rename = df_shipment_order.columns.tolist()
+        if not all(col in df_shipment_order_cols_after_rename for col in required_shipment_order_final_cols):
+            missing_cols = [col for col in required_shipment_order_final_cols if col not in df_shipment_order_cols_after_rename]
+            st.error(f"Errore: Il file degli ordini (ShipmentOrder_) deve contenere le seguenti colonne: {missing_cols}. Verifica attentamente la corrispondenza dei nomi (anche con punti o underscore). Ricorda che l'intestazione è alla seconda riga.")
             return None, None
 
+
         # Pulisci le colonne di join per una corrispondenza robusta (rimuovi spazi e assicurati che siano stringhe)
         df_shipping_mark['orderref'] = df_shipping_mark['orderref'].astype(str).str.strip()
         df_shipment_order['orderref'] = df_shipment_order['orderref'].astype(str).str.strip()
 
-        # Fai la join: cruciale 'how=inner' per la join "secca"
-        df_merged = pd.merge(df_shipping_mark, df_shipment_order, on='orderref', how='inner')
+        # Esegue la join: cruciale 'how=inner' per una join "secca"
+        # Utilizza suffissi per differenziare le colonne con lo stesso nome provenienti dai due DataFrame
+        df_merged = pd.merge(df_shipping_mark, df_shipment_order, on='orderref', how='inner', suffixes=('_sm', '_so'))
 
         if df_merged.empty:
             st.warning("Nessun record corrispondente trovato dopo la join. Assicurati che 'orderRef' sia presente e corrisponda in entrambi i file.")
@@ -163,8 +158,6 @@ def generate_poste_dat_file(df_shipping_mark_input, df_shipment_order_input):
         dat_content = []
         for index, row in df_merged.iterrows():
             record_parts = []
-            current_cumulative_length = 0 # Per tracciare la posizione corretta
-
             for field_spec in dat_format_spec:
                 field_name = field_spec['name']
                 length = field_spec['length']
@@ -172,70 +165,87 @@ def generate_poste_dat_file(df_shipping_mark_input, df_shipment_order_input):
                 decimals = field_spec['decimals']
                 mandatory = field_spec['mandatory']
                 source_type = field_spec['source']
-                excel_col_name = field_spec['excel_col'] # Nome della colonna in Excel (mappata)
-                
-                value_to_format = ''
+                excel_col_name = field_spec['excel_col'] # Nome della colonna come specificato nel dat_format_spec
 
+                value_to_format = ''
                 if source_type == 'fixed':
                     value_to_format = fixed_and_default_values.get(field_name, '')
                 elif source_type == 'shipping_mark_file':
-                    value_to_format = row.get(excel_col_name)
+                    # Accede alle colonne di shipping_mark utilizzando il suffisso '_sm' dopo la join
+                    # e il nome della colonna come specificato nel dat_format_spec
+                    value_to_format = row.get(f"{excel_col_name}_sm")
                     if pd.isna(value_to_format):
                         value_to_format = ''
                     # Gestione specifica per 'data_spedizione' (Campo 7) per formattazione AAAAMMGG
                     if field_name == 'data_spedizione':
-                        if pd.notna(value_to_format):
+                        if pd.notna(value_to_format) and value_to_format != '':
                             try:
-                                if isinstance(value_to_format, datetime): # Se è già un oggetto datetime
+                                if isinstance(value_to_format, datetime):
                                     value_to_format = value_to_format.strftime("%Y%m%d")
-                                elif isinstance(value_to_format, str) and len(value_to_format) == 8 and value_to_format.isdigit():
-                                    # Se è già una stringa nel formato giusto, usala così com'è
-                                    pass
-                                else: # Prova a convertirla (e.g., da Excel data numerica)
+                                elif isinstance(value_to_format, (int, float)): # Le date di Excel possono essere numeri
+                                    # L'epoch di Excel è 1899-12-30 per le date
+                                    value_to_format = pd.to_datetime(value_to_format, unit='D', origin='1899-12-30', errors='coerce')
+                                    if pd.notna(value_to_format):
+                                        value_to_format = value_to_format.strftime("%Y%m%d")
+                                    else:
+                                        value_to_format = ''
+                                elif isinstance(value_to_format, str):
+                                    # Tenta di parsare formati di data stringa comuni
                                     value_to_format = pd.to_datetime(value_to_format, errors='coerce')
                                     if pd.notna(value_to_format):
                                         value_to_format = value_to_format.strftime("%Y%m%d")
                                     else:
                                         value_to_format = ''
-                            except Exception:
-                                value_to_format = '' # Fallback se la conversione fallisce
-                        else:
-                            value_to_format = '' # Se NaN, usa vuoto
+                                else: # Fallback per tipi inaspettati
+                                    value_to_format = ''
+                            except Exception as e:
+                                st.warning(f"Errore durante la conversione della data per campo '{field_name}': {value_to_format} - {e}")
+                                value_to_format = ''
+                        else: # Se NaN o vuoto, usa stringa vuota
+                            value_to_format = ''
                 elif source_type == 'shipment_order_file':
-                    value_to_format = row.get(excel_col_name)
+                    # Accede alle colonne di shipment_order utilizzando il suffisso '_so' dopo la join.
+                    # Se la colonna originale è stata rinominata prima della join (e.g. 'orderdate' -> 'order_date'),
+                    # usa il nome rinominato per costruire il nome della colonna fusa.
+                    # Altrimenti, usa il nome originale di excel_col_name.
+                    col_to_access = excel_col_mapping_for_rename.get(excel_col_name, excel_col_name)
+                    value_to_format = row.get(f"{col_to_access}_so")
+
                     if pd.isna(value_to_format):
                         value_to_format = ''
                 elif source_type == 'filler':
                     value_to_format = ' ' * length # Riempie il filler con spazi
-                
-                # Conversione in stringa e pulizia iniziale
+
                 value_str = str(value_to_format).strip()
 
                 # Gestione specifica per Campo 25 (Numero di telefono Destinatario) "se vuoto mettere tanti zeri"
-                if field_name == 'numero_telefono_destinatario' and mandatory and not value_str:
+                if field_name == 'numero_telefono_destinatario' and (not value_str or value_str.lower() == 'nan'):
                     value_str = '0' * length
                 # Se il campo è obbligatorio e il valore è ancora vuoto dopo aver cercato/gestito casi speciali, usa il default (spazi o zeri)
                 elif mandatory and not value_str:
                     if is_numeric_pad_zero:
                         value_str = '0' * length
                     else:
-                        value_str = ' ' * length 
+                        value_str = ' ' * length
 
                 # Formattazione finale (allineamento, padding)
                 if is_numeric_pad_zero:
                     try:
-                        clean_value = value_str.replace(',', '.') # Sostituisce virgole con punti
-                        num_val = float(clean_value) * (10**decimals)
+                        clean_value = value_str.replace(',', '.')
+                        num_val = float(clean_value)
+                        # Arrotonda e converte in stringa, riempiendo con '0' a sinistra
                         formatted_value = str(int(round(num_val))).rjust(length, '0')
                     except ValueError:
-                        formatted_value = '0'.rjust(length, '0') # Fallback se la conversione fallisce
+                        # Fallback se la conversione numerica fallisce
+                        formatted_value = '0'.rjust(length, '0')
                 else:
+                    # Allinea a sinistra e riempi con spazi
                     formatted_value = value_str.ljust(length)
-                
+
                 # Trunca se la stringa è più lunga della lunghezza specificata
                 final_field_value = formatted_value[:length]
                 record_parts.append(final_field_value)
-            
+
             dat_content.append("".join(record_parts))
 
         # Genera il nome del file con timestamp (uguale per .dat e .dis)
@@ -245,30 +255,38 @@ def generate_poste_dat_file(df_shipping_mark_input, df_shipment_order_input):
         dat_filename = f"{base_filename}.dat"
         dis_filename = f"{base_filename}.dis"
 
-        # Usa la directory temporanea /tmp che è scrivibile su Hugging Face Spaces
+        # Utilizza la directory temporanea /tmp che è scrivibile su Hugging Face Spaces
         temp_dir = "/tmp"
-        os.makedirs(temp_dir, exist_ok=True) 
+        os.makedirs(temp_dir, exist_ok=True)
 
         dat_filepath = os.path.join(temp_dir, dat_filename)
         dis_filepath = os.path.join(temp_dir, dis_filename)
 
-        with open(dat_filepath, 'w', encoding='utf-8') as f: # Specifica encoding utf-8
+        # Scrivi il contenuto nel file .dat con encoding UTF-8
+        with open(dat_filepath, 'w', encoding='utf-8') as f:
             for line in dat_content:
                 f.write(line + '\n')
-        
-        with open(dis_filepath, 'w') as f:
-            pass # Crea un file vuoto
-        
-        return dat_filepath, dis_filepath
 
+        # Crea un file .dis vuoto con encoding UTF-8
+        with open(dis_filepath, 'w', encoding='utf-8') as f:
+            pass
+
+        return dat_filepath, dis_filepath
     except pd.errors.EmptyDataError:
         st.error("Errore: Uno dei file Excel è vuoto o non contiene dati validi. Assicurati che non siano completamente vuoti.")
         return None, None
+    except KeyError as e:
+        st.error(f"Errore: Colonna mancante nel file Excel. Assicurati che tutte le colonne necessarie ('shippingMark', 'orderRef', 'totalWeight', 'totalLdv', 'requestedShipment' e i campi del destinatario come 'consegnee.partner.name', 'consegnee.partner.address.address' ecc.) siano presenti e che i nomi corrispondano esattamente (case-insensitive) a quelli previsti. Errore specifico: {e}")
+        st.warning("Ricorda che l'intestazione dei file Excel deve essere alla **seconda riga**.")
+        return None, None
     except FileNotFoundError as e:
         st.error(f"Errore: File non trovato - {e}. Assicurati che i file siano caricati correttamente.")
         return None, None
     except Exception as e:
         st.error(f"Si è verificato un errore inatteso durante l'elaborazione: {e}")
+        import traceback
+        st.error("Traceback completo per il debug:")
+        st.error(traceback.format_exc()) # Stampa il traceback completo per il debug
         st.warning("Verifica che i nomi delle colonne nei tuoi file Excel corrispondano alle aspettative del programma, specialmente 'orderRef' e i campi relativi al destinatario. Ricorda che l'intestazione è alla seconda riga.")
         return None, None
 
@@ -277,19 +295,20 @@ def generate_dat_format_spec_text():
     spec_text = "Specifiche del Tracciato File .DAT\n\n"
     spec_text += "Id\tNome Campo\tObbligatorio\tTipo\tLunghezza\tInizio\tDescrizione\tDefault / Fonte Dati\n"
     spec_text += "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n"
-
     # Ricalcolo delle start_pos per la documentazione basata sulle lunghezze
     current_start_pos_for_spec = 1
     for field_spec in dat_format_spec:
+        # Assegna la posizione iniziale calcolata per l'output della documentazione
         field_spec['start_pos_for_spec_output'] = current_start_pos_for_spec
+        # Incrementa la posizione iniziale per il campo successivo
         current_start_pos_for_spec += field_spec['length']
 
-
     for field_spec in dat_format_spec:
         field_id = field_spec.get('id', '')
+        # Formatta il nome del campo per la visualizzazione, rimuovendo underscore e capitalizzando
         display_name = field_spec['name'].replace('_', ' ').replace('fixed', '').replace('derived', '').strip().title()
-        
-        # Gestione speciale per nomi lunghi per migliorare la leggibilità
+
+        # Gestione speciale per nomi lunghi per migliorare la leggibilità nella tabella di testo
         if display_name == 'Numero Riferimento Spedizione':
             display_name = 'Num. Rif. Spedizione'
         elif display_name == 'Numero Civico Destinatario':
@@ -353,14 +372,12 @@ def generate_dat_format_spec_text():
         elif display_name == 'Filler Gap 18 20':
             display_name = 'Gap'
 
-
-        obligatory = "*" if field_spec['mandatory'] else ""
-        field_type = "char" # Tutte sono char
+        obligatory = "*" if field_spec['mandatory'] else "" # Indica se il campo è obbligatorio
+        field_type = "char" # Tutte le colonne sono considerate di tipo carattere
         length = field_spec['length']
         # Usa la start_pos ricalcolata per la documentazione
         start_pos_output = field_spec['start_pos_for_spec_output']
         description = field_spec['description']
-
         source_info = ""
         source_type = field_spec['source']
         if source_type == 'fixed':
@@ -375,21 +392,18 @@ def generate_dat_format_spec_text():
                 source_info += " (riempi con '0' se vuoto)"
         elif source_type == 'filler':
             source_info = "Spazi vuoti (Gap)"
-        
-        # Aggiusta la colonna Descrizione per non essere troppo larga nella tabella di testo
+
+        # Adatta la colonna Descrizione per non essere troppo larga nella tabella di testo
         if len(description) > 50:
             description = description[:47] + "..."
-
+        # Aggiungi la riga formattata al testo delle specifiche
         spec_text += f"{field_id}\t{display_name:<25}\t{obligatory:<12}\t{field_type:<4}\t{length:<9}\t{start_pos_output:<7}\t{description:<50}\t{source_info}\n"
-    
     return spec_text
 
 # --- Sezione App Streamlit ---
 def app():
     st.set_page_config(layout="centered", page_title="Generatore File Poste .DAT")
-
     st.title("📦 Generatore File .DAT per Poste Italiane")
-
     st.markdown("""
         Carica i tuoi due file Excel per generare il file .DAT nel formato richiesto da Poste Italiane.
         Ogni "shipping mark" (LDV) nel file `ShippingMark_` genererà un record nel file di output.
@@ -397,15 +411,19 @@ def app():
         **Nota**: I file Excel devono avere l'intestazione sulla **seconda riga**.
         """)
 
+    # Caricamento dei file
     shipping_mark_file = st.file_uploader("Carica il file ShippingMark_ (con 'shippingMark', 'orderRef', 'totalWeight', 'totalLdv', 'requestedShipment')", type=["xlsx"])
     shipment_order_file = st.file_uploader("Carica il file ShipmentOrder_ (con 'orderRef' e dettagli destinatario)", type=["xlsx"])
 
     dat_filepath = None
     dis_filepath = None
-    
-    # Aggiungi un pulsante per innescare la generazione
+
+    # Pulsante per innescare la generazione dei file
     if shipping_mark_file and shipment_order_file:
+        # Aggiungi un placeholder per il messaggio di caricamento/stato
+        status_message_placeholder = st.empty()
         if st.button("Crea File DAT e DIS"):
+            status_message_placeholder.info("Elaborazione in corso... Attendere.")
             try:
                 # Leggi i file Excel, specificando che l'intestazione è alla seconda riga (indice 1)
                 df_shipping_mark = pd.read_excel(shipping_mark_file, header=1)
@@ -414,54 +432,80 @@ def app():
                 # Esegui la funzione di generazione
                 dat_filepath, dis_filepath = generate_poste_dat_file(df_shipping_mark, df_shipment_order)
 
+                if dat_filepath and dis_filepath:
+                    status_message_placeholder.success("File generati con successo!")
+                else:
+                    # Se generate_poste_dat_file ha restituito None, un errore è già stato mostrato
+                    # Questo garantisce che il messaggio di errore rimanga visibile
+                    pass
+
             except Exception as e:
-                st.error(f"Errore: {e}")
+                status_message_placeholder.error(f"Si è verificato un errore durante la lettura dei file Excel: {e}")
                 st.warning("Assicurati che i file siano in formato .xlsx, non siano corrotti e che l'intestazione sia effettivamente alla seconda riga.")
+            finally:
+                # La logica del finally assicura che il messaggio di caricamento venga rimosso,
+                # ma i messaggi di successo/errore specifici rimangano.
+                if status_message_placeholder.empty: # Se non ci sono messaggi attivi
+                    status_message_placeholder.empty() # Assicurati che sia vuoto
 
+    # Mostra i pulsanti di download se i file sono stati generati con successo
     if dat_filepath and dis_filepath:
         # Ottieni il nome base del file (es. SDA20240101123456789)
         base_filename = os.path.basename(dat_filepath).replace('.dat', '')
-
-        st.success("File generati con successo! Puoi scaricarli qui sotto:")
-        # Per consentire il download in Streamlit, dobbiamo leggere il contenuto del file
-        # in modalità binaria ('rb') e passarlo al download_button.
+        st.write("---") # Separatore visivo
+        st.subheader("Scarica i File Generati")
+        st.markdown(f"I file `{base_filename}.dat` e `{base_filename}.dis` sono stati generati.")
+        st.markdown("""
+            **Nota sul download automatico:**
+            Per motivi di sicurezza del browser, Streamlit non consente il download automatico di file
+            senza un'interazione esplicita dell'utente dopo il click sul pulsante "Crea File".
+            È necessario cliccare sui pulsanti qui sotto per avviare il download dei file.
+            """)
+
+        # Pulsante per scaricare il file .dat
         with open(dat_filepath, "rb") as f:
             st.download_button(
                 label=f"Scarica {base_filename}.dat",
                 data=f.read(),
                 file_name=f"{base_filename}.dat",
                 mime="text/plain", # Tipo MIME per file di testo generici
-                key="download_dat_btn"
+                key="download_dat_btn",
+                help="Clicca per scaricare il file .dat generato."
             )
-        
+
+        # Pulsante per scaricare il file .dis
         with open(dis_filepath, "rb") as f:
             st.download_button(
                 label=f"Scarica {base_filename}.dis",
                 data=f.read(),
                 file_name=f"{base_filename}.dis",
                 mime="text/plain",
-                key="download_dis_btn"
+                key="download_dis_btn",
+                help="Clicca per scaricare il file .dis generato."
             )
 
     st.markdown("---")
     st.subheader("Specifiche del Tracciato .DAT")
     st.markdown("Qui puoi scaricare un file di testo con la descrizione dettagliata del formato del file .DAT generato:")
-    
+
+    # Genera il testo delle specifiche
     spec_text_content = generate_dat_format_spec_text()
-    
+
+    # Pulsante per scaricare le specifiche
     st.download_button(
         label="Scarica Specifiche Tracciato DAT",
-        data=spec_text_content.encode('utf-8'),
+        data=spec_text_content.encode('utf-8'), # Codifica il testo in UTF-8
         file_name="DAT_Format_Specification.txt",
         mime="text/plain",
-        key="download_spec_btn"
+        key="download_spec_btn",
+        help="Clicca per scaricare il documento con le specifiche del formato DAT."
     )
-
     st.markdown("---")
     st.info("""
         **Nota importante sui nomi delle colonne nei tuoi file Excel:**
-        Assicurati che i nomi delle colonne nel tuo file `ShipmentOrder_` (es. 'consegnee.partner.name', 'consegnee.partner.address.address') e `ShippingMark_` (es. 'shippingMark', 'orderRef', 'requestedShipment', 'totalLdv', 'totalWeight') corrispondano **esattamente** ai nomi completi con la notazione a punti (o CamelCase originali se è il caso dopo il `header=1`) una volta letti da Excel con l'intestazione alla seconda riga.
+        Assicurati che i nomi delle colonne nel tuo file `ShipmentOrder_` (es. 'consegnee.partner.name', 'consegnee.partner.address.address') e `ShippingMark_` (es. 'shippingMark', 'orderRef', 'totalLdv', 'totalWeight', 'requestedShipment') corrispondano **esattamente** ai nomi completi con la notazione a punti (se presente).
         """)
 
+# Punto di ingresso dell'applicazione Streamlit
 if __name__ == "__main__":
     app()