from copy import deepcopy
import decimal
import json
from unittest.mock import Mock
from unittest.mock import patch

from moto import mock_aws
import boto3
from oto import response

from masters_registry.constant import field_const
from masters_registry.constant import opcode_const
from masters_registry.logic import masters_registry
from masters_registry.models import ownership
from masters_registry.models import yt_ownership
from tests import test_utils
from tests.helpers import patches

from masters_registry.connectors.dynamodb import client as outside_dynamodb_client
dynamodb_resource = boto3.resource("dynamodb")


@patch(
    'masters_registry.models.ownership.get_track',
    new=patches.ownership_get_track)
@patch(
    'masters_registry.models.ownership.get_tracks',
    new=lambda tuids: response.Response({
        111111: {'vendor_id': 222},
        123456: {'vendor_id': 222}}))
@patch(
    'masters_registry.models.ows_territories.get_territories',
    new=patches.ows_territories_get_territories_patch)
@patch(
    'masters_registry.models.ownership.get_upc_by_tuid',
    new=patches.ownership_get_upc_by_tuid_patch)
@patch(
    'masters_registry.models.ows_carveouts.get_dms_carveout_for_upc',
    new=patches.ows_carveouts_get_dms_carveout_for_upc_not_carved_out_patch)
@patch(
    'masters_registry.logic.masters_registry.'
    '_check_conflicts_with_the_same_label',
    new=lambda *args: response.Response())
@patch(
    'masters_registry.models.yt_ownership.send_message',
    new=Mock())
@mock_aws
def test_add_tuid_for_territory_internal_conflict_enabled(
        feature_engine, client, valid_headers,
        setup_masters_active_table, seed_masters_active_table,
        setup_new_audit_table):
    """Expect new tuid to be appended to existing list of tuid dicts."""
    from moto.core import patch_client, patch_resource
    patch_client(outside_dynamodb_client)
    patch_resource(dynamodb_resource)

    ownership_info = patches.ownership_get_ownership_patch('').message
    setup_masters_active_table(dynamodb_resource.meta.client)
    seed_masters_active_table(
        dynamodb_resource.meta.client, item=ownership_info)
    setup_new_audit_table(dynamodb_resource.meta.client)
    ignore_fields = ['timestamp', 'updated_timestamp']

    tuid = 444
    isrc = 'US4R30920517'
    territories = ['AF']
    user = '1234'
    correlation_id = 'test'

    data = {
        field_const.ISRC: isrc,
        field_const.TUID: tuid,
        field_const.TERRITORIES: territories
    }
    valid_headers['Content-Type'] = 'application/json'
    valid_headers['Correlation-Id'] = correlation_id
    res = client.post(
        '/ownership', headers=valid_headers, data=json.dumps(data))

    audit_records = ownership.get_ownership_audit(isrc).message

    expected_auidt_records = [
        {
            'opcode': opcode_const.ADD,
            'territories': {'AF': decimal.Decimal('444')},
            'isrc': isrc,
            'user': user,
            'correlation_id': correlation_id,
        },
        {
            'opcode': opcode_const.CONFLICT_CREATED,
            'source': field_const.MANUAL_EDIT_ISRC,
            'territories': {'AF': decimal.Decimal('444')},
            'conflict': {
                'status': opcode_const.CONFLICT_CREATED,
                'conflicting_tuid': [
                    decimal.Decimal('444'),
                    decimal.Decimal('111111')
                ]
            },
            'isrc': isrc,
            'user': user,
            'correlation_id': correlation_id,
        }
    ]

    for (i, expected_record) in enumerate(expected_auidt_records):
        assert test_utils.equal_dicts(
            audit_records[i], expected_record, ignore_fields)

    expected_ownership_record = deepcopy(ownership_info)
    expected_territories = expected_ownership_record[field_const.TERRITORIES]
    expected_territories['AF'] = [expected_territories['AF'], {'tuid': tuid}]
    expected_ownership_record[field_const.TERRITORIES] = expected_territories

    ownership_record = ownership.get_ownership(isrc).message
    assert test_utils.equal_dicts(
        expected_ownership_record, ownership_record, ignore_fields)

    track_info = patches.ownership_get_track(tuid).message
    expected_track = {
        field_const.TUID: tuid,
        field_const.VENDOR_NAME: track_info[field_const.VENDOR_NAME],
        field_const.VENDOR_ID: track_info[field_const.VENDOR_ID],
        field_const.ARTIST_NAME: track_info[field_const.ARTIST_NAME],
        field_const.TRACK_NAME: track_info[field_const.TRACK_NAME],
        field_const.UPC: track_info[field_const.UPC],
        field_const.RELEASE_NAME: track_info[field_const.RELEASE_NAME],
        field_const.TERRITORIES: territories
    }
    assert json.loads(res.data.decode()) == expected_track

    territories = set(ownership_info[field_const.TERRITORIES].keys())
    yt_ownership.send_message.assert_called_with(
        isrc,
        territories,
        correlation_id
    )


@patch(
    'masters_registry.logic.masters_registry.add_tuid_for_territory',
    new=Mock(return_value=response.Response()))
def test_add_tuid_for_territory_normalizes_orchard_user_id(
        client, feature_engine):
    """Expect to call logic layer with normalized orchard_user_id."""
    headers = {
        'Orchard-User-Id': '123',
        'Correlation-Id': 'test',
        'Content-Type': 'application/json'
    }
    tuid = 1
    isrc = 'QA1234567890'
    territories = ['AF']
    data = {
        'tuid': tuid,
        'isrc': isrc,
        'territories': territories
    }
    result = client.post(
        '/ownership', headers=headers, data=json.dumps(data))

    assert result.status_code == 200
    masters_registry.add_tuid_for_territory.assert_called_with(
        tuid, isrc, territories, headers['Correlation-Id'], '123')