"""Logic for playlist placements."""

import oto.response
from ddtrace import tracer

from sound_recordings.logic import permissions, store_outages
from sound_recordings.logic.parallel import parallel
from sound_recordings.models import placements_metadata
from sound_recordings.schemas.placement import PlacementSchema, RecentPlacementsSchema
from sound_recordings.schemas.placements import PlacementsSchema
from sound_recordings.validation.schema import schema_dump

SOURCES = [{"id": 1, "name": "Apple Music"}, {"id": 286, "name": "Spotify"}]


TASK_RESULT = "get_recent_placements_metadata"
TASK_RESULT_COUNT = "get_placements_total_count"


@tracer.wrap(name="get_placements")
def get_placements(
    request_context,
    limit,
    offset,
    order_dir,
    order_by,
    isrc,
    store_ids,
    owner_categories,
    min_followers,
):
    """Return all playlist placements associated with a provided ISRC."""
    permissions_filter = permissions.get_permissions_filter(request_context)

    result = placements_metadata.get_placements_metadata(
        permissions_filter,
        limit,
        offset,
        order_dir,
        order_by,
        isrc,
        store_ids,
        owner_categories,
        min_followers,
    )

    body = {
        "isrc": isrc,
        "items": result["items"],
        "sources": store_outages.add_outage_error_to_stores(SOURCES),
        "total_count": result["total_count"],
    }
    schema = PlacementsSchema()
    return oto.response.Response(schema_dump(schema, body))


@tracer.wrap(name="get_placement")
def get_placement(request_context, isrc, playlist_id):
    """Get an individual playlist placement via ISRC and playlist_id."""
    permissions_filter = permissions.get_permissions_filter(request_context)
    placement_model = placements_metadata.get_placement(
        permissions_filter, isrc, playlist_id
    )
    if not placement_model:
        return oto.response.Response(status=404)
    schema = PlacementSchema()
    return oto.response.Response(schema_dump(schema, placement_model))


@tracer.wrap(name="get_recent_placements")
def get_recent_placements(
    request_context,
    limit,
    offset,
    store_ids,
    owner_categories,
    min_followers,
    label_ids=None,
    subaccount_ids=None,
):
    """Return recent playlist placements."""
    permissions_filter = permissions.get_permissions_filter(request_context)

    requests = {
        TASK_RESULT: {
            "func": placements_metadata.get_recent_placements_metadata,
            "args": (
                permissions_filter,
                limit,
                offset,
                store_ids,
                owner_categories,
                min_followers,
                label_ids,
                subaccount_ids,
            ),
        },
        TASK_RESULT_COUNT: {
            "func": placements_metadata.get_placements_total_count,
            "args": (
                permissions_filter,
                owner_categories,
                min_followers,
                label_ids,
                subaccount_ids,
            ),
        },
    }

    result = parallel(requests).message
    recent_placements = result[TASK_RESULT]

    try:
        # we have total count of recent placements in each item
        count_of_placements = recent_placements[0].get("count")
    except IndexError:
        count_of_placements = 0

    body = {
        "items": result[TASK_RESULT],
        "count": count_of_placements,
        "sources": store_outages.add_outage_error_to_stores(SOURCES),
        "total": result[TASK_RESULT_COUNT],
    }
    schema = RecentPlacementsSchema()
    return oto.response.Response(schema_dump(schema, body))