"""Testing log formatter for datadog."""
import datetime
import logging
import sys
from typing import Any

from pythonjsonlogger.json import JsonFormatter


def setup(environment, service_name, service_version,
          clear_handlers=True):
    """Logger."""
    current_logger = logging.getLogger('garcon')
    # Clear the list of handlers to override ddtrace-run behavior
    if clear_handlers:
        current_logger.handlers.clear()
    configure_handler(
        current_logger, environment, service_name, service_version
    )

    return current_logger


def configure_handler(
        logger: logging.Logger,
        environment: str,
        service_name: str,
        service_version: str,
) -> None:
    """Configure the logger based on a provided DSN.

    Args:
        logger: the logger instance.
        environment: the application's environment.
        service_name: the service name.
        service_version: the service version.

    """
    handler = logging.StreamHandler(sys.stdout)
    formatter = DDJsonFormatter(service_name, environment, service_version)
    handler.setFormatter(formatter)
    logger.addHandler(handler)


class DDJsonFormatter(JsonFormatter):
    """Manage fields for logging trace."""

    def __init__(
            self,
            service_name: str,
            env: str,
            service_version: str,
            *args: Any,
            **kwargs: Any,
    ) -> None:
        """Init."""
        super().__init__(*args, **kwargs)
        self.service_name = 'swf-' + service_name
        self.env = env
        self.service_version = service_version

    def add_fields(
            self,
            log_record: dict[str, Any],
            record: logging.LogRecord,
            message_dict: dict[str, Any],
    ) -> None:
        """Update a logging record with standard fields."""
        super().add_fields(log_record, record, message_dict)

        # Calculate the timestamp.
        utc_date = datetime.datetime.fromtimestamp(
            record.created, tz=datetime.timezone.utc
        )

        # datadog reserved names https://docs.datadoghq.com/logs/log_configuration/attributes_naming_convention/   # noqa
        log_record['timestamp'] = utc_date.isoformat()
        log_record['level'] = record.levelname
        log_record['service'] = self.service_name
        log_record['environment'] = self.env

        # log metadata
        logging_context = {
            'logger': {
                'name': record.name,
                'pathname': record.pathname,
                'file_name': record.filename,
                'method_name': record.funcName,
                'lineno': record.lineno,
            }
        }

        log_record.update(logging_context)