"""Logic copied from the set_main_release_date Lambda."""
from typing import Dict, List

from ddex_ingester_common.constants.ddex_providers import SME
from ddex_ingester_common.models.s3.deal import Deal as S3Deal


def retrieve_release_dates(deals: List[S3Deal], ddex_provider: str) -> Dict:
    """Retrieve the latest start date from deal terms."""
    # Only keep R0 or R1 release deal, in that order.
    filtered_deal = filter_release_deals(deals)

    # We have a filtered deal, weed out pre_orders
    filtered_deal = filter_preorder_deals(filtered_deal)

    # Find earliest sales start date and set timed release date
    sales_start_date, timed_release_date = retrieve_deal_dates(
        filtered_deal, ddex_provider)

    # Gather territory dates that are not the same as sales start date
    territory_dates = retrieve_territory_with_differing_dates(
        filtered_deal,
        sales_start_date)

    return {
        'sales_start_date': sales_start_date,
        'timed_release_date': timed_release_date,
        'territory_dates': territory_dates,
    }


def filter_release_deals(deals: List[S3Deal]) -> S3Deal:
    """Try to filter only for R0 then R1 if available. Otherwise fail."""
    filtered_deals = [deal for deal in deals
                      if 'R0' in deal.release_references]

    if not filtered_deals:
        filtered_deals = [deal for deal in deals
                          if 'R1' in deal.release_references]

    if not filtered_deals:
        raise ValueError('No valid release deals found.')

    return filtered_deals[0]


def filter_preorder_deals(deal: S3Deal) -> S3Deal:
    """Filter out preorder deal terms from release deal."""
    # We have a filtered deal, weed out pre_orders
    deal.deal_terms = [deal_term for deal_term in
                       deal.deal_terms
                       if not deal_term.pre_order]

    if not deal.deal_terms:
        raise ValueError('Only pre-order deals exist in R0 or R1.')

    return deal


def retrieve_deal_dates(deal: S3Deal, ddex_provider: str) -> (str, str):
    """Retrieve earliest sales_start_date and set timed_release_date."""
    sales_start_date = None
    timed_release_date = None

    for deal_term in deal.deal_terms:
        start_date = deal_term.start_date
        start_date_time = deal_term.start_date_time

        if not start_date and not start_date_time:
            continue

        if not start_date:
            # Strip time from datetime
            start_date = start_date_time[0:10]

            # A date time with format '00:00:00.000Z' would indicate a timed
            # release and '00:00:00.000' would indicate a non-timed release.
            # Timed release date is the latest deal term start date
            set_timed_release_date = (
                start_date_time.endswith('Z') and (
                not timed_release_date or timed_release_date < start_date_time)  # noqa
            )

            if set_timed_release_date:
                timed_release_date = start_date_time

            # For non SME we want diff timed release and sales start date
            # So we never set sale start date with the date of a timed release
            if ddex_provider != SME and start_date_time.endswith('Z'):
                continue

        if not sales_start_date or sales_start_date > start_date:
            sales_start_date = start_date

    if timed_release_date and not sales_start_date:
        sales_start_date = timed_release_date[0:10]

    return sales_start_date, timed_release_date


def retrieve_territory_with_differing_dates(
        filtered_deal: S3Deal,
        sales_start_date: str) -> Dict:
    """Retrieve territories when start date != sales start date."""
    territory_dates = {}
    for deal_term in filtered_deal.deal_terms:
        start_date = deal_term.start_date
        start_date_time = deal_term.start_date_time

        if not start_date and not start_date_time:
            continue

        if not start_date:
            # Strip time from datetime
            start_date = start_date_time[0:10]

        if start_date == sales_start_date:
            continue

        if deal_term.territories:
            for territory in deal_term.territories:
                territory_date = territory_dates.get(territory)
                if not territory_date or territory_date < start_date:
                    territory_dates[territory] = start_date

    return territory_dates