"""Test handler."""
from datetime import date, datetime
from unittest.mock import ANY, MagicMock, patch

from constants import queries
from constants.set_main_release_date import (
    RC_JSON_NAME)
from ddex_ingester_common.release_correction.release_correction_diffs import (
    ReleaseCorrectionDiffDetail)
from ddex_ingester_common.schemas.s3_schema import S3Schema
from ddex_ingester_common.schemas.state_machine_schema import (
    StateMachineSchema)
import index
import pytest


@patch('index.create_blank_rc_json')
@patch('index.logger')
@patch('index.graphql')
@patch('index.update_audio_release_date')
@patch('index.update_product_timed_release')
@patch('index.replace_product_territory_dates')
@patch('index.load_ddex_json')
def test_handler(
        mock_load_ddex_json,
        mock_replace_product_territory_dates,
        mock_update_product_timed_release,
        mock_update_product,
        mock_graphql,
        mock_current_logger,
        mock_rc_json,
        mock_event):
    """Test the main handler."""
    mock_logger = MagicMock(name='info')
    mock_current_logger.return_value = mock_logger

    mock_load_ddex_json.return_value = mock_event

    response = index.handler(mock_event, None)

    mock_graphql_conn = MagicMock(name='GraphQLConnector')
    mock_graphql.return_value = mock_graphql_conn

    mock_update_product.assert_called_with(
        mock_graphql.GraphQLConnector(),
        ANY,
        '2020-03-25',
        '2020-03-25'
    )
    # CCM-3561 We no longer set timed release from DDEX deliveries
    # mock_update_product_timed_release.assert_called_with(
    #     ANY,
    #     mock_graphql.GraphQLConnector(),
    #     234324,
    #     '2020-03-27T04:00:00Z',
    #     '2020-03-25',
    # )
    mock_replace_product_territory_dates.assert_called_with(
        mock_graphql.GraphQLConnector(),
        234324,
        {
            'AE': '2020-03-27',
            'BE': '2020-03-27',
        }
    )
    assert response.get('product').get('original_release_date') == '2020-03-25'
    assert response.get('product').get('sale_start_date') == '2020-03-25'


@patch('index.graphql')
def test_replace_product_territory_dates(mock_graphql):
    """Test replace_product_territory_dates function."""
    mock_graphql_conn = mock_graphql.GraphQLConnector()

    index.replace_product_territory_dates(
        mock_graphql_conn,
        45234,
        {
            'GB': '2020-03-25',
            'US': '2020-03-25',
            'AE': '2020-03-27',
            'BE': '2020-03-27',
        }
    )

    payload = {
        'productId': 45234,
        'territoryDates': [
            {
                'countryCodes': ['GB', 'US'],
                'saleStartDate': '2020-03-25',
            },
            {
                'countryCodes': ['AE', 'BE'],
                'saleStartDate': '2020-03-27',
            },
        ]
    }

    mock_graphql_conn.execute.assert_called_with(
        queries.REPLACE_PRODUCT_TERRITORY_DATES,
        {'data': payload}
    )


@patch('index.graphql')
def test_update_product_timed_release_gmt_timezone(
        mock_graphql,
        mock_event,
        mock_get_timed_release_stores):
    """Test update_product_timed_release function."""
    context = StateMachineSchema().load(mock_event)
    mock_graphql_conn = mock_graphql.GraphQLConnector()
    mock_graphql_conn.execute.return_value = mock_get_timed_release_stores
    timed_release_date = '2020-03-27T04:00:00'

    index.update_product_timed_release(
        context,
        mock_graphql_conn,
        2452,
        timed_release_date,
        '2020-03-25',
    )

    mock_graphql_conn.execute.assert_called_with(
        queries.SET_PRODUCT_RELEASE_SCHEDULE,
        {'data': {
            'productId': 2452,
            'releaseSchedule': {
                'staggered': [],
                'timed': [
                    {
                        'deliveryStore': {'id': '581'},
                        'saleDateTime': timed_release_date
                    },
                    {
                        'deliveryStore': {'id': '412'},
                        'saleDateTime': timed_release_date
                    },
                    {
                        'deliveryStore': {'id': '348'},
                        'saleDateTime': timed_release_date
                    },
                ]
            }
        }}
    )


def test_update_product_timed_release_no_release_date(mock_event):
    """Test update_product_timed_release returns None with no Release data."""
    context = StateMachineSchema().load(mock_event)
    timed_release_date = None
    assert not index.update_product_timed_release(
        context,
        None,
        2452,
        timed_release_date,
        '2020-03-25'
    )


@patch('index.graphql')
def test_update_product_timed_release_local_timezone(
        mock_graphql,
        mock_event,
        mock_get_timed_release_stores):
    """Test update_product_timed_release function."""
    context = StateMachineSchema().load(mock_event)
    mock_graphql_conn = mock_graphql.GraphQLConnector()
    mock_graphql_conn.execute.return_value = mock_get_timed_release_stores
    timed_release_date = '2020-03-27T04:00:00'

    index.update_product_timed_release(
        context,
        mock_graphql_conn,
        2452,
        timed_release_date,
        '2020-03-25',
    )

    mock_graphql_conn.execute.assert_called_with(
        queries.SET_PRODUCT_RELEASE_SCHEDULE,
        {'data': {
            'productId': 2452,
            'releaseSchedule': {
                'staggered': [],
                'timed': [
                    {
                        'deliveryStore': {'id': '581'},
                        'saleDateTime': timed_release_date
                    },
                    {
                        'deliveryStore': {'id': '412'},
                        'saleDateTime': timed_release_date
                    },
                    {
                        'deliveryStore': {'id': '348'},
                        'saleDateTime': timed_release_date
                    },
                ]
            }
        }}
    )


@patch('index.graphql')
def test_update_audio_release_date(
        mock_graphql,
        mock_event):
    """Test update_audio_release_date function."""
    context = StateMachineSchema().load(mock_event)
    context.product.product_id = 2342
    mock_graphql_conn = mock_graphql.GraphQLConnector()

    index.update_audio_release_date(
        mock_graphql_conn, context, '2020-03-27', '2020-03-25')

    mock_graphql_conn.execute.assert_called_with(
        queries.UPDATE_PRODUCT_RELEASE_DATE,
        {
            'data': {
                'productId': 2342,
                'releaseDate': '2020-03-27',
                'saleStartDate': '2020-03-25',
            }
        }
    )


@patch('index.write_rc_json')
@patch('index.create_blank_rc_json')
@patch('index.check_for_product', return_value={'releaseDate': '2030-01-03'})
@patch('index.graphql')
def test_update_video_release_date_in_content(
        mock_graphql,
        mock_check_product,
        mock_rc_json,
        mock_write_rc,
        mock_event,
        s3_release_corrections):
    """Test update_video_release_date function."""
    mock_rc_json.return_value = s3_release_corrections
    context = StateMachineSchema().load(mock_event)
    context.product.status = 'in_content'
    context.product.product_id = 2342
    mock_graphql_conn = mock_graphql.GraphQLConnector()

    index.update_video_release_date(
        mock_graphql_conn, context,
        '2025-03-27', '2025-03-25')

    mock_check_product.assert_called_with(context, mock_graphql_conn)
    mock_graphql_conn.execute.assert_not_called()
    mock_write_rc.assert_called_once()
    expected_s3_output = {'changes': [ReleaseCorrectionDiffDetail(field_name='releaseDate', isrc=None, old='2030-01-03', new='2025-03-27', db_table_name='', db_field_name='', email_customer=False, accept_update=False)]}  # noqa
    event_details = {'bucket': context.bucket, 'key': context.key}
    mock_write_rc.assert_called_with(
        event_details,
        expected_s3_output,
        RC_JSON_NAME)


@patch('index.write_rc_json')
@patch('index.create_blank_rc_json')
@patch('index.check_for_product', return_value={'releaseDate': '2030-10-14'})
@patch('index.graphql')
def test_update_video_release_date_in_content_no_update(
        mock_graphql,
        mock_check_product,
        mock_rc_json,
        mock_write_rc,
        mock_event,
        s3_release_corrections):
    """Test update_video_release_date function."""
    context = StateMachineSchema().load(mock_event)
    context.product.status = 'in_content'
    context.product.product_id = 2342
    mock_graphql_conn = mock_graphql.GraphQLConnector()

    index.update_video_release_date(
        mock_graphql_conn, context,
        '2030-10-14', '2030-10-14')

    mock_check_product.assert_called_with(context, mock_graphql_conn)
    mock_graphql_conn.execute.assert_not_called()
    mock_write_rc.assert_not_called()


@patch('index.write_rc_json')
@patch('index.create_blank_rc_json')
@patch('index.graphql')
@patch('index.date')
def test_update_video_release_date_awal_before_cutover_dates_dont_match(  # noqa
        mock_date,
        mock_graphql,
        mock_rc_json,
        mock_write_rc,
        mock_event,
        s3_release_corrections):
    """Test update_video_release_date function."""
    mock_date.today.return_value = datetime.strptime(
        '2020-03-28', '%Y-%m-%d'
    ).date()

    # SWITCH-2793 Scenario 1
    context = StateMachineSchema().load(mock_event)
    context.ddex_provider = 'ALTAFONTE'
    context.product.product_id = 2342
    mock_graphql_conn = mock_graphql.GraphQLConnector()

    index.update_video_release_date(
        mock_graphql_conn, context,
        '1974-11-09', '2022-01-01')

    mock_write_rc.assert_not_called()
    mock_graphql_conn.execute.assert_called_with(
        queries.UPDATE_VIDEO_PRODUCT_RELEASE_DATE,
        {
            'data': {
                'update': {
                    'productId': '2342',
                    'originalReleaseDate': '1974-11-09',
                    'releaseDate': '2025-04-01',
                    'newRelease': False
                }
            }
        }
    )


@patch('index.write_rc_json')
@patch('index.create_blank_rc_json')
@patch('index.graphql')
@patch('index.date')
def test_update_video_release_date_sme_release_date_in_future(  # noqa
        mock_date,
        mock_graphql,
        mock_rc_json,
        mock_write_rc,
        mock_event,
        s3_release_corrections):
    """Test update_video_release_date function."""
    mock_date.today.return_value = datetime.strptime(
        '2020-03-28', '%Y-%m-%d'
    ).date()

    context = StateMachineSchema().load(mock_event)
    context.ddex_provider = 'SME'
    context.product.product_id = 2342
    mock_graphql_conn = mock_graphql.GraphQLConnector()

    index.update_video_release_date(
        mock_graphql_conn, context,
        '1974-11-09', '2040-01-01')

    mock_write_rc.assert_not_called()
    mock_graphql_conn.execute.assert_called_with(
        queries.UPDATE_VIDEO_PRODUCT_RELEASE_DATE,
        {
            'data': {
                'update': {
                    'productId': '2342',
                    'originalReleaseDate': '1974-11-09',
                    'releaseDate': '2040-01-01',
                    'newRelease': False
                }
            }
        }
    )


@patch('index.write_rc_json')
@patch('index.create_blank_rc_json')
@patch('index.graphql')
@patch('index.date')
def test_update_video_release_date_sme_release_date_in_past(  # noqa
        mock_date,
        mock_graphql,
        mock_rc_json,
        mock_write_rc,
        mock_event,
        s3_release_corrections):
    """Test update_video_release_date function."""
    mock_date.today.return_value = datetime.strptime(
        '2020-03-28', '%Y-%m-%d'
    ).date()

    context = StateMachineSchema().load(mock_event)
    context.ddex_provider = 'SME'
    context.product.product_id = 2342
    mock_graphql_conn = mock_graphql.GraphQLConnector()

    index.update_video_release_date(
        mock_graphql_conn, context,
        '1974-11-09', '2020-01-01')

    mock_write_rc.assert_not_called()
    mock_graphql_conn.execute.assert_called_with(
        queries.UPDATE_VIDEO_PRODUCT_RELEASE_DATE,
        {
            'data': {
                'update': {
                    'productId': '2342',
                    'originalReleaseDate': '1974-11-09',
                    'releaseDate': '2020-03-28',
                    'newRelease': False
                }
            }
        }
    )


@patch('index.write_rc_json')
@patch('index.create_blank_rc_json')
@patch('index.graphql')
@patch('index.date')
def test_update_video_release_date_sme_blank_original_release_date(  # noqa
        mock_date,
        mock_graphql,
        mock_rc_json,
        mock_write_rc,
        mock_event,
        s3_release_corrections):
    """Test update_video_release_date function."""
    mock_date.today.return_value = datetime.strptime(
        '2020-03-28', '%Y-%m-%d'
    ).date()

    context = StateMachineSchema().load(mock_event)
    context.ddex_provider = 'SME'
    context.product.product_id = 2342
    mock_graphql_conn = mock_graphql.GraphQLConnector()

    index.update_video_release_date(
        mock_graphql_conn, context,
        None, '2040-01-01')

    mock_write_rc.assert_not_called()
    mock_graphql_conn.execute.assert_called_with(
        queries.UPDATE_VIDEO_PRODUCT_RELEASE_DATE,
        {
            'data': {
                'update': {
                    'productId': '2342',
                    'originalReleaseDate': None,
                    'releaseDate': '2040-01-01',
                    'newRelease': True
                }
            }
        }
    )


@patch('index.write_rc_json')
@patch('index.create_blank_rc_json')
@patch('index.graphql')
def test_update_audio_release_date_awal_audio_before_cutover_dates_dont_match(  # noqa
        mock_graphql,
        mock_rc_json,
        mock_write_rc,
        mock_event,
        s3_release_corrections):
    """Test update_audio_release_date function."""
    context = StateMachineSchema().load(mock_event)
    context.ddex_provider = 'ALTAFONTE'
    context.product.product_id = 2342
    mock_graphql_conn = mock_graphql.GraphQLConnector()

    index.update_audio_release_date(
        mock_graphql_conn, context,
        '1974-11-09', '2022-01-01')

    mock_write_rc.assert_not_called()
    mock_graphql_conn.execute.assert_called_with(
        queries.UPDATE_PRODUCT_RELEASE_DATE,
        {
            'data': {
                'productId': 2342,
                'releaseDate': '1974-11-09',
                'saleStartDate': '2025-04-01'
            }
        }
    )


@patch('index.write_rc_json')
@patch('index.create_blank_rc_json')
@patch('index.graphql')
@patch('index.date')
def test_update_video_release_date_awal_before_cutover_dates_match(
        mock_date,
        mock_graphql,
        mock_rc_json,
        mock_write_rc,
        mock_event,
        s3_release_corrections):
    """Test update_video_release_date function."""
    mock_date.today.return_value = datetime.strptime(
        '2020-03-28', '%Y-%m-%d'
    ).date()

    # SWITCH-2793 Scenario 2
    context = StateMachineSchema().load(mock_event)
    context.ddex_provider = 'ALTAFONTE'
    context.product.product_id = 2342
    mock_graphql_conn = mock_graphql.GraphQLConnector()

    index.update_video_release_date(
        mock_graphql_conn, context,
        '2022-05-11', '2022-05-11')

    mock_write_rc.assert_not_called()
    mock_graphql_conn.execute.assert_called_with(
        queries.UPDATE_VIDEO_PRODUCT_RELEASE_DATE,
        {
            'data': {
                'update': {
                    'productId': '2342',
                    'originalReleaseDate': '2022-05-11',
                    'releaseDate': '2025-04-01',
                    'newRelease': False
                }
            }
        }
    )


@patch('index.write_rc_json')
@patch('index.create_blank_rc_json')
@patch('index.graphql')
def test_update_audio_release_date_awal_audio_before_cutover_dates_match(
        mock_graphql,
        mock_rc_json,
        mock_write_rc,
        mock_event,
        s3_release_corrections):
    """Test update_audio_release_date function."""
    context = StateMachineSchema().load(mock_event)
    context.ddex_provider = 'ALTAFONTE'
    context.product.product_id = 2342
    mock_graphql_conn = mock_graphql.GraphQLConnector()

    index.update_audio_release_date(
        mock_graphql_conn, context,
        '2025-01-11', '2025-01-11')

    mock_write_rc.assert_not_called()
    mock_graphql_conn.execute.assert_called_with(
        queries.UPDATE_PRODUCT_RELEASE_DATE,
        {
            'data': {
                'productId': 2342,
                'releaseDate': '2025-01-11',
                'saleStartDate': '2025-04-01'
            }
        }
    )


@patch('index.write_rc_json')
@patch('index.create_blank_rc_json')
@patch('index.graphql')
@patch('index.date')
def test_update_video_release_date_awal_after_cutover_dates_match(
        mock_date,
        mock_graphql,
        mock_rc_json,
        mock_write_rc,
        mock_event,
        s3_release_corrections):
    """Test update_video_release_date function."""
    mock_date.today.return_value = datetime.strptime(
        '2020-03-28', '%Y-%m-%d'
    ).date()

    # SWITCH-2793 Scenario 3
    context = StateMachineSchema().load(mock_event)
    context.ddex_provider = 'ALTAFONTE'
    context.product.product_id = 2342
    mock_graphql_conn = mock_graphql.GraphQLConnector()

    index.update_video_release_date(
        mock_graphql_conn, context,
        '2025-11-11', '2025-11-11')

    mock_write_rc.assert_not_called()
    mock_graphql_conn.execute.assert_called_with(
        queries.UPDATE_VIDEO_PRODUCT_RELEASE_DATE,
        {
            'data': {
                'update': {
                    'productId': '2342',
                    'originalReleaseDate': None,
                    'releaseDate': '2025-11-11',
                    'newRelease': True
                }
            }
        }
    )


@patch('index.write_rc_json')
@patch('index.create_blank_rc_json')
@patch('index.graphql')
def test_update_audio_release_date_awal_audio_after_cutover_dates_match(
        mock_graphql,
        mock_rc_json,
        mock_write_rc,
        mock_event,
        s3_release_corrections):
    """Test update_audio_release_date function."""
    context = StateMachineSchema().load(mock_event)
    context.ddex_provider = 'ALTAFONTE'
    context.product.product_id = 2342
    mock_graphql_conn = mock_graphql.GraphQLConnector()

    index.update_audio_release_date(
        mock_graphql_conn, context,
        '2025-11-11', '2025-11-11')

    mock_write_rc.assert_not_called()
    mock_graphql_conn.execute.assert_called_with(
        queries.UPDATE_PRODUCT_RELEASE_DATE,
        {
            'data': {
                'productId': 2342,
                'releaseDate': '2025-11-11',
                'saleStartDate': '2025-11-11'
            }
        }
    )


@patch('index.write_rc_json')
@patch('index.create_blank_rc_json')
@patch('index.graphql')
@patch('index.date')
def test_update_video_release_date_awal_after_cutover_dates_dont_match(
        mock_date,
        mock_graphql,
        mock_rc_json,
        mock_write_rc,
        mock_event,
        s3_release_corrections):
    """Test update_video_release_date function."""
    # SWITCH-2793 Scenario 4
    context = StateMachineSchema().load(mock_event)
    context.ddex_provider = 'ALTAFONTE'
    context.product.product_id = 2342
    mock_graphql_conn = mock_graphql.GraphQLConnector()
    mock_date.today.return_value = date(2000, 1, 1)

    index.update_video_release_date(
        mock_graphql_conn, context,
        '2025-11-11', '2026-11-11')

    mock_write_rc.assert_not_called()
    mock_graphql_conn.execute.assert_called_with(
        queries.UPDATE_VIDEO_PRODUCT_RELEASE_DATE,
        {
            'data': {
                'update': {
                    'productId': '2342',
                    'originalReleaseDate': '2025-11-11',
                    'releaseDate': '2026-11-11',
                    'newRelease': False
                }
            }
        }
    )


@patch('index.write_rc_json')
@patch('index.create_blank_rc_json')
@patch('index.graphql')
def test_update_audio_release_date_awal_audio_after_cutover_dates_dont_match(
        mock_graphql,
        mock_rc_json,
        mock_write_rc,
        mock_event,
        s3_release_corrections):
    """Test update_audio_release_date function."""
    # SWITCH-2793 Scenario 4
    context = StateMachineSchema().load(mock_event)
    context.ddex_provider = 'ALTAFONTE'
    context.product.product_id = 2342
    mock_graphql_conn = mock_graphql.GraphQLConnector()

    index.update_audio_release_date(
        mock_graphql_conn, context,
        '2025-11-11', '2026-11-11')

    mock_write_rc.assert_not_called()
    mock_graphql_conn.execute.assert_called_with(
        queries.UPDATE_PRODUCT_RELEASE_DATE,
        {
            'data': {
                'productId': 2342,
                'releaseDate': '2025-11-11',
                'saleStartDate': '2026-11-11'
            }
        }
    )


@patch('index.write_rc_json')
@patch('index.create_blank_rc_json')
@patch('index.graphql')
def test_update_audio_release_date_awal_video_after_cutover_date_timed_release(  # noqa
        mock_graphql,
        mock_rc_json,
        mock_write_rc,
        mock_event,
        mock_get_timed_release_stores):
    """Test update_audio_release_date function."""
    mock_graphql.execute.return_value = mock_get_timed_release_stores
    context = S3Schema().load(mock_event)
    context.ddex_provider = 'ALTAFONTE'
    timed_release_date = '2026-03-25T04:00:00Z'
    sales_start_date = '2025-04-12'

    index.update_product_timed_release(
        context,
        mock_graphql,
        context.product.product_id,
        timed_release_date,
        sales_start_date,
    )

    mock_graphql.execute.assert_called_with(
        queries.SET_PRODUCT_RELEASE_SCHEDULE,
        {'data': {
            'productId': 234324,
            'releaseSchedule': {
                'staggered': [
                    {
                        'deliveryStore': {'id': '286'},
                        'saleDate': '2025-11-01',
                    },
                    {
                        'deliveryStore': {'id': '723'},
                        'saleDate': '2025-05-01',
                    }
                ],
                'timed': [
                    {
                        'deliveryStore': {'id': '581'},
                        'saleDateTime': timed_release_date
                    },
                    {
                        'deliveryStore': {'id': '412'},
                        'saleDateTime': timed_release_date
                    },
                    {
                        'deliveryStore': {'id': '348'},
                        'saleDateTime': timed_release_date
                    },
                ]
            }
        }}
    )


@patch('index.write_rc_json')
@patch('index.create_blank_rc_json')
@patch('index.graphql')
def test_update_audio_release_date_awal_video_before_cutover_date_timed_release(  # noqa
        mock_graphql,
        mock_rc_json,
        mock_write_rc,
        mock_event,
        s3_release_corrections):
    """Test update_audio_release_date function."""
    context = S3Schema().load(mock_event)
    context.ddex_provider = 'ALTAFONTE'
    timed_release_date = '2020-03-25T04:00:00Z'
    result = index.update_product_timed_release(
        context,
        mock_graphql,
        context.product.product_id,
        timed_release_date,
        '2020-03-25')

    assert not result
    mock_graphql.assert_not_called()


def test_retrieve_release_dates_deal_has_differing_territory_dates(
        mock_event):
    """Test retrieve_release_dates where deals have differing release dates."""
    context = S3Schema().load(mock_event)
    deals = context.deals
    result = index.retrieve_release_dates(deals, 'SME')

    assert result == {
        'sales_start_date': '2020-03-25',
        'territory_dates': {
            'AE': '2020-03-27',
            'BE': '2020-03-27',
        },
        'timed_release_date': '2020-03-27T04:00:00Z'
    }


def test_retrieve_release_dates_deal_has_same_territory_dates(
        mock_event):
    """Test retrieve_release_dates where deals have same release dates."""
    context = S3Schema().load(mock_event)
    deals = context.deals
    deals[0].deal_terms[0].start_date_time = '2020-03-25T04:00:00Z'
    result = index.retrieve_release_dates(deals, 'SME')

    assert result == {
        'sales_start_date': '2020-03-25',
        'territory_dates': {},
        'timed_release_date': '2020-03-25T04:00:00Z'
    }


@patch('index.graphql')
def test_replace_product_territory_dates_with_no_dates(mock_graphql):
    """Test replace_product_territory_dates function w/o dates."""
    mock_graphql_conn = mock_graphql.GraphQLConnector()

    index.replace_product_territory_dates(mock_graphql_conn, 45234, {})

    payload = {
        'productId': 45234,
        'territoryDates': []
    }

    mock_graphql_conn.execute.assert_called_with(
        queries.REPLACE_PRODUCT_TERRITORY_DATES,
        {'data': payload}
    )


@patch('index.graphql')
@patch('index.date')
def test_update_video_release_date_previous_day(mock_date,
                                                mock_graphql,
                                                mock_event):
    """Test update_video_release_date function."""
    context = StateMachineSchema().load(mock_event)
    context.product.product_id = 2342
    mock_graphql_conn = mock_graphql.GraphQLConnector()

    date_value = datetime.strptime(
        '2020-03-28', '%Y-%m-%d'
    ).date()
    mock_date.today.return_value = date_value

    index.update_video_release_date(
        mock_graphql_conn, context, '2020-03-27', None)

    mock_graphql_conn.execute.assert_called_with(
        queries.UPDATE_VIDEO_PRODUCT_RELEASE_DATE,
        {
            'data': {
                'update': {
                    'productId': '2342',
                    'originalReleaseDate': '2020-03-27',
                    'releaseDate': '2020-03-28',
                    'newRelease': False
                }
            }
        }
    )


@patch('index.graphql')
@patch('index.date')
def test_update_video_release_date_same_day(mock_date,
                                            mock_graphql,
                                            mock_event):
    """Test update_video_release_date function."""
    context = StateMachineSchema().load(mock_event)
    context.product.product_id = 2342
    mock_graphql_conn = mock_graphql.GraphQLConnector()

    date_value = datetime.strptime(
        '2020-03-28', '%Y-%m-%d'
    ).date()
    mock_date.today.return_value = date_value

    index.update_video_release_date(
        mock_graphql_conn, context, '2020-03-28', None)

    mock_graphql_conn.execute.assert_called_with(
        queries.UPDATE_VIDEO_PRODUCT_RELEASE_DATE,
        {
            'data': {
                'update': {
                    'productId': '2342',
                    'originalReleaseDate': None,
                    'releaseDate': '2020-03-28',
                    'newRelease': True
                }
            }
        }
    )


@patch('index.graphql')
@patch('index.date')
def test_update_video_release_date_next_day(mock_date,
                                            mock_graphql,
                                            mock_event):
    """Test update_video_release_date function."""
    context = StateMachineSchema().load(mock_event)
    context.product.product_id = 2342
    mock_graphql_conn = mock_graphql.GraphQLConnector()

    date_value = datetime.strptime(
        '2020-03-28', '%Y-%m-%d'
    ).date()
    mock_date.today.return_value = date_value

    index.update_video_release_date(
        mock_graphql_conn, context, '2020-03-29', None)

    mock_graphql_conn.execute.assert_called_with(
        queries.UPDATE_VIDEO_PRODUCT_RELEASE_DATE,
        {
            'data': {
                'update': {
                    'productId': '2342',
                    'originalReleaseDate': None,
                    'releaseDate': '2020-03-29',
                    'newRelease': True
                }
            }
        }
    )


"""
    Note, this is a temporary test until we enable pre_order
    functionality properly within the lambda. This is to prevent QA breaking.
    Ignore all instances of pre_order = True deal terms for now.
"""


@pytest.mark.parametrize('test_input,expected', [
    (True, '2020-03-25'),
    (False, '2010-03-25')])
@patch('index.create_blank_rc_json')
@patch('index.logger')
@patch('index.graphql')
@patch('index.update_audio_release_date')
@patch('index.update_product_timed_release')
@patch('index.replace_product_territory_dates')
@patch('index.load_ddex_json')
def test_pre_order_deal_terms_are_ignored(
    mock_load_ddex_json,
        mock_replace_product_territory_dates,
        mock_update_product_timed_release,
        mock_update_product,
        mock_graphql,
        mock_current_logger,
        mock_rc_json,
        test_input,
        expected,
        mock_event):
    """Test that pre_order = True deal terms are ignored."""
    mock_logger = MagicMock(name='info')
    mock_current_logger.return_value = mock_logger

    mock_load_ddex_json.return_value = mock_event
    mock_event['deals'][0]['deal_terms'][2]['pre_order'] = test_input

    index.handler(mock_event, None)

    mock_graphql_conn = MagicMock(name='GraphQLConnector')
    mock_graphql.return_value = mock_graphql_conn

    mock_update_product.assert_called_with(
        mock_graphql.GraphQLConnector(),
        ANY,
        '2020-03-25',
        expected
    )


def test_retrieve_release_dates_early_release_track_deal_not_in_r0(
        mock_preorder_deals):
    """Test where a deal contains an early release track that is not in the R0 deals."""  # noqa
    context = S3Schema().load(mock_preorder_deals)
    deals = context.deals
    return_value = index.retrieve_release_dates(deals, 'SME')
    assert return_value['sales_start_date'] == '2021-06-25'


def test_retrieve_release_dates_early_release_track_deal_not_in_r1(
        mock_preorder_deals):
    """Test where a deal contains an early release track that is not in the R1 deals when."""  # noqa
    context = S3Schema().load(mock_preorder_deals)
    deals = context.deals
    # Remove R0 deal from list
    deals.pop(0)
    deals[0].deal_terms[0].start_date = '2016-01-01'
    return_value = index.retrieve_release_dates(deals, 'SME')
    assert return_value['sales_start_date'] == '2016-01-01'


def test_retrieve_territory_with_differing_dates(mock_event):
    """Test method returns territories where start date differs."""
    context = S3Schema().load(mock_event)
    deal = context.deals[0]
    deal.deal_terms = deal.deal_terms[:1]

    expected_dict = {'AE': '2020-03-27', 'BE': '2020-03-27'}

    rv = index.retrieve_territory_with_differing_dates(deal, '2030-01-01')

    assert rv == expected_dict


def test_retrieve_deal_dates_timed_release(mock_event):
    """Test retrieve_deal_dates returns earliest dates."""
    context = S3Schema().load(mock_event)
    deal = context.deals[0]
    expected_start_date = '2010-03-25'
    expected_timed_date = '2020-03-27T04:00:00Z'

    start_date, timed_date = index.retrieve_deal_dates(deal, 'SME')

    assert start_date == expected_start_date
    assert timed_date == expected_timed_date


def test_retrieve_deal_dates_not_timed_release(mock_event):
    """Test retrieve_deal_dates returns earliest dates."""
    mock_event['deals'][0]['deal_terms'][0]['start_date_time'] =\
        '2020-03-27T04:00:00'
    context = S3Schema().load(mock_event)
    deal = context.deals[0]
    expected_start_date = '2010-03-25'

    start_date, timed_date = index.retrieve_deal_dates(deal, 'SME')

    assert start_date == expected_start_date
    assert timed_date is None


def test_filter_release_deals_r0(mock_preorder_deals):
    """Test filter_release_deals filters out preorder deals."""
    context = S3Schema().load(mock_preorder_deals)
    deals = context.deals

    # R0 deal
    expected_deal = deals[0]
    returned_deal = index.filter_release_deals(deals)

    assert returned_deal == expected_deal


def test_filter_release_deals_r1(mock_preorder_deals):
    """Test filter_release_deals filters out preorder deals."""
    context = S3Schema().load(mock_preorder_deals)
    deals = context.deals
    # Remove R0 deal from list
    deals.pop(0)

    # R1 deal
    expected_deal = deals[0]
    returned_deal = index.filter_release_deals(deals)

    assert returned_deal == expected_deal


def test_filter_release_deals_fallback(
        mock_preorder_deals):
    """Test retrieve_release_dates where there is no R0 or R1 deal listed."""
    context = S3Schema().load(mock_preorder_deals)
    # Omit R0 and R1 as first two entries
    deals = context.deals[2:]

    # it should take the first deal in the list even if it is not R0 or R1
    expected_deal = deals[0]

    returned_deal = index.filter_release_deals(deals)
    assert returned_deal == expected_deal


def test_filter_release_deals_fails(
        mock_preorder_deals):
    """Test retrieve_release_dates where there is deal listed with terms."""
    context = S3Schema().load(mock_preorder_deals)
    # There are no deals with terms.
    deals = []
    for deal in context.deals:
        deal.deal_terms = []
        deals.append(deal)

    with pytest.raises(ValueError):
        index.retrieve_release_dates(deals, 'SME')


def test_filter_preorder_deals(mock_preorder_deals):
    """Test filter_preorder_deals filters pre-order deal terms."""
    s3_data = S3Schema().load(mock_preorder_deals)
    deal = s3_data.deals[0]

    expected_deal_terms = []
    # We know first and last terms are pre_order = False.
    expected_deal_terms.append(deal.deal_terms[0])
    expected_deal_terms.append(deal.deal_terms[4])

    returned_terms = index.filter_preorder_deals(deal)

    assert returned_terms.deal_terms == expected_deal_terms


def test_filter_preorder_deals_throws_exception(mock_preorder_deals):
    """Test filter_preorder_deals throws exception with no deal term."""
    s3_data = S3Schema().load(mock_preorder_deals)
    # This ensures that all hardcoded preorders are now True.
    deal = s3_data.deals[0]
    deal.deal_terms[0].pre_order = True
    deal.deal_terms[4].pre_order = True

    with pytest.raises(ValueError):
        index.filter_preorder_deals(deal)