from enum import Enum
from http import HTTPStatus
from typing import Any
from urllib.parse import parse_qsl

from aws_lambda_powertools import Logger, Tracer
from aws_lambda_powertools.event_handler.api_gateway import (
    APIGatewayHttpResolver,
    Response,
)
from aws_lambda_powertools.event_handler.exceptions import NotFoundError
from aws_lambda_powertools.logging import correlation_paths
from aws_lambda_powertools.utilities.typing import LambdaContext
from layercake.dateutils import now
from layercake.dynamodb import DynamoDBPersistenceLayer, KeyPair

from boto3clients import dynamodb_client
from config import ORDER_TABLE

logger = Logger(__name__)
tracer = Tracer()
app = APIGatewayHttpResolver(enable_validation=True)
dyn = DynamoDBPersistenceLayer(ORDER_TABLE, dynamodb_client)


class OrderNotFoundError(NotFoundError): ...


class InvoiceNotFoundError(NotFoundError): ...


class StatusAttr(Enum):
    PAID = 'paid_at'
    CANCELED = 'canceled_at'
    REFUNDED = 'refunded_at'
    EXPIRED = 'expired_at'
    EXTERNALLY_PAID = 'paid_at'


def _status_attr(status: str) -> StatusAttr | None:
    try:
        return StatusAttr[status]
    except KeyError:
        return None


@app.post('/<order_id>/postback')
@tracer.capture_method
def postback(order_id: str):
    decoded_body = dict(parse_qsl(app.current_event.decoded_body))
    logger.info('IUGU Postback', decoded_body=decoded_body)

    now_ = now()
    event = decoded_body['event']
    status = decoded_body.get('data[status]', '').upper()
    status_attr = _status_attr(status)

    if event != 'invoice.status_changed' or not status_attr:
        return Response(status_code=HTTPStatus.NO_CONTENT)

    with dyn.transact_writer() as transact:
        transact.update(
            key=KeyPair(order_id, '0'),
            update_expr='SET #status = :status, \
                             #status_attr = :now, \
                             updated_at = :now',
            cond_expr='attribute_exists(sk)',
            expr_attr_names={
                '#status': 'status',
                '#status_attr': status_attr.value,
            },
            expr_attr_values={
                ':status': status,
                ':now': now_,
            },
            exc_cls=OrderNotFoundError,
        )

        if status == 'EXTERNALLY_PAID':
            transact.update(
                key=KeyPair(order_id, 'INVOICE'),
                cond_expr='attribute_exists(sk)',
                update_expr='SET externally_paid = :true, \
                                 updated_at = :now',
                expr_attr_values={
                    ':true': True,
                    ':now': now_,
                },
                exc_cls=InvoiceNotFoundError,
            )

    return Response(status_code=HTTPStatus.NO_CONTENT)


@logger.inject_lambda_context(correlation_id_path=correlation_paths.API_GATEWAY_HTTP)
@tracer.capture_lambda_handler
def lambda_handler(
    event: dict[str, Any],
    context: LambdaContext,
) -> dict[str, Any]:
    return app.resolve(event, context)