#!/bin/sh

mail_uid=${1:-"1"}
mail_path=${2:-/tmp/111/777.eml}
out_dir=${3:-/tmp/uid777}






if [ -f ${mail_path} ] ;then
echo "parse_mail: ${mail_path} существует OK"
else
echo "parse_mail: не нашел ${mail_path}"
exit 1
fi

if [ -d ${out_dir} ] ;then
echo "parse_mail: ${out_dir} существует OK"
else
mkdir -p ${out_dir}
fi



export IMAP_UID="${mail_uid}"
export MAIL_PATH="${mail_path}"
export OUT_DIR="${out_dir}"

echo "parse_mail: ${mail_uid} ${mail_path} ${out_dir}"


command='
import os
import sys
import json
import email
from email.header import decode_header
from email.utils import parsedate_to_datetime

mail_uid = os.environ.get("IMAP_UID")
mail_path = os.environ.get("MAIL_PATH")
out_dir = os.environ.get("OUT_DIR")

def decode_mime_header(header_value):
    if not header_value:
        return ""
    decoded_parts = decode_header(header_value)
    result = []
    for text, charset in decoded_parts:
        if isinstance(text, bytes):
            if charset:
                result.append(text.decode(charset, errors="ignore"))
            else:
                result.append(text.decode("utf-8", errors="ignore"))
        else:
            result.append(str(text))
    return "".join(result)
	
	
	
try:
   
    with open(mail_path, "rb") as f:
        msg = email.message_from_bytes(f.read())

    mail_subject = decode_mime_header(msg.get("Subject"))
    mail_from = decode_mime_header(msg.get("From"))
    mail_date = msg.get("Date", "")


    t_date = msg.get("Date", "")
    mail_date = ""
    if t_date:
        try:
            dt = email.utils.parsedate_to_datetime(t_date)        
            mail_date = dt.strftime("%d.%m.%Y %H:%M:%S")
        except Exception:
            mail_date = t_date 


    received_headers = msg.get_all("Received")
    mail_recv = ""
    
    if received_headers:
        try:
            # Берем самую верхнюю строчку Received (последний узел доставки)
            top_received = received_headers[0]
            # Дата в Received всегда идет после точки с запятой ";"
            if ";" in top_received:
                raw_received_date = top_received.split(";")[-1].strip()
                dt = email.utils.parsedate_to_datetime(raw_received_date)
                mail_recv = dt.strftime("%d.%m.%Y %H:%M:%S")
        except Exception:
            mail_recv=""
      


    attachments_names = []
    attachments_paths = []
    mail_body=""
    mail_body_html=""
    body_html_file_path=""
    #body_extension = "txt"
    all_plain_parts = []
    all_html_parts = []

    for part in msg.walk():
        content_type = part.get_content_type()
        content_disposition = part.get("Content-Disposition")

        if content_type == "text/plain" and content_disposition is None:
            charset = part.get_content_charset() or "utf-8"
            try:
                text_chunk = part.get_payload(decode=True).decode(charset, errors="ignore")
                all_plain_parts.append(text_chunk)
            except Exception:
                pass
        elif content_type == "text/html" and content_disposition is None:
            charset = part.get_content_charset() or "utf-8"
            try:
                html_chunk = part.get_payload(decode=True).decode(charset, errors="ignore")
                all_html_parts.append(html_chunk)
            except Exception:
                pass
				


        if part.get_content_maintype() == "multipart":
            continue
        if part.get("Content-Disposition") is None:
            continue
            
        filename = part.get_filename()

        if filename:
          filename = decode_mime_header(filename)
          safe_filename = os.path.basename(filename)
          attachments_names.append(safe_filename)

          blob_path = os.path.join(out_dir, safe_filename)
          attachments_paths.append(blob_path)
          with open(blob_path, "wb") as bf:
            bf.write(part.get_payload(decode=True))

    


    if all_html_parts:
        # HTML-блоки, склеиваем их и сохраняем как html
        mail_body_html = "".join(all_html_parts)
        body_filename_html = "mail_body_html_{}.{}".format(mail_uid,"html")
        body_html_file_path = os.path.join(out_dir, body_filename_html)    
        with open(body_html_file_path, "w", encoding="utf-8") as body_html_file:
           body_html_file.write(mail_body_html.strip())

    if all_plain_parts:
        # Plain-блоки, склеиваем их 
        mail_body = "".join(all_plain_parts)
        #body_extension = "txt"
    else:
        # если в письме вообще нет текста
        mail_body = ""
        #body_extension = "txt"
	
    #body_filename = "mail_body_{}.{}".format(mail_uid,body_extension)
    #body_file_path = os.path.join(out_dir, body_filename)
    
    #with open(body_file_path, "w", encoding="utf-8") as body_file:
    #    body_file.write(mail_body_html.strip())
		
    passport = {
       "mail_uid": "{}".format(mail_uid),     
       "subject": mail_subject,
       "from": mail_from,
       "d_send": mail_date,
       "d_recv": mail_recv,
       "files": attachments_paths,
       "body_html": body_html_file_path,
       "body": mail_body
    }



    with open(os.path.join(out_dir, "mail_passport.json"), "w") as pf:
     json.dump(passport,pf,ensure_ascii=False,indent=5)

    print("parse_mail: Письмо успешно распарсено.")
    sys.exit(0)

except Exception as e:
    print("parse_mail: Ошибка при парсинге EML файла:", e, file=sys.stderr)
    sys.exit(1)




'

response=$(python3 -c "${command}")
r=$?

if [ $r -ne 0 ]; then
    echo "parse_mail: Ошибка парсинга uid= ${mail_path} ${response}"
    exit $r
fi


    echo "parse_mail: OK"