"""
log module-based on loguru
"""
import sys
from pathlib import Path
from loguru import logger
from src.config.settings import settings


class Logger:
    """logger cls"""

    def __init__(self):
        """init config"""
        self._context_name = None
        self._setup_logger()

    def _setup_logger(self):
        """setup logger"""
        # remove logger
        logger.remove()

        # make sure file path exist
        log_dir = Path(settings.LOG_FILE_PATH).parent
        log_dir.mkdir(exist_ok=True)

        # add stdout handler
        logger.add(
            sys.stdout,
            format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | "
                   "<level>{level: <8}</level> | "
                   "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - "
                   "<level>{message}</level>",
            level=settings.LOG_LEVEL,
            colorize=True
        )

        # add file handler
        logger.add(
            settings.LOG_FILE_PATH,
            format="{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {name}:{function}:{line} - {message}",
            level=settings.LOG_LEVEL,
            rotation=settings.LOG_ROTATION,
            retention=settings.LOG_RETENTION,
            compression="zip",
            encoding="utf-8"
        )

    def get_logger(self, name: str = None):
        """get logger self"""
        if name:
            # set context name
            self._context_name = name
            return self
        return self

    def __getattr__(self, name):
        """get loguru logger"""
        if self._context_name:
            bound_logger = logger.bind(name=self._context_name)
        else:
            bound_logger = logger

        return getattr(bound_logger, name)

    def log_conversation_start(self, attack_model: str, victim_model: str, topic: str, max_rounds: int):
        """start conversation log"""
        logger.info(
            f"Conversation start： - Attack model: {attack_model}, Victim model: {victim_model}, topic: {topic},max rounds: {max_rounds}")

    def log_model_response(self, model_type: str, model_name: str, round_num: int, response_length: int):
        """model response log """
        logger.info(
            f"Model response - model type: {model_type}, model name: {model_name}, dialogue round: {round_num}, response length: {response_length}")

    def log_conversation_end(self, total_rounds: int, total_tokens: int = None):
        """the end of conversation log """
        logger.info(f"The end of conversation - total rounds: {total_rounds}, costed tokens: {total_tokens or 'unknown'}")

    def log_error(self, error: Exception, context: str = ""):
        """error log"""
        logger.error(f"Error - context: {context}, error info: {str(error)}", exc_info=True)


# instance logger
app_logger = Logger()