From b9c3024e045543a61d175bfde9ee6c49294ed4d0 Mon Sep 17 00:00:00 2001
From: Miguel <miguel.vera.csa@gmail.com>
Date: Wed, 5 Feb 2025 12:58:41 +0100
Subject: [PATCH] Funcionando mejor

---
 config.json                                   |   2 +-
 main.py                                       |  21 +-
 .../__pycache__/mensaje_email.cpython-310.pyc | Bin 2632 -> 3051 bytes
 models/mensaje_email.py                       |  45 ++-
 .../__pycache__/email_parser.cpython-310.pyc  | Bin 3865 -> 7200 bytes
 utils/email_parser.py                         | 362 ++++++++++++------
 6 files changed, 311 insertions(+), 119 deletions(-)

diff --git a/config.json b/config.json
index e8bedec..f9b1ad9 100644
--- a/config.json
+++ b/config.json
@@ -1,5 +1,5 @@
 {
-    "input_dir": "D:\\Proyectos\\Scripts\\EmailCrono",
+    "input_dir": "C:\\Trabajo\\VM\\40 - 93040 - HENKEL - NEXT2 Problem\\Reporte\\Emails",
     "output_dir": "C:\\Users\\migue\\OneDrive\\Miguel\\Obsidean\\Trabajo\\VM\\04-InLavoro\\HENKEL\\93040 - HENKEL - BowlingGreen\\Description\\HENKEL - ALPLA - AUTEFA - Batch Data",
     "cronologia_file": "cronologia.md",
     "attachments_dir": "adjuntos"
diff --git a/main.py b/main.py
index 84ae2f5..469ff41 100644
--- a/main.py
+++ b/main.py
@@ -4,6 +4,7 @@ from pathlib import Path
 from utils.email_parser import procesar_eml
 from utils.markdown_handler import cargar_cronologia_existente
 from config.config import Config
+import hashlib
 
 def main():
     config = Config()
@@ -31,19 +32,35 @@ def main():
     mensajes = []
     print(f"Loaded {len(mensajes)} existing messages")
     mensajes_hash = {msg.hash for msg in mensajes}
+    
+    total_procesados = 0
+    total_nuevos = 0
+    mensajes_duplicados = 0
 
     for archivo in eml_files:
-        print(f"Processing {archivo}")
+        print(f"\nProcessing {archivo}")
         nuevos_mensajes = procesar_eml(archivo, config.get_attachments_dir())
+        total_procesados += len(nuevos_mensajes)
+        
+        # Verificar duplicados
         for msg in nuevos_mensajes:
             if msg.hash not in mensajes_hash:
                 mensajes.append(msg)
                 mensajes_hash.add(msg.hash)
+                total_nuevos += 1
+            else:
+                mensajes_duplicados += 1
 
+    print(f"\nEstadísticas de procesamiento:")
+    print(f"- Total mensajes encontrados: {total_procesados}")
+    print(f"- Mensajes únicos añadidos: {total_nuevos}")
+    print(f"- Mensajes duplicados ignorados: {mensajes_duplicados}")
+
+    # Ordenar todos los mensajes por fecha
     mensajes.sort(key=lambda x: x.fecha)
 
     output_file = config.get_cronologia_file()
-    print(f"Writing to {output_file}")
+    print(f"\nWriting {len(mensajes)} messages to {output_file}")
     with open(output_file, 'w', encoding='utf-8') as f:
         for msg in mensajes:
             f.write(msg.to_markdown())
diff --git a/models/__pycache__/mensaje_email.cpython-310.pyc b/models/__pycache__/mensaje_email.cpython-310.pyc
index fdaa767c42b6cccfa295d5080d464ed415cf7f06..e4a679143fc0fe235bde656de7cce2482cd5f854 100644
GIT binary patch
delta 947
zcmYjP&ui2`6wdtEB%5v)TDO#1Thq!`mWnKjc<@l6f?gC#^<Z5o+059c>`u0mER;22
z@lYuAW)5CFB=j$k-aL5e#ecv{KoC57R4>JYZ+1)R4D-#r_r7^E^S=37`!!PyY}?YH
z{aioZemD84`T-9OFm)JfFv5=jF$yU|8!%@Y!#PUuww90>Khj>$Cp4xR%C!tLlB00`
z!lF5n3ww4%GRjI!k7-VlQcSW^T*?vB_H2eTJ%&ArKH?Y*$2xHIW~^rhGvOed=%aOc
zydKdkHZi6_1diR%8kO`mdANd|l>#|~YD=!RL~Gw|jur!KTW81~=q>T~?yckuTUNtN
zkI392mb@Tgzg_5Vug3)|=x*SP!jQbzaXsEJ(l2D$+N^jT?h4Mf(jVl;(gGBNB8n_R
zk%_NijH<W-R+UtsSBXi|>+~C%P5;vO=+4Pu=@6l->7=o=I0rimoeM8uywDj}bE70D
z!7WV{OP?D}w3;3m-_b_unQOxmcrR4wfe~pLVhF0F?c$tdB-avj$wy@kB2*yIVH{P=
zlH$RvN(zd^I7Uj113as3(}XZ1Ge;WGsGM1#-9)bCD68b!5Grf-kKkO(Id6}-;L>&a
z!r5`d9q073@V&t4x!~g+r^`j??sBK?hAs;nE`aDdUeIm(!u9;q6X7uKcy6~Bgcm9I
z`rPpu7m@$Q_gpc~=|ZY#$S)<m;15VET#++yD>)4?u<9@C-8!p3sXu+@|3Tnh26w}j
z^NOP6lC}a>emS8)6<ewwFK;Sv0189Br{lK^(q;E#Q@P6PJA9w{+dPcUW!kKIfrz;9
zS+J$}n^)lX>~b&K5`pZx9e)7N-mLNtSJw~1G0BSfel*^YHp{iSSCBlM0;m}a#H1F&
n$U^j=WloWFy}XVZ>2dkN^pa_twTda#A7~ik$J|eUmtXt`+?@1b

delta 518
zcmX|8O=}ZD7@l`NcE)WsVy!mS#)5~!LP`sMTs$aLdgx87ml6*NvnDAvo6fEhbeEn4
z&kpLL2(ySkK=kg_KcL`(zrd>}z4%Td&hR|%^9(O9Gtc~7{<73eqbMY}UhTdc1dR{P
zH}p6_D-hd=><Ll<8P~9f)e%iADCvNdtf05agYzXXxPyu~s#yhD`@iEAm`g`d!5k}4
z138K`b-ci?Qslw~T4-8`iv4qemU9;t!Vladv9kBrt#-3(Zg$7rX>V&Lo(A3Vvn!qQ
zHx0vB+RyA_E9gxo$ynF?ARUcsYLc2|kNa_8|FCtt$=6m}_y`UhLdHSSRZ5|Ox`|s+
zJK<kp+3tv!5P$qGUI4UgUtWe4`&_QUzI`vZ;JW=Lf55K&q_&T#pM{vE)A8w$19IXS
z9IfVxoshSzgq%BpnFST8z)Alk<Fk#GQCN)6y*@R{(ub)z?Byo%UJiTN@X@GWvqOE&
zY|L7Q$yAR9NtVadbk5+>zQ~hlo|;9}b2{tQX{5V|%-`<<EQ0+N-hp+yvvA|wii*@y
SLmB_Eu{3Qg=Bj<YaQ`ojk$E2g

diff --git a/models/mensaje_email.py b/models/mensaje_email.py
index 4a52c2c..0fc4fed 100644
--- a/models/mensaje_email.py
+++ b/models/mensaje_email.py
@@ -25,17 +25,26 @@ class MensajeEmail:
             # Skip metadata lines
             if line.strip().startswith(('Da: ', 'Inviato: ', 'A: ', 'From: ', 'Sent: ', 'To: ')) or line.strip().startswith('Oggetto: '):
                 continue
-            cleaned_lines.append(line)
+            # Limpiar espacios múltiples dentro de cada línea, pero mantener la línea completa
+            cleaned_line = re.sub(r' +', ' ', line)
+            cleaned_lines.append(cleaned_line)
         
-        # Unir las líneas
+        # Unir las líneas preservando los saltos de línea
         text = '\n'.join(cleaned_lines)
         
-        # Primero limpiamos la combinación específica de CRLF+NBSP+CRLF
+        # Limpiar la combinación específica de CRLF+NBSP+CRLF
         text = re.sub(r'\r?\n\xa0\r?\n', '\n', text)
-
+        
+        # Reemplazar CRLF por LF
+        text = text.replace('\r\n', '\n')
+        
+        # Reemplazar CR por LF
+        text = text.replace('\r', '\n')
+        
         # Reemplazar 3 o más saltos de línea por dos
         text = re.sub(r'\n{3,}', '\n\n', text)
-
+        
+        # Eliminar espacios al inicio y final del texto completo
         return text.strip()
     
     def to_markdown(self):
@@ -80,5 +89,27 @@ class MensajeEmail:
         return fecha
 
     def _generar_hash(self):
-        texto = f"{self.remitente}{self.fecha.isoformat()}{self.contenido}"
-        return hashlib.md5(texto.encode()).hexdigest()
\ No newline at end of file
+        """
+        Genera un hash único para el mensaje basado en una combinación de campos
+        que identifican únicamente el mensaje
+        """
+        # Limpiar y normalizar el contenido para el hash
+        # Para el hash, sí normalizamos completamente los espacios
+        contenido_hash = re.sub(r'\s+', ' ', self.contenido).strip()
+        
+        # Normalizar el subject
+        subject_normalizado = re.sub(r'\s+', ' ', self.subject if self.subject else '').strip()
+        
+        # Crear una cadena con los elementos clave del mensaje
+        elementos_hash = [
+            self.remitente.strip(),
+            self.fecha.strftime('%Y%m%d%H%M'),  # Solo hasta minutos para permitir pequeñas variaciones
+            subject_normalizado,
+            contenido_hash[:500]  # Usar solo los primeros 500 caracteres del contenido normalizado
+        ]
+        
+        # Unir todos los elementos con un separador único
+        texto_hash = '|'.join(elementos_hash)
+        
+        # Generar el hash
+        return hashlib.md5(texto_hash.encode()).hexdigest()
\ No newline at end of file
diff --git a/utils/__pycache__/email_parser.cpython-310.pyc b/utils/__pycache__/email_parser.cpython-310.pyc
index 14b6cecedc9cd34833da0af5b856ac04b04c97cb..15fe621948d32057640df058fe1153381e8c0b3b 100644
GIT binary patch
literal 7200
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
RTF$)FaIQE{JFfeK{|CGK7D503

delta 2339
zcmZ8j&2Jk;6rY)0+q>(vy|&XNPSPk<X{pt!4X8pC(r{?$2P$a=RDu<iwasj7C;rOp
z1h>_!T#*)1i5#LmQ7&t7%Be#92NfqiM7g0oaBi=NN{B<ln{{GBZS9*k@8dV`y`A^$
z@XfEMv+YdAK=65T`P=H{@vZC>{%Y$uKWNbOJ!D(dq#0QAG)r@^7AXD@m94G6HhUxB
zqrs!V<4q8R1PT$wl=O)|;1#M4`NV+dSRk5QCq5Q9BsA5>=h2NvJ`n_VS|9t0P}omZ
z<f~Qm00{-OZ}<t30Ig1qDglcmS2oZ(?r}vV*YOHsmp4$T(sUnVG*Innyg8nbHULum
zl=vxM<H-#qQYEkxTA1piQ0oKKI+4;jwEF()aiP$33GF*hmlX*0FVPZ?YoGz94wyY~
z?Bg*+tuf>qG*9!PP7AU~8|eI=E)Tl2P(xK1GQ60J1BGLX6x}B!u)Q&}o1sDVL5BN|
z905dmWSqvn6U|->W=h!AZ>UPuP#3BU$j?AA4JdC~Wcm;y=%?ahABc;c^0Oiv8t^)#
z<~Ptl9sHcgg{GAG78E~EkzWuNgf{6HMKR3K(LQE>iy|Ex1PygN2PUgeW92v~UjUzn
zJc}{x(>R<wz~w|i<dz6rn$p5^xFqOt_z#}BLo!B$jbOvL{q{Cq*j6H~>hcPAZ}BMM
zaaQj{iN^Ap$3a6*&PKQ%sf%u-v5jq`>D;Px>y+2L?I5L`N$Yb}x8>gIu=%6GmGtMY
zPQoE&!p2~U60sqZq5+wb+(976g6HYu7c9BWOHz<zRFVlvVvnKmDJhx;5|Nwij()WY
z!SeQ7GtYF8m6O4*i4&xp4YthLT%<sJtSB91g9J~^nZuA$r%~sT;c<s?uUqG}@`$b0
zc(Y-vUVE*>a=~=w=)$=4Dgm*Ln(I)PRam<lB?o+@dv3>J4sSDC19@C5TWh%kj=chY
zkvgbgquz48U^6q`i&V)E(uot3IYm}Qo?US&O^2<}cDI!QsaFGH5)+%)AX&x0DpBFl
za28wGz}AjMW-!?)s1{CQZHHiWXNnjEG(=kL$xQIIFu9vmOsvf*h5{g1149sELm}7%
znMT-YIBij0h`o<|7jmAQgU9<BL+!5S5A~1=-*p9}mi8L*N?o|L^7{!qLJ1ReFk{r1
zAIz8pPm07k%n7RcDY(cQTxgvpeFJRZs<SJwLfgaTHla7uq25O{wL;i?RPzlu2d~bz
zl3)|ddn;t<_}$R)`u`m7iuAHUHL7poWeI5ZQKv~^eo}Lj_$JQ?a~;F{$w232m@hQX
z7a3m@SwFRE?*@>803Hg%d-xJoPl5$QFlgOfrz}LB1*b<mC(;5&m~3J8Na&%(^CGv7
zmkV(x+ASDq!yJDR%DzyQIMl~O^#4ND{8TF^Z9f|3H8B2tXq@6jp^BtP2~FrUx0$HM
zzYGfzVK<q4uaUaM+RX@7>TvhM9bMkdQ}W^kACn_vM!fAboO;VP9L}A^TGMUuV0v`M
zdR@9}4qaYr@wQhU2`(09Xrw^bMcE28f#*7`vg9t-9NVmWmF8N5*Fnr9wd*uiY)j6P
z#deDWUWMQ8xOQ4fI?nAz+o9|Xpxed$HUI>eoShDS9G&Vh`E$sQNs^R-s4b`IvbfbP
z+hl9psW@!0R{yMRo3zd<dvV%|3k{uuEIen~WpmP3kE5)>NMmOu;JhR<J@yU|+u(JW
zU2!+s37LUwn?Y}EvNtQWyJro`@X`>A%noZWx*ik)PQ4E1-Zda59>G&PrtG~z|H|fr
zoe8Uo$qRDVR0sQMkbw>Kt%avaQg%J;WapAU&9pTQZ9h#$2)p$CgYg1R9tLoBDCn2Q
z%x5X!pUGBbM}i+pU(6i^7GAp>CFP4*tVPKxgQ?~**~&1;+g+EjgyfZai`z=8-7OpJ
zq69b_+?#m!z)SP_JZSEt;E#zDCnQ@g+6lMm)Ei9x)v(Q&KN(*G##D(SvDpW~>B;J~
rc&@NZQXqZzRc$!ZBW<qPrfUs%9)=A3bpfJ5`trNC#yrt3nX~@_lEzAP

diff --git a/utils/email_parser.py b/utils/email_parser.py
index 5ff0a79..6ba70e9 100644
--- a/utils/email_parser.py
+++ b/utils/email_parser.py
@@ -9,126 +9,270 @@ from bs4 import BeautifulSoup
 from email.utils import parsedate_to_datetime
 from models.mensaje_email import MensajeEmail
 from utils.attachment_handler import guardar_adjunto
+import tempfile
+import os
+
+def _get_payload_safely(parte):
+    """
+    Obtiene el payload de una parte del email de forma segura
+    """
+    try:
+        if parte.is_multipart():
+            return None
+        payload = parte.get_payload(decode=True)
+        if payload is None:
+            return None
+        charset = parte.get_content_charset() or 'utf-8'
+        return payload.decode(charset, errors='ignore')
+    except Exception as e:
+        print(f"Error getting payload: {str(e)}")
+        return None
+
+def _extract_subject_from_text(text):
+    """
+    Extrae el asunto de un texto dados diferentes formatos de cabecera
+    """
+    subject_headers = {
+        'Oggetto: ': 9,      # Italian
+        'Subject: ': 9,      # English
+        'Asunto: ': 8,       # Spanish
+        'Sujet: ': 7,        # French
+        'Betreff: ': 9       # German
+    }
+    
+    for line in text.split('\n'):
+        line = line.strip()
+        for header, offset in subject_headers.items():
+            if line.startswith(header):
+                return line[offset:].strip()
+    return None
+
+def _should_skip_line(line):
+    """
+    Determina si una línea debe ser omitida por ser una cabecera de email
+    """
+    headers_to_skip = [
+        'Da: ', 'Inviato: ', 'A: ',           # Italian
+        'From: ', 'Sent: ', 'To: ',           # English
+        'De: ', 'Enviado: ', 'Para: ',        # Spanish
+        'Von: ', 'Gesendet: ', 'An: ',        # German
+        'De : ', 'Envoyé : ', 'À : '          # French
+    ]
+    return any(line.strip().startswith(header) for header in headers_to_skip)
 
 def _html_a_markdown(html):
-    # Primero limpiamos los caracteres especiales en el HTML
-    html = html.replace('\xa0', ' ')  # NBSP a espacio normal
-    html = html.replace('\r\n', '\n') # CRLF a LF
-    html = html.replace('\r', '\n')   # CR a LF
-    
-    soup = BeautifulSoup(html, 'html.parser')
-    
-    # Convert tables, keeping all newlines
-    for table in soup.find_all('table'):
-        rows = table.find_all('tr')
+    """
+    Convierte contenido HTML a texto markdown, extrayendo el asunto si está presente
+    """
+    if html is None:
+        return (None, "")
         
-        if rows:
-            markdown_table = []
-            # Get maximum width for each column
-            max_widths = []
-            for row in rows:
-                cells = row.find_all(['th', 'td'])
-                while len(max_widths) < len(cells):
-                    max_widths.append(0)
-                for i, cell in enumerate(cells):
-                    max_widths[i] = max(max_widths[i], len(cell.get_text().strip()))
-            
-            # Build table rows
-            header_row = rows[0].find_all(['th', 'td'])
-            header = '| ' + ' | '.join(cell.get_text().strip().ljust(max_widths[i]) 
-                                     for i, cell in enumerate(header_row)) + ' |'
-            separator = '|' + '|'.join('-' * (width + 2) for width in max_widths) + '|'
-            
-            markdown_table.append(header)
-            markdown_table.append(separator)
-            
-            for row in rows[1:]:
-                cells = row.find_all(['td', 'th'])
-                row_text = '| ' + ' | '.join(cell.get_text().strip().ljust(max_widths[i]) 
-                                           for i, cell in enumerate(cells)) + ' |'
-                markdown_table.append(row_text)
-            
-            # Join with newlines and replace
-            new_text = '\n' + '\n'.join(markdown_table)
-            table.replace_with(soup.new_string(new_text))
-    
-    # Handle basic HTML elements
-    for br in soup.find_all('br'):
-        br.replace_with('\n')
-    
-    # Get text content
-    text = soup.get_text()
-    
-    # Only extract subject and remove basic email headers
-    lines = text.split('\n')
-    cleaned_lines = []
-    subject = None
-    
-    for line in lines:
-        # Extract subject if present
-        if line.startswith('Oggetto: '):
-            subject = line[9:].strip()
-            continue
+    try:
+        # Limpieza básica
+        html = html.replace('\xa0', ' ')  # NBSP a espacio normal
+        html = html.replace('\r\n', '\n') # CRLF a LF
+        html = html.replace('\r', '\n')   # CR a LF
         
-        # Skip only the most basic email headers
-        if line.startswith(('Da: ', 'Inviato: ', 'A: ', 'From: ', 'Sent: ', 'To: ')):
-            continue
+        soup = BeautifulSoup(html, 'html.parser')
+        
+        # Procesar tablas
+        for table in soup.find_all('table'):
+            try:
+                rows = table.find_all('tr')
+                if not rows:
+                    continue
+                    
+                markdown_table = []
+                max_widths = []
+                
+                # Calcular anchos máximos
+                for row in rows:
+                    cells = row.find_all(['th', 'td'])
+                    while len(max_widths) < len(cells):
+                        max_widths.append(0)
+                    for i, cell in enumerate(cells):
+                        cell_text = cell.get_text().strip()
+                        max_widths[i] = max(max_widths[i], len(cell_text))
+                
+                # Construir tabla markdown
+                if max_widths:  # Solo si tenemos celdas válidas
+                    header_row = rows[0].find_all(['th', 'td'])
+                    header = '| ' + ' | '.join(cell.get_text().strip().ljust(max_widths[i]) 
+                                             for i, cell in enumerate(header_row)) + ' |'
+                    separator = '|' + '|'.join('-' * (width + 2) for width in max_widths) + '|'
+                    
+                    markdown_table.append(header)
+                    markdown_table.append(separator)
+                    
+                    for row in rows[1:]:
+                        cells = row.find_all(['td', 'th'])
+                        row_text = '| ' + ' | '.join(cell.get_text().strip().ljust(max_widths[i]) 
+                                                   for i, cell in enumerate(cells)) + ' |'
+                        markdown_table.append(row_text)
+                    
+                    table.replace_with(soup.new_string('\n' + '\n'.join(markdown_table)))
+            except Exception as e:
+                print(f"Error procesando tabla: {str(e)}")
+                continue
+        
+        # Procesar saltos de línea
+        for br in soup.find_all('br'):
+            br.replace_with('\n')
+        
+        # Obtener texto limpio
+        text = soup.get_text()
+        
+        # Procesar líneas
+        cleaned_lines = []
+        subject = None
+        
+        for line in text.split('\n'):
+            if not subject:
+                subject = _extract_subject_from_text(line)
             
-        # Keep the line as is, with all its spacing
-        cleaned_lines.append(line)
-    
-    # Join lines preserving all newlines
-    text = '\n'.join(cleaned_lines)
-    
-    return subject, text
+            if not _should_skip_line(line):
+                cleaned_lines.append(line)
+        
+        final_text = '\n'.join(cleaned_lines).strip()
+        return (subject, final_text)
+        
+    except Exception as e:
+        print(f"Error en html_a_markdown: {str(e)}")
+        return (None, html if html else "")
+
+def _procesar_email_adjunto(parte, dir_adjuntos):
+    """
+    Procesa un email que viene como adjunto dentro de otro email.
+    """
+    try:
+        mensajes = []
+        if parte.is_multipart():
+            # Si es multipart, procesar cada subparte
+            for subparte in parte.walk():
+                if subparte.get_content_type() == "message/rfc822":
+                    # Si es un mensaje RFC822, obtener el payload como lista
+                    payload = subparte.get_payload()
+                    if isinstance(payload, list):
+                        for msg in payload:
+                            mensajes.extend(procesar_eml_interno(msg, dir_adjuntos))
+                    elif isinstance(payload, email.message.Message):
+                        mensajes.extend(procesar_eml_interno(payload, dir_adjuntos))
+        else:
+            # Si no es multipart, intentar procesar como mensaje único
+            payload = parte.get_payload()
+            if isinstance(payload, list):
+                for msg in payload:
+                    mensajes.extend(procesar_eml_interno(msg, dir_adjuntos))
+            elif isinstance(payload, email.message.Message):
+                mensajes.extend(procesar_eml_interno(payload, dir_adjuntos))
+            
+        return mensajes
+    except Exception as e:
+        print(f"Error procesando email adjunto: {str(e)}")
+        return []
 
 def procesar_eml(ruta_archivo, dir_adjuntos):
-    with open(ruta_archivo, 'rb') as eml:
-        mensaje = BytesParser(policy=policy.default).parse(eml)
+    """
+    Punto de entrada principal para procesar archivos .eml
+    """
+    try:
+        with open(ruta_archivo, 'rb') as eml:
+            mensaje = BytesParser(policy=policy.default).parse(eml)
+        return procesar_eml_interno(mensaje, dir_adjuntos)
+    except Exception as e:
+        print(f"Error al abrir el archivo {ruta_archivo}: {str(e)}")
+        return []
 
-    remitente = mensaje.get('from', '')
-    fecha_str = mensaje.get('date', '')
-    fecha = _parsear_fecha(fecha_str)
+def procesar_eml_interno(mensaje, dir_adjuntos):
+    """
+    Procesa un mensaje de email, ya sea desde archivo o adjunto
+    """
+    mensajes = []
     
-    contenido = ""
-    subject = None
-    adjuntos = []
-    tiene_html = False
-    
-    # Primera pasada: verificar si hay contenido HTML
-    if mensaje.is_multipart():
-        for parte in mensaje.walk():
-            if parte.get_content_type() == "text/html":
-                tiene_html = True
-                break
-    else:
-        tiene_html = mensaje.get_content_type() == "text/html"
-    
-    # Segunda pasada: procesar el contenido
-    if mensaje.is_multipart():
-        for parte in mensaje.walk():
-            if parte.get_content_type() == "text/html":
-                html_content = parte.get_payload(decode=True).decode(parte.get_content_charset() or 'utf-8', errors='ignore')
-                part_subject, text = _html_a_markdown(html_content)
-                if part_subject and not subject:
-                    subject = part_subject
-                contenido = text  # Reemplazar en lugar de concatenar
-            elif parte.get_content_type() == "text/plain" and not tiene_html:
-                # Solo usar texto plano si no hay HTML
-                text = parte.get_payload(decode=True).decode(parte.get_content_charset() or 'utf-8', errors='ignore')
-                contenido = text
-            elif parte.get_content_disposition() == 'attachment':
-                ruta_adjunto = guardar_adjunto(parte, dir_adjuntos)
-                if ruta_adjunto:
-                    adjuntos.append(Path(ruta_adjunto).name)
-    else:
-        if mensaje.get_content_type() == "text/html":
-            html_content = mensaje.get_payload(decode=True).decode(mensaje.get_content_charset() or 'utf-8', errors='ignore')
-            subject, contenido = _html_a_markdown(html_content)
+    try:
+        remitente = mensaje.get('from', '')
+        fecha_str = mensaje.get('date', '')
+        fecha = _parsear_fecha(fecha_str)
+        
+        # Get subject from email headers first
+        subject = mensaje.get('subject', '')
+        if subject:
+            # Try to decode if it's encoded
+            subject = str(email.header.make_header(email.header.decode_header(subject)))
+        
+        contenido = ""
+        adjuntos = []
+        tiene_html = False
+        
+        # First pass: check for HTML content
+        if mensaje.is_multipart():
+            for parte in mensaje.walk():
+                if parte.get_content_type() == "text/html":
+                    tiene_html = True
+                    break
         else:
-            contenido = mensaje.get_payload(decode=True).decode(mensaje.get_content_charset() or 'utf-8', errors='ignore')
+            tiene_html = mensaje.get_content_type() == "text/html"
+        
+        # Second pass: process content and attachments
+        if mensaje.is_multipart():
+            for parte in mensaje.walk():
+                content_type = parte.get_content_type()
+                
+                try:
+                    if content_type == "text/html":
+                        html_content = _get_payload_safely(parte)
+                        if html_content:
+                            part_subject, text = _html_a_markdown(html_content)
+                            if not subject and part_subject:
+                                subject = part_subject
+                            if text:
+                                contenido = text
+                    elif content_type == "text/plain" and not tiene_html:
+                        text = _get_payload_safely(parte)
+                        if text:
+                            contenido = text
+                    elif content_type == "message/rfc822":
+                        # Procesar email adjunto
+                        mensajes_adjuntos = _procesar_email_adjunto(parte, dir_adjuntos)
+                        mensajes.extend(mensajes_adjuntos)
+                    elif parte.get_content_disposition() == 'attachment':
+                        nombre = parte.get_filename()
+                        if nombre and nombre.lower().endswith('.eml'):
+                            # Si es un archivo .eml adjunto
+                            mensajes_adjuntos = _procesar_email_adjunto(parte, dir_adjuntos)
+                            mensajes.extend(mensajes_adjuntos)
+                        else:
+                            # Otros tipos de adjuntos
+                            ruta_adjunto = guardar_adjunto(parte, dir_adjuntos)
+                            if ruta_adjunto:
+                                adjuntos.append(Path(ruta_adjunto).name)
+                except Exception as e:
+                    print(f"Error procesando parte del mensaje: {str(e)}")
+                    continue
+        else:
+            if mensaje.get_content_type() == "text/html":
+                html_content = _get_payload_safely(mensaje)
+                if html_content:
+                    part_subject, contenido = _html_a_markdown(html_content)
+                    if not subject and part_subject:
+                        subject = part_subject
+            else:
+                contenido = _get_payload_safely(mensaje) or ""
+        
+        # Solo agregar el mensaje si tiene contenido útil
+        if contenido or subject or adjuntos:
+            mensajes.append(MensajeEmail(
+                remitente=remitente,
+                fecha=fecha,
+                contenido=contenido,
+                subject=subject,
+                adjuntos=adjuntos
+            ))
+        
+    except Exception as e:
+        print(f"Error procesando mensaje: {str(e)}")
     
-    return [MensajeEmail(remitente=remitente, fecha=fecha, contenido=contenido, subject=subject, adjuntos=adjuntos)]
+    return mensajes
 
 def _parsear_fecha(fecha_str):
     try: