import os
import asyncio
import fnmatch
from typing import Awaitable, Callable

from app.services.parser.excel.isbank.parser import parse_isbank_mail
from app.services.types.mail import MailParsedResult, PlainMailReader, ProcessMailObject
from app.services.common.service_base_async import ServiceBaseAsync
from app.services.types.queue import Enqueue
from app.services.types.task import Job


PRODUCE_BURST = int(os.getenv("PRODUCE_BURST", "10"))
PRODUCE_ONCE  = os.getenv("PRODUCE_ONCE", "true").lower() == "true"
EVENT_TYPE    = os.getenv("EVENT_TYPE", "db-mongo")

PROCESS_SEC = 10


bank_mail_dict = {
    "ileti.isbank.com.tr": parse_isbank_mail
}


def grab_fn_callable(domain: str) -> Callable[[ServiceBaseAsync, dict], Awaitable[None]]:
    for pat, fn in bank_mail_dict.items():
        if fnmatch.fnmatch(domain, pat):
            return fn
    return None


async def produce(svc: ServiceBaseAsync):
    await asyncio.sleep(PROCESS_SEC)


async def handle_from_parser(svc: ServiceBaseAsync, job: dict):
    job_model = Job(**job)
    await svc.ack_current()
    await asyncio.sleep(PROCESS_SEC)


async def handle_from_mail_parser(svc: ServiceBaseAsync, job: dict):
    job_model = Job(**job)
    process_mail_object = ProcessMailObject(**job_model.payload)
    mail_id = process_mail_object.data.id
    task_id = f"IsBankServiceExcelParser_{mail_id}"
    await asyncio.sleep(PROCESS_SEC)
    function_handler = grab_fn_callable(process_mail_object.data.from_.domain)
    if not function_handler:
        await svc.dlq_current(job, error="Invalid domain")
        return
    parsed_data = function_handler(process_mail_object)
    if not parsed_data:
        plain_mail_data = PlainMailReader(**process_mail_object.data.model_dump())
        parsed_result = MailParsedResult(task_id=task_id, mail_data=plain_mail_data.model_dump(), send_to="Completed", data=parsed_data)
        print("Parser Excel Consumer from mail              handle_from_mail        :", parsed_result)
        enqueue = Enqueue(task_id=task_id, payload=parsed_result.model_dump(), action="mail.service.publish")
        await svc.enqueue(enqueue)
        await svc.ack_current()
    else:
        plain_mail_data = PlainMailReader(**process_mail_object.data.model_dump())
        parsed_result = MailParsedResult(task_id=task_id, mail_data=plain_mail_data.model_dump(), send_to="Completed", data=parsed_data)
        enqueue = Enqueue(task_id=task_id, payload=parsed_result.model_dump(), action="parser.comment.publish")
        await svc.enqueue(enqueue)
        await svc.ack_current()
    print("Parser Excel Consumer from mail              handle_from_mail        :", task_id)


async def consume_default(svc: ServiceBaseAsync, job: dict):

    job_model = Job(**job)
    await svc.ack_current()
    await asyncio.sleep(PROCESS_SEC)


if __name__ == "__main__":

    svc = ServiceBaseAsync(produce_fn=produce, consume_fn=consume_default, handlers={"parser.mail.publish": handle_from_mail_parser})
    asyncio.run(svc.run())