"""A."""

import datetime
from typing import Dict
from typing import List
from typing import Optional

from .e import E
from .util import deduplicate_territories
from ..constants.ddex import DEFAULT_TERRITORY_CODE

from soundrecording_utils.metadata.types import OrchardSoundRecording
from soundrecording_utils.metadata.types import Product


def _get_start_date(product: Product):
    return product.ingestion_completed or \
        product.sale_start_date or \
        product.release_date


def _generate_sound_recording_deals(
    sound_recording_metadata: OrchardSoundRecording,
):
    """Generate Deals by StartDate."""
    territories_by_date: Dict[str, List[str]] = dict()

    # group territories by date(s)
    for track in deduplicate_territories(sound_recording_metadata):
        valid_date = _get_start_date(track.product)
        for territory in track.territories:
            if valid_date not in territories_by_date:
                territories_by_date[valid_date] = []
            territories_by_date[valid_date].append(territory)

    if territories_by_date:
        return [
            _generate_sound_recording_deal(territories, start_date=start_date)
            for start_date, territories in territories_by_date.items()
        ]

    # handle "takedown"
    return [
        _generate_sound_recording_deal(
            [DEFAULT_TERRITORY_CODE],
            end_date=str(datetime.date.today() - datetime.timedelta(days=2))
        )
    ]


def _generate_sound_recording_deal(
        territories: List[str],
        start_date: Optional[str] = None,
        end_date: Optional[str] = None
):
    """Generate Deal node by StartDate with Territories."""
    periods = []
    if start_date:
        periods.append(E('StartDate', start_date))
    if end_date:
        periods.append(E('EndDate', end_date))
    if not periods:
        raise ValueError('Deal must include start and/or end date')
    return E(
        'Deal',
        E(
            'DealTerms',
            E('CommercialModelType', 'RightsClaimModel'),
            E(
                'Usage',
                E('UseType', 'UserMakeAvailableUserProvided'),
            ),
            *[
                E(
                    'TerritoryCode',
                    territory
                )
                for territory in territories
            ],
            E(
                'ValidityPeriod',
                *periods
            ),
            E(
                'RightsClaimPolicy',
                E('RightsClaimPolicyType', 'Monetize'),
            ),
        ),
    )


def generate_release_deal(
    release_reference: str,
    sound_recording_metadata: OrchardSoundRecording,
):
    """Generate a ReleaseDeal node."""
    return E(
        'ReleaseDeal',
        E('DealReleaseReference', release_reference),
        *_generate_sound_recording_deals(sound_recording_metadata),
    )