from typing import Annotated, List

from fastapi import APIRouter, Depends, Form, Request

from core.security.authentication import get_user
from schema import GenericResponse
from schema.event import (
    AdminEventBookingResponse,
    EventCartCreateSchema,
    EventCartUpdateSchema,
    EventCreateSchema,
    EventPurchaseDetailResponse,
    EventUpdateSchema,
)
from schema.event import EventPaymentSessionRequest
from schema.event_filter import EventFilter
from services.event import EventService

event_router = APIRouter(prefix="/event")


@event_router.post("/", response_model=GenericResponse)
async def create_event(request: Annotated[EventCreateSchema, Form()], user=Depends(get_user),
                        service=Depends(EventService)):
    await service.create_event(request)
    return {"message": "Event created successfully."}


@event_router.get("/", response_model=GenericResponse)
async def list_all_event(user=Depends(get_user), service=Depends(EventService)):
    return {"message": "Event populated successfully.", 'data': service.fetch_all_event()}


@event_router.get("/{event_id}", response_model=GenericResponse)
async def event_details(event_id: int, user=Depends(get_user),
                        service=Depends(EventService)):
    return {"message": "Event populated successfully.", 'data': service.fetch_event_details(event_id)}


@event_router.put("/{event_id}", response_model=GenericResponse)
async def update_event(event_id: int, request: Annotated[EventUpdateSchema, Form()], user=Depends(get_user),
                       service=Depends(EventService)):
    await service.update_event(event_id, request)
    return {"message": "Event  updated successfully."}


@event_router.delete("/{event_id}", response_model=GenericResponse)
async def delete_event(event_id: int, user=Depends(get_user),
                       service=Depends(EventService)):
    service.delete_event(event_id)
    return {"message": "Event deleted successfully."}


@event_router.post("/filter", response_model=GenericResponse)
async def event_filter(request: EventFilter, user=Depends(get_user), service=Depends(EventService)):
    return {"message": "Event populated successfully.", 'data': service.event_filter(request)}


# event cart
@event_router.post("/event_cart", response_model=GenericResponse)
async def create_event_cart(request: EventCartCreateSchema, user=Depends(get_user),
                          service=Depends(EventService)):
    await service.create_event_cart(request,user)
    return {"message": "Event cart created successfully."}

@event_router.get("/event_cart/current_user/", response_model=GenericResponse)
async def get_event_cart_by_current_user(user=Depends(get_user), service=Depends(EventService)):
    return {"message": "Event carts populated successfully.", 
            'data': service.get_event_cart_by_user_id(user)}

@event_router.get("/event_cart/{event_cart_id}", response_model=GenericResponse)
async def event_cart_details(event_cart_id: int, user=Depends(get_user),
                           service=Depends(EventService)):
    return {"message": "Event cart populated successfully.", 
            'data': service.fetch_event_cart_details(event_cart_id)}

@event_router.put("/event_cart/{event_cart_id}", response_model=GenericResponse)
async def update_event_cart(event_cart_id: int, request: EventCartUpdateSchema, 
                          user=Depends(get_user), service=Depends(EventService)):
    await service.update_event_cart(event_cart_id, request,user)
    return {"message": "Event cart updated successfully."}

@event_router.delete("/event_cart/{event_cart_id}", response_model=GenericResponse)
async def delete_event_cart(event_cart_id: int, user=Depends(get_user),
                          service=Depends(EventService)):
    service.delete_event_cart(event_cart_id)
    return {"message": "Event cart deleted successfully."}

@event_router.post("/create_payment_session", response_model=GenericResponse)
async def create_event_payment_session(request: EventPaymentSessionRequest, 
                                     user=Depends(get_user),
                                     service=Depends(EventService)):
    result = await service.create_event_payment_session(request, user)
    return {
        "message": "Event payment session created successfully",
        "data": result
    }


@event_router.post("/stripe/webhook")
async def update_payment(request:Request,service: EventService = Depends(EventService)):
    payload = await request.body()
    service.update_payment(payload)
    return {"message": "Payment status updated successfully"}


@event_router.get("/purchases/history", response_model=List[EventPurchaseDetailResponse])
async def get_user_event_purchases(
    current_user: dict = Depends(get_user),
    service: EventService = Depends(EventService)
):
    """
    Get all event purchases for the current user
    """
    return service.get_user_event_purchases(current_user)


@event_router.get("/purchase/all", response_model=AdminEventBookingResponse)
async def get_all_event_bookings(
    current_user: dict = Depends(get_user),
    service: EventService = Depends(EventService)
):
    """
    Get all event bookings (admin only)
    """
    
    return dict(data=service.get_all_event_bookings())