from typing import Annotated, Any

from anydi.ext.fastapi import Inject
from fansifter_common.api.schemas import response_errors
from fansifter_common.artist.exceptions import InvalidGlobalParticipantIdError
from fastapi import APIRouter, Path, Query
from starlette import status

from dmp.ad_reporting.exceptions import (
    AdReportingAdNotFoundError,
    AdReportingAdSetNotFoundError,
    AdReportingCampaignNotFoundError,
    AdReportingInvalidCampaignIdError,
    AdReportingInvalidReportIdError,
    AdReportingReportLastCampaignDeleteError,
    AdReportingReportNotFoundError,
    AdReportingReportUniqueNameError,
)
from dmp.ad_reporting.handlers import (
    AddAdReportingCampaignToReportsHandler,
    AddAdReportingCampaignToReportsRequest,
    AddAdReportingReportToCampaignsHandler,
    AddAdReportingReportToCampaignsRequest,
    AssignArtistsToAdReportingCampaignHandler,
    AssignArtistsToAdReportingCampaignRequest,
    CreateAdReportingReportHandler,
    CreateAdReportingReportRequest,
    DeleteAdReportingReportHandler,
    DeleteAdReportingReportRequest,
    EditAdReportingReportHandler,
    EditAdReportingReportRequest,
    GetAdReportingAdHandler,
    GetAdReportingAdRequest,
    GetAdReportingAdSetHandler,
    GetAdReportingAdSetRequest,
    GetAdReportingAdSetsHandler,
    GetAdReportingAdSetsNamesHandler,
    GetAdReportingAdSetsNamesRequest,
    GetAdReportingAdSetsRequest,
    GetAdReportingAdsHandler,
    GetAdReportingAdsRequest,
    GetAdReportingCampaignHandler,
    GetAdReportingCampaignReportsHandler,
    GetAdReportingCampaignReportsRequest,
    GetAdReportingCampaignRequest,
    GetAdReportingCampaignsArtistsHandler,
    GetAdReportingCampaignsArtistsRequest,
    GetAdReportingCampaignsHandler,
    GetAdReportingCampaignsNamesHandler,
    GetAdReportingCampaignsNamesRequest,
    GetAdReportingCampaignsObjectivesHandler,
    GetAdReportingCampaignsObjectivesRequest,
    GetAdReportingCampaignsRequest,
    GetAdReportingReportAdHandler,
    GetAdReportingReportAdRequest,
    GetAdReportingReportAdSetHandler,
    GetAdReportingReportAdSetRequest,
    GetAdReportingReportAdSetsHandler,
    GetAdReportingReportAdSetsRequest,
    GetAdReportingReportAdsGroupedHandler,
    GetAdReportingReportAdsHandler,
    GetAdReportingReportAdsRequest,
    GetAdReportingReportCampaignHandler,
    GetAdReportingReportCampaignRequest,
    GetAdReportingReportCampaignsHandler,
    GetAdReportingReportCampaignsRequest,
    GetAdReportingReportOverviewHandler,
    GetAdReportingReportOverviewRequest,
    GetAdReportingReportsArtistsHandler,
    GetAdReportingReportsArtistsRequest,
    GetAdReportingReportsHandler,
    GetAdReportingReportsRequest,
    RemoveAdReportingReportCampaignHandler,
    RemoveAdReportingReportCampaignRequest,
)
from dmp.ad_reporting.models import AdReportingReport
from dmp.api import auth
from dmp.api.ad_reporting import schemas
from dmp.api.schemas import ArtistWithId, LimitOffsetPage

router = APIRouter(tags=["Ad Reporting"], prefix="/ad-reporting")


@router.get(
    "/campaigns-artists",
    operation_id="getAdReportingCampaignsArtists",
    response_model=list[ArtistWithId],
)
def get_ad_reporting_campaigns_artists(
    identity_id: auth.IdentityId,
    handler: Annotated[GetAdReportingCampaignsArtistsHandler, Inject()],
) -> Any:
    artist_ids = handler.handle(
        GetAdReportingCampaignsArtistsRequest(
            identity_id=identity_id,
        )
    )
    return [{"id": artist_id} for artist_id in artist_ids]


@router.get(
    "/campaigns-objectives",
    operation_id="getAdReportingCampaignsObjectives",
    response_model=list[schemas.AdReportingCampaignObjective],
)
def get_ad_reporting_campaigns_objectives(
    identity_id: auth.IdentityId,
    data: Annotated[schemas.GetAdReportingCampaignsObjectivesInput, Query()],
    handler: Annotated[GetAdReportingCampaignsObjectivesHandler, Inject()],
) -> Any:
    return handler.handle(
        GetAdReportingCampaignsObjectivesRequest(
            identity_id=identity_id, report_id=data.report_id
        )
    )


@router.get(
    "/campaigns-names",
    operation_id="getAdReportingCampaignsNames",
    response_model=LimitOffsetPage[schemas.AdReportingCampaignIdName],
)
def get_ad_reporting_campaigns_names(
    identity_id: auth.IdentityId,
    data: Annotated[schemas.GetAdReportingCampaignsNamesInput, Query()],
    handler: Annotated[GetAdReportingCampaignsNamesHandler, Inject()],
) -> Any:
    limit = data.limit or GetAdReportingCampaignsNamesRequest.DEFAULT_LIMIT
    offset = data.offset or GetAdReportingCampaignsNamesRequest.DEFAULT_OFFSET
    response = handler.handle(
        GetAdReportingCampaignsNamesRequest(
            identity_id=identity_id,
            search=data.search,
            global_participant_id=data.global_participant_id,
            platform=data.platform,
            objective=data.objective,
            report_id=data.report_id,
            limit=limit,
            offset=offset,
        )
    )
    return LimitOffsetPage(
        limit=limit,
        offset=offset,
        items=response.items,
        total=response.total,
    )


@router.get(
    "/campaigns",
    operation_id="getAdReportingCampaigns",
    response_model=schemas.GetAdReportingCampaignsOutput,
    response_model_by_alias=True,
)
def get_ad_reporting_campaigns(
    identity_id: auth.IdentityId,
    data: Annotated[schemas.GetAdReportingCampaignsInput, Query()],
    handler: Annotated[GetAdReportingCampaignsHandler, Inject()],
) -> Any:
    limit = data.limit or GetAdReportingCampaignsRequest.DEFAULT_LIMIT
    offset = data.offset or GetAdReportingCampaignsRequest.DEFAULT_OFFSET
    order_by = data.order_by or GetAdReportingCampaignsRequest.DEFAULT_ORDER_BY
    response = handler.handle(
        GetAdReportingCampaignsRequest(
            identity_id=identity_id,
            search=data.search,
            global_participant_id=data.global_participant_id,
            platform=data.platform,
            objective=data.objective,
            countries=data.countries,
            order_by=order_by,
            report_id=data.report_id,
            limit=limit,
            offset=offset,
        )
    )
    return {
        "items": response.items,
        "summary": response.summary,
        "limit": limit,
        "offset": offset,
        "total": response.total,
    }


@router.get(
    "/campaigns/{campaignId}",
    operation_id="getAdReportingCampaign",
    response_model=schemas.AdReportingCampaign,
    response_model_by_alias=True,
    responses=response_errors(
        AdReportingCampaignNotFoundError,
    ),
)
def get_ad_reporting_campaign(
    identity_id: auth.IdentityId,
    campaign_id: Annotated[str, Path(alias="campaignId")],
    handler: Annotated[GetAdReportingCampaignHandler, Inject()],
) -> Any:
    return handler.handle(
        GetAdReportingCampaignRequest(
            identity_id=identity_id,
            campaign_id=campaign_id,
        )
    )


@router.put(
    "/campaigns/{campaignId}/assign-artist",
    operation_id="assignArtistToAdReportingCampaign",
    responses=response_errors(
        AdReportingCampaignNotFoundError,
        InvalidGlobalParticipantIdError,
    ),
    status_code=status.HTTP_204_NO_CONTENT,
)
def assign_artist_to_ad_reporting_campaign(
    identity_id: auth.IdentityId,
    campaign_id: Annotated[str, Path(alias="campaignId")],
    data: schemas.AssignArtistToAdReportingCampaignInput,
    handler: Annotated[AssignArtistsToAdReportingCampaignHandler, Inject()],
) -> None:
    handler.handle(
        AssignArtistsToAdReportingCampaignRequest(
            identity_id=identity_id,
            campaign_id=campaign_id,
            global_participant_ids={data.global_participant_id},
        )
    )


@router.put(
    "/campaigns/{campaignId}/assign-artists",
    operation_id="assignArtistsToAdReportingCampaign",
    responses=response_errors(
        AdReportingCampaignNotFoundError,
        InvalidGlobalParticipantIdError,
    ),
    status_code=status.HTTP_204_NO_CONTENT,
)
def assign_artists_to_ad_reporting_campaign(
    identity_id: auth.IdentityId,
    campaign_id: Annotated[str, Path(alias="campaignId")],
    data: schemas.AssignArtistsToAdReportingCampaignInput,
    handler: Annotated[AssignArtistsToAdReportingCampaignHandler, Inject()],
) -> None:
    handler.handle(
        AssignArtistsToAdReportingCampaignRequest(
            identity_id=identity_id,
            campaign_id=campaign_id,
            global_participant_ids=data.global_participant_ids,
        )
    )


@router.get(
    "/campaigns/{campaignId}/reports",
    operation_id="getAdReportingCampaignReports",
    response_model=list[schemas.AdReportingCampaignReport],
    response_model_by_alias=True,
    responses=response_errors(
        AdReportingCampaignNotFoundError,
    ),
)
def get_ad_reporting_campaign_reports(
    identity_id: auth.IdentityId,
    campaign_id: Annotated[str, Path(alias="campaignId")],
    data: Annotated[schemas.GetAdReportingCampaignReportsInput, Query()],
    handler: Annotated[GetAdReportingCampaignReportsHandler, Inject()],
) -> Any:
    return handler.handle(
        GetAdReportingCampaignReportsRequest(
            identity_id=identity_id,
            campaign_id=campaign_id,
            search=data.search,
        )
    )


@router.post(
    "/campaigns/{campaignId}/reports",
    operation_id="addAdReportingCampaignToReports",
    responses=response_errors(
        AdReportingCampaignNotFoundError,
        AdReportingInvalidReportIdError,
    ),
    status_code=status.HTTP_204_NO_CONTENT,
)
def add_ad_reporting_campaign_to_reports(
    identity_id: auth.IdentityId,
    campaign_id: Annotated[str, Path(alias="campaignId")],
    data: schemas.AddAdReportingCampaignToReportsInput,
    handler: Annotated[AddAdReportingCampaignToReportsHandler, Inject()],
) -> None:
    handler.handle(
        AddAdReportingCampaignToReportsRequest(
            identity_id=identity_id,
            campaign_id=campaign_id,
            report_ids=data.report_ids,
        )
    )


@router.get(
    "/ad-sets-names",
    operation_id="getAdReportingAdSetsNames",
    response_model=LimitOffsetPage[schemas.AdReportingAdSetIdName],
    response_model_by_alias=True,
)
def get_ad_reporting_ad_sets_names(
    identity_id: auth.IdentityId,
    data: Annotated[schemas.GetAdReportingAdSetsNamesInput, Query()],
    handler: Annotated[GetAdReportingAdSetsNamesHandler, Inject()],
) -> Any:
    limit = data.limit or GetAdReportingAdSetsNamesRequest.DEFAULT_LIMIT
    offset = data.offset or GetAdReportingAdSetsNamesRequest.DEFAULT_OFFSET
    result = handler.handle(
        GetAdReportingAdSetsNamesRequest(
            identity_id=identity_id,
            search=data.search,
            campaign_id=data.campaign_id,
            global_participant_id=data.global_participant_id,
            platform=data.platform,
            objective=data.objective,
            report_id=data.report_id,
            limit=limit,
            offset=offset,
        )
    )
    return LimitOffsetPage(
        items=result.items,
        total=result.total,
        limit=limit,
        offset=offset,
    )


@router.get(
    "/ad-sets",
    operation_id="getAdReportingAdSets",
    response_model=schemas.GetAdReportingAdSetsOutput,
    response_model_by_alias=True,
)
def get_ad_reporting_ad_sets(
    identity_id: auth.IdentityId,
    data: Annotated[schemas.GetAdReportingAdSetsInput, Query()],
    handler: Annotated[GetAdReportingAdSetsHandler, Inject()],
) -> Any:
    limit = data.limit or GetAdReportingAdSetsRequest.DEFAULT_LIMIT
    offset = data.offset or GetAdReportingAdSetsRequest.DEFAULT_OFFSET
    order_by = data.order_by or GetAdReportingAdSetsRequest.DEFAULT_ORDER_BY
    response = handler.handle(
        GetAdReportingAdSetsRequest(
            identity_id=identity_id,
            search=data.search,
            campaign_id=data.campaign_id,
            global_participant_id=data.global_participant_id,
            platform=data.platform,
            objective=data.objective,
            order_by=order_by,
            limit=limit,
            offset=offset,
            countries=data.countries,
        )
    )
    return {
        "items": response.items,
        "summary": response.summary,
        "limit": limit,
        "offset": offset,
        "total": response.total,
    }


@router.get(
    "/ad-sets/{adSetId}",
    operation_id="getAdReportingAdSet",
    response_model=schemas.AdReportingAdSet,
    response_model_by_alias=True,
    responses=response_errors(
        AdReportingAdSetNotFoundError,
    ),
)
def get_ad_reporting_ad_set(
    identity_id: auth.IdentityId,
    ad_set_id: Annotated[str, Path(alias="adSetId")],
    handler: Annotated[GetAdReportingAdSetHandler, Inject()],
) -> Any:
    return handler.handle(
        GetAdReportingAdSetRequest(identity_id=identity_id, ad_set_id=ad_set_id)
    )


@router.get(
    "/ads",
    operation_id="getAdReportingAds",
    response_model=schemas.GetAdReportingAdsOutput,
    response_model_by_alias=True,
)
def get_ad_reporting_ads(
    identity_id: auth.IdentityId,
    data: Annotated[schemas.GetAdReportingAdsInput, Query()],
    handler: Annotated[GetAdReportingAdsHandler, Inject()],
) -> Any:
    limit = data.limit or GetAdReportingAdsRequest.DEFAULT_LIMIT
    offset = data.offset or GetAdReportingAdsRequest.DEFAULT_OFFSET
    order_by = data.order_by or GetAdReportingAdsRequest.DEFAULT_ORDER_BY
    response = handler.handle(
        GetAdReportingAdsRequest(
            identity_id=identity_id,
            search=data.search,
            campaign_id=data.campaign_id,
            ad_set_id=data.ad_set_id,
            global_participant_id=data.global_participant_id,
            platform=data.platform,
            objective=data.objective,
            order_by=order_by,
            limit=limit,
            offset=offset,
            countries=data.countries,
        )
    )
    return {
        "items": response.items,
        "summary": response.summary,
        "limit": limit,
        "offset": offset,
        "total": response.total,
    }


@router.get(
    "/ads/{adId}",
    operation_id="getAdReportingAd",
    response_model=schemas.AdReportingAd,
    response_model_by_alias=True,
    responses=response_errors(
        AdReportingAdNotFoundError,
    ),
)
def get_ad_reporting_ad(
    identity_id: auth.IdentityId,
    ad_id: Annotated[str, Path(alias="adId")],
    handler: Annotated[GetAdReportingAdHandler, Inject()],
) -> Any:
    return handler.handle(
        GetAdReportingAdRequest(
            identity_id=identity_id,
            ad_id=ad_id,
        )
    )


@router.get(
    "/reports",
    operation_id="getAdReportingReports",
    response_model=LimitOffsetPage[schemas.AdReportingReportView],
    response_model_by_alias=True,
)
def get_ad_reporting_reports(
    identity_id: auth.IdentityId,
    data: Annotated[schemas.GetAdReportingReportsInput, Query()],
    handler: Annotated[GetAdReportingReportsHandler, Inject()],
) -> Any:
    limit = data.limit or GetAdReportingReportsRequest.DEFAULT_LIMIT
    offset = data.offset or GetAdReportingReportsRequest.DEFAULT_OFFSET
    order_by = data.order_by or GetAdReportingReportsRequest.DEFAULT_ORDER_BY
    response = handler.handle(
        GetAdReportingReportsRequest(
            identity_id=identity_id,
            search=data.search,
            global_participant_id=data.global_participant_id,
            platform=data.platform,
            order_by=order_by,
            limit=limit,
            offset=offset,
        )
    )
    return LimitOffsetPage(
        items=response.items,
        total=response.total,
        limit=limit,
        offset=offset,
    )


@router.post(
    "/reports",
    operation_id="createAdReportingReport",
    response_model=schemas.AdReportingReport,
    response_model_by_alias=True,
    status_code=status.HTTP_201_CREATED,
    responses=response_errors(
        AdReportingReportUniqueNameError,
        AdReportingInvalidCampaignIdError,
    ),
)
def create_ad_reporting_report(
    identity_id: auth.IdentityId,
    data: schemas.CreateAdReportingReportInput,
    handler: Annotated[CreateAdReportingReportHandler, Inject()],
) -> AdReportingReport:
    return handler.handle(
        CreateAdReportingReportRequest(
            identity_id=identity_id,
            name=data.name,
            campaign_ids=data.campaign_ids,
            search=data.search,
            global_participant_id=data.global_participant_id,
            platform=data.platform,
            objective=data.objective,
        )
    )


@router.get(
    "/reports/{reportId}",
    operation_id="getAdReportingReportOverview",
    response_model=schemas.AdReportingReportOverview,
    response_model_by_alias=True,
    responses=response_errors(
        AdReportingReportNotFoundError,
    ),
)
def get_ad_reporting_report_overview(
    identity_id: auth.IdentityId,
    report_id: Annotated[str, Path(alias="reportId")],
    handler: Annotated[GetAdReportingReportOverviewHandler, Inject()],
) -> Any:
    return handler.handle(
        GetAdReportingReportOverviewRequest(
            identity_id=identity_id,
            report_id=report_id,
        )
    )


@router.put(
    "/reports/{reportId}",
    operation_id="editAdReportingReport",
    response_model=schemas.AdReportingReport,
    response_model_by_alias=True,
    responses=response_errors(
        AdReportingReportNotFoundError,
        AdReportingReportUniqueNameError,
    ),
)
def edit_ad_reporting_report(
    identity_id: auth.IdentityId,
    report_id: Annotated[str, Path(alias="reportId")],
    data: schemas.EditAdReportingReportInput,
    handler: Annotated[EditAdReportingReportHandler, Inject()],
) -> Any:
    return handler.handle(
        EditAdReportingReportRequest(
            identity_id=identity_id,
            report_id=report_id,
            name=data.name,
        )
    )


@router.delete(
    "/reports/{reportId}",
    operation_id="deleteAdReportingReport",
    responses=response_errors(
        AdReportingReportNotFoundError,
    ),
    status_code=status.HTTP_204_NO_CONTENT,
)
def delete_ad_reporting_report(
    identity_id: auth.IdentityId,
    report_id: Annotated[str, Path(alias="reportId")],
    handler: Annotated[DeleteAdReportingReportHandler, Inject()],
) -> None:
    handler.handle(
        DeleteAdReportingReportRequest(
            identity_id=identity_id,
            report_id=report_id,
        )
    )


@router.get(
    "/reports/{reportId}/campaigns",
    operation_id="getAdReportingReportCampaigns",
    response_model=schemas.GetAdReportingCampaignsOutput,
    response_model_by_alias=True,
    responses=response_errors(
        AdReportingReportNotFoundError,
    ),
)
def get_ad_reporting_report_campaigns(
    identity_id: auth.IdentityId,
    report_id: Annotated[str, Path(alias="reportId")],
    data: Annotated[schemas.GetAdReportingReportCampaignsInput, Query()],
    handler: Annotated[GetAdReportingReportCampaignsHandler, Inject()],
) -> Any:
    limit = data.limit or GetAdReportingReportCampaignsRequest.DEFAULT_LIMIT
    offset = data.offset or GetAdReportingReportCampaignsRequest.DEFAULT_OFFSET
    order_by = data.order_by or GetAdReportingReportCampaignsRequest.DEFAULT_ORDER_BY

    response = handler.handle(
        GetAdReportingReportCampaignsRequest(
            identity_id=identity_id,
            report_id=report_id,
            search=data.search,
            countries=data.countries,
            global_participant_id=data.global_participant_id,
            platform=data.platform,
            objective=data.objective,
            order_by=order_by,
            limit=limit,
            offset=offset,
        )
    )
    return {
        "items": response.items,
        "summary": response.summary,
        "limit": limit,
        "offset": offset,
        "total": response.summary.total,
    }


@router.get(
    "/reports/{reportId}/campaigns/{campaignId}",
    operation_id="getAdReportingReportCampaign",
    response_model=schemas.AdReportingCampaign,
    responses=response_errors(
        AdReportingReportNotFoundError,
        AdReportingCampaignNotFoundError,
    ),
)
def get_ad_reporting_report_campaign(
    identity_id: auth.IdentityId,
    report_id: Annotated[str, Path(alias="reportId")],
    campaign_id: Annotated[str, Path(alias="campaignId")],
    handler: Annotated[GetAdReportingReportCampaignHandler, Inject()],
) -> Any:
    return handler.handle(
        GetAdReportingReportCampaignRequest(
            identity_id=identity_id,
            report_id=report_id,
            campaign_id=campaign_id,
        )
    )


@router.delete(
    "/reports/{reportId}/campaigns/{campaignId}",
    operation_id="removeAdReportingReportCampaign",
    responses=response_errors(
        AdReportingReportNotFoundError,
        AdReportingCampaignNotFoundError,
        AdReportingReportLastCampaignDeleteError,
    ),
    status_code=status.HTTP_204_NO_CONTENT,
)
def remove_ad_reporting_report_campaign(
    identity_id: auth.IdentityId,
    report_id: Annotated[str, Path(alias="reportId")],
    campaign_id: Annotated[str, Path(alias="campaignId")],
    handler: Annotated[RemoveAdReportingReportCampaignHandler, Inject()],
) -> None:
    handler.handle(
        RemoveAdReportingReportCampaignRequest(
            identity_id=identity_id,
            report_id=report_id,
            campaign_id=campaign_id,
        )
    )


@router.get(
    "/reports/{reportId}/ad-sets",
    operation_id="getAdReportingReportAdSets",
    response_model=schemas.GetAdReportingAdSetsOutput,
    response_model_by_alias=True,
    responses=response_errors(
        AdReportingReportNotFoundError,
    ),
)
def get_ad_reporting_report_ad_sets(
    identity_id: auth.IdentityId,
    report_id: Annotated[str, Path(alias="reportId")],
    data: Annotated[schemas.GetAdReportingAdSetsInput, Query()],
    handler: Annotated[GetAdReportingReportAdSetsHandler, Inject()],
) -> Any:
    limit = data.limit or GetAdReportingReportAdSetsRequest.DEFAULT_LIMIT
    offset = data.offset or GetAdReportingReportAdSetsRequest.DEFAULT_OFFSET
    order_by = data.order_by or GetAdReportingReportAdSetsRequest.DEFAULT_ORDER_BY

    response = handler.handle(
        GetAdReportingReportAdSetsRequest(
            identity_id=identity_id,
            report_id=report_id,
            search=data.search,
            campaign_id=data.campaign_id,
            global_participant_id=data.global_participant_id,
            platform=data.platform,
            objective=data.objective,
            order_by=order_by,
            limit=limit,
            offset=offset,
            countries=data.countries,
        )
    )
    return {
        "items": response.items,
        "summary": response.summary,
        "limit": limit,
        "offset": offset,
        "total": response.summary.total,
    }


@router.get(
    "/reports/{reportId}/ad-sets/{adSetId}",
    operation_id="getAdReportingReportAdSet",
    response_model=schemas.AdReportingAdSet,
    response_model_by_alias=True,
    responses=response_errors(
        AdReportingReportNotFoundError,
        AdReportingAdSetNotFoundError,
    ),
)
def get_ad_reporting_report_ad_set(
    identity_id: auth.IdentityId,
    report_id: Annotated[str, Path(alias="reportId")],
    ad_set_id: Annotated[str, Path(alias="adSetId")],
    handler: Annotated[GetAdReportingReportAdSetHandler, Inject()],
) -> Any:
    return handler.handle(
        GetAdReportingReportAdSetRequest(
            identity_id=identity_id,
            report_id=report_id,
            ad_set_id=ad_set_id,
        )
    )


@router.get(
    "/reports/{reportId}/ads",
    operation_id="getAdReportingReportAds",
    response_model=schemas.GetAdReportingAdsOutput,
    response_model_by_alias=True,
    responses=response_errors(
        AdReportingReportNotFoundError,
    ),
)
def get_ad_reporting_report_ads(
    identity_id: auth.IdentityId,
    report_id: Annotated[str, Path(alias="reportId")],
    data: Annotated[schemas.GetAdReportingAdsInput, Query()],
    handler: Annotated[GetAdReportingReportAdsHandler, Inject()],
) -> Any:
    limit = data.limit or GetAdReportingReportAdsRequest.DEFAULT_LIMIT
    offset = data.offset or GetAdReportingReportAdsRequest.DEFAULT_OFFSET
    order_by = data.order_by or GetAdReportingReportAdsRequest.DEFAULT_ORDER_BY
    response = handler.handle(
        GetAdReportingReportAdsRequest(
            identity_id=identity_id,
            report_id=report_id,
            search=data.search,
            campaign_id=data.campaign_id,
            ad_set_id=data.ad_set_id,
            global_participant_id=data.global_participant_id,
            platform=data.platform,
            objective=data.objective,
            countries=data.countries,
            order_by=order_by,
            limit=limit,
            offset=offset,
        )
    )
    return {
        "items": response.items,
        "summary": response.summary,
        "limit": limit,
        "offset": offset,
        "total": response.summary.total,
    }


@router.get(
    "/reports/{reportId}/ads/grouped",
    operation_id="getAdReportingReportAdsGrouped",
    response_model=schemas.GetAdReportingAdsGroupedResponse,
    response_model_by_alias=True,
)
def get_ad_reporting_report_ads_grouped(
    identity_id: auth.IdentityId,
    report_id: Annotated[str, Path(alias="reportId")],
    data: Annotated[schemas.GetAdReportingAdsInput, Query()],
    handler: Annotated[GetAdReportingReportAdsGroupedHandler, Inject()],
) -> Any:
    limit = data.limit or GetAdReportingReportAdsRequest.DEFAULT_LIMIT
    offset = data.offset or GetAdReportingReportAdsRequest.DEFAULT_OFFSET
    order_by = data.order_by or GetAdReportingReportAdsRequest.DEFAULT_ORDER_BY
    response = handler.handle(
        GetAdReportingReportAdsRequest(
            identity_id=identity_id,
            report_id=report_id,
            search=data.search,
            campaign_id=data.campaign_id,
            ad_set_id=data.ad_set_id,
            global_participant_id=data.global_participant_id,
            platform=data.platform,
            objective=data.objective,
            countries=data.countries,
            order_by=order_by,
            limit=limit,
            offset=offset,
        )
    )
    return {
        "limit": limit,
        "offset": offset,
        "total": response.total,
        "summary": response.summary,
        "items": response.items,
    }


@router.get(
    "/reports/{reportId}/ads/{adId}",
    operation_id="getAdReportingReportAd",
    response_model=schemas.AdReportingAd,
    responses=response_errors(
        AdReportingReportNotFoundError,
        AdReportingAdNotFoundError,
    ),
)
def get_ad_reporting_report_ad(
    identity_id: auth.IdentityId,
    report_id: Annotated[str, Path(alias="reportId")],
    ad_id: Annotated[str, Path(alias="adId")],
    handler: Annotated[GetAdReportingReportAdHandler, Inject()],
) -> Any:
    return handler.handle(
        GetAdReportingReportAdRequest(
            identity_id=identity_id,
            report_id=report_id,
            ad_id=ad_id,
        )
    )


@router.get(
    "/reports-artists",
    operation_id="getAdReportingReportsArtists",
    response_model=list[ArtistWithId],
)
def get_ad_reporting_reports_artists(
    identity_id: auth.IdentityId,
    data: Annotated[schemas.GetAdReportingReportsArtistsInput, Query()],
    handler: Annotated[GetAdReportingReportsArtistsHandler, Inject()],
) -> Any:
    artist_ids = handler.handle(
        GetAdReportingReportsArtistsRequest(
            identity_id=identity_id,
            report_id=data.report_id,
        )
    )
    return [{"id": artist_id} for artist_id in artist_ids]


@router.post(
    "/reports/{reportId}/campaigns",
    operation_id="addCampaignsToAReport",
    responses=response_errors(
        AdReportingReportNotFoundError,
        AdReportingCampaignNotFoundError,
    ),
    response_model=schemas.AddAdReportingReportToCampaignsOutput,
)
def add_ad_reporting_campaigns_to_a_report(
    identity_id: auth.IdentityId,
    report_id: Annotated[str, Path(alias="reportId")],
    data: schemas.AddAdReportingReportToCampaignsInput,
    handler: Annotated[AddAdReportingReportToCampaignsHandler, Inject()],
) -> Any:
    campaigns_added = handler.handle(
        AddAdReportingReportToCampaignsRequest(
            identity_id=identity_id,
            campaign_ids=data.campaign_ids,
            report_id=report_id,
            search=data.search,
            global_participant_id=data.global_participant_id,
            countries=data.countries,
            platform=data.platform,
            objective=data.objective,
        )
    )
    return {
        "campaignsAdded": campaigns_added,
    }