from typing import Annotated, Any

from anydi import Provide
from fansifter_common.api.schemas import response_errors
from fastapi import APIRouter, Body, Depends, Path, Query
from starlette import status
from starlette.responses import Response

from email_campaigns.api import auth, schemas
from email_campaigns.reporting.exceptions import EmailReportingReportNotFoundError
from email_campaigns.reporting.handlers import (
    CreateEmailReportingReportHandler,
    CreateEmailReportingReportRequest,
    DeleteEmailReportingReportHandler,
    DeleteEmailReportingReportRequest,
    GetEmailReportingReportHandler,
    GetEmailReportingReportRequest,
    ListEmailReportingReportsHandler,
    ListEmailReportingReportsRequest,
    UpdateEmailReportingReportHandler,
    UpdateEmailReportingReportRequest,
)
from email_campaigns.reporting.handlers.get_reporting_analytics import (
    GetReportingAnalyticsHandler,
    GetReportingAnalyticsRequest,
)
from email_campaigns.reporting.handlers.get_reporting_link_analytics import (
    GetReportingLinkAnalyticsHandler,
    GetReportingLinkAnalyticsRequest,
)
from email_campaigns.reporting.handlers.get_reporting_sales_analytics import (
    GetReportingSalesAnalyticsHandler,
    GetReportingSalesAnalyticsRequest,
)
from email_campaigns.reporting.handlers.get_reporting_sales_locations_analytics import (
    GetReportingSalesLocationsAnalyticsHandler,
    GetReportingSalesLocationsAnalyticsRequest,
)
from email_campaigns.reporting.handlers.get_reporting_sales_products_analytics import (
    GetReportingSalesProductsAnalyticsHandler,
    GetReportingSalesProductsAnalyticsRequest,
)
from email_campaigns.reporting.handlers.get_reporting_sales_shops_analytics import (
    GetReportingSalesShopsAnalyticsHandler,
    GetReportingSalesShopsAnalyticsRequest,
)

router = APIRouter(prefix="/email-reporting", tags=["Email Reporting"])


@router.get(
    "/reports",
    operation_id="listEmailReportingReports",
    response_model=schemas.LimitOffsetPage[schemas.EmailReportingReportSummaryResponse],
    response_model_by_alias=True,
)
def list_email_reporting_reports(
    identity_id: Annotated[str, Depends(auth.get_identity_id)],
    params: Annotated[schemas.GetEmailReportingReportsInput, Query()],
    handler: Provide[ListEmailReportingReportsHandler],
) -> Any:
    limit = params.limit or ListEmailReportingReportsRequest.DEFAULT_LIMIT
    offset = params.offset or ListEmailReportingReportsRequest.DEFAULT_OFFSET
    response = handler.handle(
        ListEmailReportingReportsRequest(
            identity_id=identity_id,
            name=params.name,
            limit=limit,
            offset=offset,
        )
    )
    return schemas.LimitOffsetPage(
        total=response.total,
        items=response.items,
        limit=limit,
        offset=offset,
    )


@router.post(
    "/reports",
    operation_id="createEmailReportingReport",
    response_model=schemas.EmailReportingReportResponse,
    response_model_by_alias=True,
    status_code=status.HTTP_201_CREATED,
)
def create_email_reporting_report(
    data: Annotated[schemas.EmailReportingReportInput, Body()],
    identity_id: Annotated[str, Depends(auth.get_identity_id)],
    handler: Provide[CreateEmailReportingReportHandler],
) -> Any:
    return handler.handle(
        CreateEmailReportingReportRequest(
            identity_id=identity_id,
            name=data.name,
            email_ids=data.email_ids,
            vendor_id=data.vendor_id,
            subaccount_id=data.subaccount_id,
            global_participant_id=data.global_participant_id,
        )
    )


@router.get(
    "/reports/{reportId}",
    operation_id="getEmailReportingReport",
    response_model=schemas.EmailReportingReportResponse,
    response_model_by_alias=True,
    responses=response_errors(EmailReportingReportNotFoundError),
)
def get_email_reporting_report(
    report_id: Annotated[str, Path(alias="reportId")],
    identity_id: Annotated[str, Depends(auth.get_identity_id)],
    handler: Provide[GetEmailReportingReportHandler],
) -> Any:
    return handler.handle(
        GetEmailReportingReportRequest(
            identity_id=identity_id,
            report_id=report_id,
        )
    )


@router.patch(
    "/reports/{reportId}",
    operation_id="updateEmailReportingReport",
    response_model=schemas.EmailReportingReportResponse,
    response_model_by_alias=True,
    responses=response_errors(EmailReportingReportNotFoundError),
)
def update_email_reporting_report(
    report_id: Annotated[str, Path(alias="reportId")],
    data: Annotated[schemas.EmailReportingReportInput, Body()],
    identity_id: Annotated[str, Depends(auth.get_identity_id)],
    handler: Provide[UpdateEmailReportingReportHandler],
) -> Any:
    return handler.handle(
        UpdateEmailReportingReportRequest(
            identity_id=identity_id,
            report_id=report_id,
            name=data.name,
            email_ids=data.email_ids,
            vendor_id=data.vendor_id,
            subaccount_id=data.subaccount_id,
            global_participant_id=data.global_participant_id,
        )
    )


@router.delete(
    "/reports/{reportId}",
    operation_id="deleteEmailReportingReport",
    response_class=Response,
    status_code=status.HTTP_204_NO_CONTENT,
    responses=response_errors(EmailReportingReportNotFoundError),
)
def delete_email_reporting_report(
    report_id: Annotated[str, Path(alias="reportId")],
    identity_id: Annotated[str, Depends(auth.get_identity_id)],
    handler: Provide[DeleteEmailReportingReportHandler],
) -> None:
    handler.handle(
        DeleteEmailReportingReportRequest(
            identity_id=identity_id,
            report_id=report_id,
        )
    )


# Report analytics


@router.get(
    "/reports/{reportId}/analytics",
    operation_id="getEmailReportingReportAnalytics",
    response_model=schemas.GetEmailReportingAnalyticsResponse,
    response_model_by_alias=True,
    responses=response_errors(EmailReportingReportNotFoundError),
)
def get_email_reporting_report_analytics(
    report_id: Annotated[str, Path(alias="reportId")],
    identity_id: Annotated[str, Depends(auth.get_identity_id)],
    handler: Provide[GetReportingAnalyticsHandler],
) -> Any:
    return handler.handle(
        GetReportingAnalyticsRequest(identity_id=identity_id, report_id=report_id)
    )


@router.get(
    "/reports/{reportId}/analytics/links",
    operation_id="getEmailReportingReportLinkAnalytics",
    response_model=schemas.GetEmailReportingReportLinkAnalyticsResponse,
    response_model_by_alias=True,
    responses=response_errors(EmailReportingReportNotFoundError),
)
def get_email_reporting_report_link_analytics(
    report_id: Annotated[str, Path(alias="reportId")],
    identity_id: Annotated[str, Depends(auth.get_identity_id)],
    handler: Provide[GetReportingLinkAnalyticsHandler],
) -> Any:
    return handler.handle(
        GetReportingLinkAnalyticsRequest(identity_id=identity_id, report_id=report_id)
    )


@router.get(
    "/reports/{reportId}/analytics/sales",
    operation_id="getEmailReportingReportSalesAnalytics",
    response_model=schemas.GetEmailSalesAnalyticsResponse,
    response_model_by_alias=True,
    responses=response_errors(EmailReportingReportNotFoundError),
)
def get_email_reporting_report_sales_analytics(
    report_id: Annotated[str, Path(alias="reportId")],
    identity_id: Annotated[str, Depends(auth.get_identity_id)],
    handler: Provide[GetReportingSalesAnalyticsHandler],
) -> Any:
    return handler.handle(
        GetReportingSalesAnalyticsRequest(identity_id=identity_id, report_id=report_id)
    )


@router.get(
    "/reports/{reportId}/analytics/sales/products",
    operation_id="getEmailReportingReportSalesProductsAnalytics",
    response_model=schemas.GetEmailSalesProductsAnalyticsResponse,
    response_model_by_alias=True,
    responses=response_errors(EmailReportingReportNotFoundError),
)
def get_email_reporting_report_sales_products_analytics(
    report_id: Annotated[str, Path(alias="reportId")],
    identity_id: Annotated[str, Depends(auth.get_identity_id)],
    handler: Provide[GetReportingSalesProductsAnalyticsHandler],
) -> Any:
    return handler.handle(
        GetReportingSalesProductsAnalyticsRequest(
            identity_id=identity_id, report_id=report_id
        )
    )


@router.get(
    "/reports/{reportId}/analytics/sales/locations",
    operation_id="getEmailReportingReportSalesLocationsAnalytics",
    response_model=schemas.GetEmailSalesLocationsAnalyticsResponse,
    response_model_by_alias=True,
    responses=response_errors(EmailReportingReportNotFoundError),
)
def get_email_reporting_report_sales_locations_analytics(
    report_id: Annotated[str, Path(alias="reportId")],
    identity_id: Annotated[str, Depends(auth.get_identity_id)],
    handler: Provide[GetReportingSalesLocationsAnalyticsHandler],
) -> Any:
    return handler.handle(
        GetReportingSalesLocationsAnalyticsRequest(
            identity_id=identity_id, report_id=report_id
        )
    )


@router.get(
    "/reports/{reportId}/analytics/sales/shops",
    operation_id="getEmailReportingReportSalesShopsAnalytics",
    response_model=schemas.GetEmailSalesShopsAnalyticsResponse,
    response_model_by_alias=True,
    responses=response_errors(EmailReportingReportNotFoundError),
)
def get_email_reporting_report_sales_shops_analytics(
    report_id: Annotated[str, Path(alias="reportId")],
    identity_id: Annotated[str, Depends(auth.get_identity_id)],
    handler: Provide[GetReportingSalesShopsAnalyticsHandler],
) -> Any:
    return handler.handle(
        GetReportingSalesShopsAnalyticsRequest(
            identity_id=identity_id, report_id=report_id
        )
    )