#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from os.path import dirname as directory_name, abspath as path_absolute

ROOT_PATH:str = directory_name(path_absolute(__file__))

from typing import Self, Any, Optional
from datetime import datetime
from re import Match as REMatch
from Drivers.FilesDriver import FilesDriver
from Managers.SettingsManager import SettingsManager
from Managers.I18NManager import I18NManager
from Managers.TerminalManager import TerminalManager
from Managers.ModelsManager import ModelsManager
from Managers.DatabasesManager import DatabasesManager
from Managers.ControllersManager import ControllersManager
from Managers.ProceduresManager import ProceduresManager
from Controllers.LogsController import LogsController
from Utils.Utils import Utils
from Utils.Patterns import RE

class CXCV:

    def __init__(self:Self, 
        inputs:Optional[dict[str, Any|None]|list[Any|None]|tuple[Any|None, ...]] = None
    ) -> None:
        
        project_root_path:str = ROOT_PATH[:ROOT_PATH.index("/CXCV") + 6]
        
        self.__print_format:str = "[{yyyy}-{mm}-{dd} {hh}:{ii}:{ss}] [{type}] {message}"
        self.__exception_format:str = "\nException in '{file}({method})[{line}]'{lines}\n\n{exception_message}"
        self.working:bool = True

        self.files:FilesDriver = FilesDriver(self, ROOT_PATH)
        self.settings:SettingsManager = SettingsManager(self, inputs)

        self.__print_format = self.settings.get("print_format", None, self.__print_format)
        self.__exception_format = self.settings.get("exception_format", None, self.__exception_format)
        
        self.i18n:I18NManager = I18NManager(self)
        self.terminal:TerminalManager = TerminalManager(self)
        self.models:ModelsManager = ModelsManager(self)
        self.databases:DatabasesManager = DatabasesManager(self)
        self.controllers:ControllersManager = ControllersManager(self)
        self.procedures:ProceduresManager = ProceduresManager(self)

        self.terminal.start()

    def close(self:Self) -> None:
        self.working = False

    def print(self:Self, 
        _type:str, 
        string:str, 
        inputs:Optional[dict[str, Any|None]|list[Any|None]|tuple[Any|None, ...]] = None, 
        i:int = 0
    ) -> None:

        date:datetime = datetime.now()
        own:dict[str, Any|None] = {
            "raw_type" : _type,
            "type" : _type.upper()[:4],
            "i18n" : Utils.get_strings(string)[0],
            "message" : self.i18n.get(string, inputs),
            **Utils.get_action_data(i + 1),
            **Utils.get_dictionary(inputs)
        }

        try:
            own["file"] = own["file"][str(own["file"]).index("/CXCV/"):]
        except Exception as exception:
            pass

        while len(own["type"]) < 4:
            own["type"] = " " + own["type"] if len(own["type"]) % 2 else own["type"] + " "

        for key in ("year", "month", "day", "hour", "minute", "second"):

            k:str = key[0] if key != "minute" else "i"

            own[k] = own[key] = getattr(date, key)
            own[k + k] = ("00" + str(own[key] % 100))[-2:]

        own["yyyy"] = ("0000" + str(own["year"]))[-4:]

        if "end" in own:
            own["message"] += own["end"]

        print(Utils.string_variables(self.__print_format, own))

        if not self.controllers:
            return
            
        controller:LogsController|None = self.controllers.get(
            LogsController, "logs"
        )

        controller and own["type"] != "EXCE" and controller.set_log(own["i18n"], (
            1 if own["type"] == "EXCE" else 
            2 if own["type"] == "WARN" else 
            3 if own["type"] == "ERRO" else 
        0), inputs or {}, i)
        
    def exception(self, 
        exception:Exception, 
        message:Optional[str|list|tuple] = None, 
        inputs:Optional[dict[str, Any]|list|tuple] = None, 
        i:Optional[int] = 0
    ) -> None:

        lines:list[str]|None = Utils.get_trace(exception)
        line_matches:REMatch[str]|None = RE.EXCEPTION.match(lines[-1])
        data:dict[str, Any|None] = {
            **{key : value for subset in (inputs if isinstance(inputs, (list, tuple)) else (inputs,)) for key, value in (subset if isinstance(subset, dict) else {}).items()}, 
            **Utils.get_action_data(1),
            "lines" : "".join("\n    " + RE.BREAK_LINES.split(line.strip())[0] for line in lines), 
            "exception_message" : str(exception), 
            "method" : line_matches.group(3), 
            "line" : line_matches.group(2), 
            "file" : line_matches.group(1)
        }

        data["end"] = Utils.string_variables(self.__exception_format, data)
                
        if message:

            self.print("exception", message, data, None, i + 1)

            if not self.controllers:
                return

            controller:LogsController|None = self.controllers.get(
                LogsController, "logs"
            )

            controller and controller.set_exception(exception, message, inputs or {}, None, i)