import asyncio
from decimal import Decimal
from urllib.parse import parse_qs
import orjson
from fastapi import APIRouter,Depends,Query,Request,WebSocket,WebSocketDisconnect
from fastapi.responses import ORJSONResponse
from fastapi.security.utils import get_authorization_scheme_param
from ulid import ULID
from src.application.commands import CreateOrderCommand,CreatePaymentCommand,GetOrderCommand,GetOrderStatusCommand,GetPaymentConfigCommand,GetPaymentQuoteCommand,ListOrdersCommand,ListPaymentsCommand
from src.application.contracts import IJwtService,ILogger
from src.application.domain.dto import AccessTokenPayload,AuthContext
from src.application.domain.entities import OrderEntity,PaymentEntity
from src.application.domain.enums import OrderStatus
from src.application.domain.exceptions import ApplicationException,ConflictException
from src.application.services import PaymentQuote
from src.infrastructure.context_vars import trace_id_var
from src.presentation.decorators import require_access_token, csrf_protect
from src.presentation.dependencies.commands import get_create_order_command,get_create_payment_command,get_list_orders_command,get_list_payments_command,get_order_command,get_order_status_command,get_payment_config_command,get_payment_quote_command
from src.presentation.dependencies.logger import get_logger
from src.presentation.dependencies.security import get_jwt_service
from src.presentation.schemas.order import CreateOrder,CreateOrderResponse,ErrorResponse,OrderDetailResponse,OrderPaymentResponse,OrdersResponse,OrderStatusResponse,OrderWithPaymentResponse,PaymentConfigResponse,PaymentQuoteResponse,PaymentResponse,PaymentsResponse
from src.presentation.schemas.itpay_payment_models import ItpayPaymentData

order_router = APIRouter(prefix='/order', tags=['orders'])
orders_router = APIRouter(tags=['orders'])
payment_router = APIRouter(prefix='/payment', tags=['payments'])
payments_router = APIRouter(tags=['payments'])

ERROR_RESPONSES = {
    400: {'model': ErrorResponse, 'description': 'Bad Request'},
    401: {'model': ErrorResponse, 'description': 'Unauthorized'},
    403: {'model': ErrorResponse, 'description': 'Forbidden'},
    404: {'model': ErrorResponse, 'description': 'Not Found'},
    409: {'model': ErrorResponse, 'description': 'Conflict'},
    422: {'model': ErrorResponse, 'description': 'Validation Error'},
    429: {'model': ErrorResponse, 'description': 'Too Many Requests'},
    500: {'model': ErrorResponse, 'description': 'Internal Server Error'},
    502: {'model': ErrorResponse, 'description': 'Bad Gateway'},
    503: {'model': ErrorResponse, 'description': 'Service Unavailable'},
}


def _payment_config_response(quote: PaymentQuote) -> PaymentConfigResponse:
    return PaymentConfigResponse(
        status_code=200,
        usdt_exchange_rate=str(quote.usdt_exchange_rate),
        gas_fee=str(quote.gas_fee),
        service_fee_rate=str(quote.service_fee_rate),
        one_usdt_service_fee=str(quote.service_fee),
        one_usdt_total_price=str(quote.total_price),
        created_at=quote.created_at.isoformat(),
    )


def _payment_quote_response(quote: PaymentQuote) -> PaymentQuoteResponse:
    return PaymentQuoteResponse(
        status_code=200,
        usdt_amount=str(quote.usdt_amount),
        usdt_exchange_rate=str(quote.usdt_exchange_rate),
        gas_fee=str(quote.gas_fee),
        service_fee=str(quote.service_fee),
        total_price=str(quote.total_price),
        service_fee_rate=str(quote.service_fee_rate),
        created_at=quote.created_at.isoformat(),
    )


def _order_response(o: OrderEntity) -> OrderPaymentResponse:
    return OrderPaymentResponse(
        id=o.id,
        created_at=o.created_at.isoformat() if o.created_at is not None else None,
        updated_at=o.updated_at.isoformat() if o.updated_at is not None else None,
        user_id=o.user_id,
        usdt_amount=str(o.usdt_amount) if o.usdt_amount is not None else None,
        usdt_exchange_rate=str(o.usdt_exchange_rate) if o.usdt_exchange_rate is not None else None,
        gas_fee=str(o.gas_fee) if o.gas_fee is not None else None,
        total_price=str(o.total_price) if o.total_price is not None else None,
        service_fee=str(o.service_fee) if o.service_fee is not None else None,
        status=o.status,
        client_payment_id=o.client_payment_id,
        itpay_payment_qr_url_desktop=o.itpay_payment_qr_url_desktop,
        itpay_payment_qr_url_android=o.itpay_payment_qr_url_android,
        itpay_payment_qr_url_ios=o.itpay_payment_qr_url_ios,
        itpay_payment_qr_image_desktop=o.itpay_payment_qr_image_desktop,
        itpay_payment_qr_image_android=o.itpay_payment_qr_image_android,
        itpay_payment_qr_image_ios=o.itpay_payment_qr_image_ios,
        itpay_id=o.itpay_id,
        itpay_qr_id=o.itpay_qr_id,
        itpay_amount=str(o.itpay_amount) if o.itpay_amount is not None else None,
        itpay_created_at=o.itpay_created_at.isoformat() if o.itpay_created_at is not None else None,
    )


def _payment_response(payment: PaymentEntity) -> PaymentResponse:
    return PaymentResponse(
        id=payment.id,
        created_at=payment.created_at.isoformat() if payment.created_at is not None else None,
        updated_at=payment.updated_at.isoformat() if payment.updated_at is not None else None,
        user_id=payment.user_id,
        order_id=payment.order_id,
        status=payment.status,
        receipt_cloudekassir_id=payment.receipt_cloudekassir_id,
        receipt_cloudekassir_link=payment.receipt_cloudekassir_link,
        itpay_payment_id=payment.itpay_payment_id,
        itpay_paid_amount=str(payment.itpay_paid_amount) if payment.itpay_paid_amount is not None else None,
        transaction_id=payment.transaction_id,
        web3_transaction_hash=payment.web3_transaction_hash,
        paid_at=payment.paid_at.isoformat() if payment.paid_at is not None else None,
        expired_date=payment.expired_date.isoformat() if payment.expired_date is not None else None,
    )


def _order_detail_response(order: OrderEntity, payment: PaymentEntity | None) -> OrderDetailResponse:
    return OrderDetailResponse(
        status_code=200,
        order=_order_response(order),
        payment=_payment_response(payment) if payment is not None else None,
    )


def _order_with_payment_response(order: OrderEntity, payment: PaymentEntity | None) -> OrderWithPaymentResponse:
    return OrderWithPaymentResponse(
        order=_order_response(order),
        payment=_payment_response(payment) if payment is not None else None,
    )


def _order_status_response(order: OrderEntity, payment: PaymentEntity | None) -> OrderStatusResponse:
    return OrderStatusResponse(
        status_code=200,
        order_id=str(order.id),
        order_status=order.status,
        payment_status=payment.status if payment is not None else None,
        receipt_cloudekassir_link=payment.receipt_cloudekassir_link if payment is not None else None,
        web3_transaction_hash=payment.web3_transaction_hash if payment is not None else None,
        updated_at=payment.updated_at.isoformat() if payment is not None and payment.updated_at is not None else order.updated_at.isoformat() if order.updated_at is not None else None,
    )


def _extract_websocket_access_token(websocket: WebSocket) -> str | None:
    token = websocket.cookies.get('access_token')
    if token:
        return token
    auth = websocket.headers.get('Authorization')
    if auth:
        scheme,param = get_authorization_scheme_param(auth)
        if scheme.lower() == 'bearer' and param:
            return param
    query_token = websocket.query_params.get('access_token') or websocket.query_params.get('token')
    if query_token:
        return str(query_token)
    return None


async def _websocket_auth_context(websocket: WebSocket, jwt_service: IJwtService) -> AuthContext | None:
    token = _extract_websocket_access_token(websocket)
    if not token:
        return None
    try:
        payload: AccessTokenPayload = await jwt_service.decode_access_token(token)
    except ApplicationException:
        return None
    if payload.type != 'access':
        return None
    return AuthContext(user_id=payload.sub, sid=payload.sid, token=payload)


@order_router.post(
        '/create',
        response_model=CreateOrderResponse,
        status_code=201,
        responses=ERROR_RESPONSES,
)
@csrf_protect()
async def create_order(
        request: Request,
        payment_data: CreateOrder,
        auth: AuthContext = Depends(require_access_token),
        command: CreateOrderCommand = Depends(get_create_order_command),
        logger: ILogger = Depends(get_logger),
) -> CreateOrderResponse:
    o = await command(payment_data, auth.user_id)

    itpay_error = o.status in (
        OrderStatus.CANCELLED,
        OrderStatus.REJECTED,
        OrderStatus.ERROR,
    )
    log_ids = {
        'event': 'order_create_itpay_failed' if itpay_error else 'order_created',
        'order_id': o.id,
        'user_id': o.user_id,
        'client_payment_id': o.client_payment_id,
        'itpay_id': o.itpay_id,
        'order_status': o.status.value if o.status is not None else None,
    }
    logger.info(log_ids)
    if itpay_error:
        raise ConflictException(message='Payment provider rejected order')
    content = CreateOrderResponse(
        status_code=201,
        order=_order_response(o),
    )
    return content


@payment_router.get(
        '/config',
        response_model=PaymentConfigResponse,
        status_code=200,
        responses=ERROR_RESPONSES,
)
async def payment_config(
        command: GetPaymentConfigCommand = Depends(get_payment_config_command),
) -> PaymentConfigResponse:
    quote = await command()
    return _payment_config_response(quote)


@payment_router.get(
        '/quote',
        response_model=PaymentQuoteResponse,
        status_code=200,
        responses=ERROR_RESPONSES,
)
async def payment_quote(
        usdt_amount: Decimal = Query(gt=0, decimal_places=2, max_digits=20),
        command: GetPaymentQuoteCommand = Depends(get_payment_quote_command),
) -> PaymentQuoteResponse:
    quote = await command(usdt_amount)
    return _payment_quote_response(quote)


@orders_router.get(
        '/orders',
        response_model=OrdersResponse,
        status_code=200,
        responses=ERROR_RESPONSES,
)
@csrf_protect()
async def list_orders(
        limit: int = Query(default=20, ge=1, le=100),
        offset: int = Query(default=0, ge=0),
        auth: AuthContext = Depends(require_access_token),
        command: ListOrdersCommand = Depends(get_list_orders_command),
) -> OrdersResponse:
    orders = await command(user_id=auth.user_id,limit=limit,offset=offset)
    items = [_order_with_payment_response(item.order,item.payment) for item in orders]
    return OrdersResponse(status_code=200,orders=items,limit=limit,offset=offset)


@payments_router.get(
        '/payments',
        response_model=PaymentsResponse,
        status_code=200,
        responses=ERROR_RESPONSES,
)
@csrf_protect()
async def list_payments(
        limit: int = Query(default=20, ge=1, le=100),
        offset: int = Query(default=0, ge=0),
        auth: AuthContext = Depends(require_access_token),
        command: ListPaymentsCommand = Depends(get_list_payments_command),
) -> PaymentsResponse:
    payments = await command(user_id=auth.user_id,limit=limit,offset=offset)
    return PaymentsResponse(
        status_code=200,
        payments=[_payment_response(payment) for payment in payments],
        limit=limit,
        offset=offset,
    )


@order_router.get(
        '/{order_id}/status',
        response_model=OrderStatusResponse,
        status_code=200,
        responses=ERROR_RESPONSES,
)
@csrf_protect()
async def order_status(
        order_id: str,
        auth: AuthContext = Depends(require_access_token),
        command: GetOrderStatusCommand = Depends(get_order_status_command),
) -> OrderStatusResponse:
    result = await command(order_id=order_id,user_id=auth.user_id)
    return _order_status_response(result.order,result.payment)


@order_router.websocket('/{order_id}/events')
async def order_events(
        websocket: WebSocket,
        order_id: str,
        command: GetOrderStatusCommand = Depends(get_order_status_command),
        jwt_service: IJwtService = Depends(get_jwt_service),
        logger: ILogger = Depends(get_logger),
) -> None:
    trace_id = websocket.headers.get('X-Trace-ID') or websocket.headers.get('X-Request-ID') or str(ULID())
    token = trace_id_var.set(trace_id)
    try:
        auth = await _websocket_auth_context(websocket, jwt_service)
        if auth is None:
            await websocket.close(code=1008)
            return
        await websocket.accept()
        logger.info({'event':'order_events_connected','order_id':order_id,'user_id':auth.user_id})
        last_payload: dict | None = None
        while True:
            try:
                result = await command(order_id=order_id,user_id=auth.user_id)
            except ApplicationException as exception:
                await websocket.send_json({'event':'order_events_error','detail':exception.message,'status_code':exception.status_code})
                await websocket.close(code=1008)
                return
            status_payload = _order_status_response(result.order,result.payment).model_dump(mode='json')
            payload = {'event':'order_status','data':status_payload}
            if payload != last_payload:
                await websocket.send_text(orjson.dumps(payload).decode())
                last_payload = payload
            await asyncio.sleep(2)
    except WebSocketDisconnect:
        logger.info({'event':'order_events_disconnected','order_id':order_id})
    finally:
        trace_id_var.reset(token)


@order_router.get(
        '/{order_id}',
        response_model=OrderDetailResponse,
        status_code=200,
        responses=ERROR_RESPONSES,
)
@csrf_protect()
async def order_detail(
        order_id: str,
        auth: AuthContext = Depends(require_access_token),
        command: GetOrderCommand = Depends(get_order_command),
) -> OrderDetailResponse:
    result = await command(order_id=order_id,user_id=auth.user_id)
    return _order_detail_response(result.order,result.payment)


@order_router.post(
        '/webhook/itpay',
        status_code=200,
        responses=ERROR_RESPONSES,
)
async def itpay_webhook(
        request: Request,
        payment_command: CreatePaymentCommand = Depends(get_create_payment_command),
        logger: ILogger = Depends(get_logger),
) -> ORJSONResponse:
    raw = await request.body()
    ct = (request.headers.get('content-type') or '').lower()
    if 'application/json' in ct:
        payload = orjson.loads(raw)
    elif 'application/x-www-form-urlencoded' in ct:
        decoded = raw.decode('utf-8', errors='replace')
        qs = parse_qs(decoded, keep_blank_values=True)
        payload = {k: (vals[0] if len(vals) == 1 else vals) for k, vals in qs.items()}
    else:
        payload = orjson.loads(raw)
    data = payload.get('data') if isinstance(payload.get('data'), dict) else {}
    metadata = data.get('metadata') if isinstance(data.get('metadata'), dict) else {}
    trace_id = str(metadata.get('trace_id') or '').strip()
    if trace_id:
        logger.set_trace_id(trace_id)
    status = str(data.get('status') or '').strip().lower()
    log_payload = {
        'event': 'itpay_webhook_received',
        'webhook_id': payload.get('id'),
        'webhook_type': payload.get('type'),
        'payment_id': data.get('id'),
        'client_payment_id': data.get('client_payment_id'),
        'payment_status': status,
        'itpay_metadata': metadata,
    }
    logger.info(log_payload)
    if status == 'completed':
        payment = ItpayPaymentData.model_validate(data)
        await payment_command(payment)
    return ORJSONResponse(content={'status': 0})