"""Lambda payment_allocation 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

from config import config
from src.connectors.mysql import MySQLConnectionFactory
from src.connectors.repository import Repository
from src.errors import PermanentError, TransientError
from src.processor import PaymentAllocationProcessor
from src.schemas import parse_event

if config.sentry_dsn:
    sentry_sdk.init(
        dsn=config.sentry_dsn,
        environment=config.env,
        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 allocations_created and ledger_adjustments_linked.

    Raises:
        TransientError: Retriable errors (e.g., DB connection).
        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}')
        sppe_id = parse_event(dict(event or {}))
        logger.info(f'Statement period payment entity ID: {sppe_id}')

        # Process the event with database connection
        logger.info('Establishing connections')
        factory = MySQLConnectionFactory(config.mysql)
        with factory.connection() as mysql_conn:
            try:
                repository = Repository(mysql_conn)

                logger.info('Processing')
                start_time = datetime.now()
                processor = PaymentAllocationProcessor(repository)
                result = processor.process(sppe_id)
                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, 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