from loguru import logger as guru_logger
from common.config.log_settings import log_settings
from typing import List
import socket
import json
import logging
import threading


class LoggerBase:
    binded_loggers = {}
    logger_lock = threading.Lock()

    def __init__(
        self, logger_name: str, extra_fileds: dict[str, any]
    ) -> None:
        self.__logger_name = logger_name
        self.extra_fileds = extra_fileds
        with LoggerBase.logger_lock:
            if self.__logger_name in LoggerBase.binded_loggers:
                self.logger = LoggerBase.binded_loggers[self.__logger_name]
                return

        log_filename = (
            log_settings.LOG_BASE_PATH + "/" + self.__logger_name + ".log"
        )
        log_retention = log_settings.LOG_RETENTION
        log_rotation = log_settings.LOG_ROTATION
        log_level = "INFO"
        log_message_format = "{message}"

        guru_logger.add(
            sink=log_filename,
            level=log_level,
            retention=log_retention,
            rotation=log_rotation,
            format=log_message_format,
            serialize=True,
            filter=lambda record: "extra" in record
            and "topic" in record["extra"]
            and record["extra"]["topic"] == self.__logger_name,
        )
        host_name = socket.gethostname()
        host_ip = socket.gethostbyname(host_name)
        self.logger = guru_logger.bind(
            topic=self.__logger_name,
            host_ip=host_ip,
            host_name=host_name,
        )
        with LoggerBase.logger_lock:
            LoggerBase.binded_loggers[self.__logger_name] = self.logger

    async def log_event(
        self,
        sender_id: str,
        receiver_id: str,
        subject: str,
        event: str,
        properties: dict[str, any],
        text: str = ""
    ) -> None:
        local_logger = self.logger.bind(
            sender_id=sender_id,
            receiver_id=receiver_id,
            subject=subject,
            event=event,
            properties=properties
        )
        local_logger.info(text)

    async def log_exception(
        self,
        sender_id: str,
        receiver_id: str,
        subject: str,
        exception: Exception,
        text: str = "",
        properties: dict[str, any] = None,
    ) -> None:
        local_logger = self.logger.bind(
            sender_id=sender_id,
            receiver_id=receiver_id,
            subject=subject,
            event="exception",
            properties=properties,
            exception=exception
        )
        local_logger.exception(text)

    async def log_info(
        self,
        sender_id: str,
        receiver_id: str,
        subject: str,
        text: str = "",
        properties: dict[str, any] = None,
    ) -> None:
        local_logger = self.logger.bind(
            sender_id=sender_id,
            receiver_id=receiver_id,
            subject=subject,
            event="information",
            properties=properties,
        )
        local_logger.info(text)
        
    async def log_warning(
        self,
        sender_id: str,
        receiver_id: str,
        subject: str,
        text: str = "",
        properties: dict[str, any] = None,
    ) -> None:
        local_logger = self.logger.bind(
            sender_id=sender_id,
            receiver_id=receiver_id,
            subject=subject,
            event="warning",
            properties=properties,
        )
        local_logger.warning(text)
        
    async def log_error(
        self,
        sender_id: str,
        receiver_id: str,
        subject: str,
        text: str = "",
        properties: dict[str, any] = None,
    ) -> None:
        local_logger = self.logger.bind(
            sender_id=sender_id,
            receiver_id=receiver_id,
            subject=subject,
            event="error",
            properties=properties,
        )
        local_logger.error(text)