"""Lambda adjustment_file_initialize function module."""

from __future__ import annotations

from datetime import datetime
from typing import Any, Mapping

import sentry_sdk
from lambdacommon.common_config import logger
from pydantic import ValidationError
from sentry_sdk.integrations.aws_lambda import AwsLambdaIntegration

import config
from src.connectors.db import mysql_connection
from src.connectors.repository import Repository
from src.errors import PermanentError, TransientError
from src.processor import AdjustmentFileInitializeProcessor
from src.schemas import AdjustmentFileInitializeEvent

if config.SENTRY_DSN:
    sentry_sdk.init(
        dsn=config.SENTRY_DSN,
        environment=config.ENVIRONMENT,
        integrations=[AwsLambdaIntegration(timeout_warning=True)],
    )


def handler(event: Mapping[str, Any] | None, context: Any) -> dict[str, Any]:
    """Lambda entry point.

    Args:
        event: Event data passed to the Lambda function.
        context: Lambda runtime information.

    Returns:
        dict: Response with batch_id, correlation_id, s3_bucket, and s3_key.

    Raises:
        TransientError: Retriable errors (e.g., DB connection, S3 throttling).
        PermanentError: Non-retriable errors (e.g., validation, logic errors).
        ValidationError: If event structure is invalid.
        Exception: For unexpected critical failures.
    """
    try:
        logger.info(f'Function ARN: {context.invoked_function_arn}')
        validated_event = AdjustmentFileInitializeEvent(**(event or {}))
        file_upload_id = validated_event.detail.metadata.target_id
        correlation_id = validated_event.detail.metadata.correlation_id
        logger.info(f'Correlation ID: {correlation_id}')
        logger.info(f'File upload ID: {file_upload_id}')

        # Process the event with database connection
        logger.info('Establishing connections')
        with mysql_connection(**config.MYSQL_CONFIG) as mysql_conn:
            try:
                repository = Repository(mysql_conn)

                logger.info('Processing')
                start_time = datetime.now()
                processor = AdjustmentFileInitializeProcessor(repository)
                result = processor.process(validated_event)
                mysql_conn.commit()
                end_time = datetime.now()

                # Log processing time
                diff = end_time - start_time
                logger.info(f'Finished processing in {diff}')

                # Return result
                return result.model_dump()
            except Exception:
                mysql_conn.rollback()
                raise

    except ValidationError as e:
        # Invalid event structure is a permanent error
        logger.error(f'Invalid event structure: {e}')
        raise PermanentError(str(e)) from e

    except TransientError as e:
        # Retriable errors (DB connection, IntegrityError, etc)
        logger.warning(f'Transient error encountered: {e}')
        raise TransientError(str(e)) from e

    except PermanentError as e:
        # Non-retriable errors (validation failures, not found, etc)
        logger.error(f'Permanent error encountered: {e}')
        raise PermanentError(str(e)) from e

    except Exception as e:
        # Unexpected errors
        logger.exception(f'Unexpected error encountered: {e}')
        raise