"""Tests for determining internal conflicts."""
from unittest.mock import patch

from oto import response
import pytest

from masters_registry.constant import field_const
from masters_registry.constant import opcode_const
from masters_registry.logic import conflicts
from tests.helpers import patches


def test_determine_conflict(ownership_with_conflict):
    """Assert when there is a conflict in ownership record."""
    result = conflicts.determine_conflict(
        ownership_with_conflict['territories'])
    assert result['status'] == opcode_const.CONFLICT_CREATED
    assert sorted(result['conflicting_tuid']) == sorted([222, 333])


def test_determine_conflict_no_conflict(ownership_without_conflict):
    """Assert when there is no conflict in ownership record."""
    result = conflicts.determine_conflict(
        ownership_without_conflict['territories'])
    assert result == {}


def test_determine_resolved_conflict(
        ownership_with_conflict, ownership_without_conflict):
    """Test determine when a conflict was resolved."""
    result = conflicts.determine_resolved_conflict(
        ownership_with_conflict['territories'],
        ownership_without_conflict['territories'])
    assert result['status'] == opcode_const.CONFLICT_RESOLVED
    assert result['conflicting_tuid'] == []
    assert result['resolved'] == 1


def test_determine_partially_resolved_conflict(
        ownership_with_conflict, ownership_with_two_conflicts):
    """Test determine when one of a number of conflicts was resolved."""
    result = conflicts.determine_resolved_conflict(
        ownership_with_two_conflicts['territories'],
        ownership_with_conflict['territories'])
    assert result['status'] == opcode_const.CONFLICT_RESOLVED
    assert result['conflicting_tuid'] == [333, 222]
    assert result['resolved'] == 1


@pytest.fixture
def ownership_info():
    return {
        'territories': {
            'CA': [{'tuid': 222}, {'tuid': 12345}],
            'QA': [{'tuid': 321}, {'tuid': 123456}],
            'IT': {'tuid': 222},
            'MX': [{'tuid': 12345}],
            'DE': [{'tuid': 321}]
        }
    }


@patch(
    'masters_registry.models.ownership.get_tracks',
    new=patches.ownership_get_tracks_patch)
@pytest.mark.parametrize('territories,expected_result', [
    (['SE', 'PT'], []),
    (['MX', 'PT'], []),
    (['MX', 'PT', 'CA', 'IT'], ['CA', 'IT']),
    (['SE', 'PT', 'DE'], []),
])
def test_check_conflicts_with_the_same_label(
        territories, expected_result, ownership_info):
    """Test check_conflicts_with_the_same_label"""
    tuid = 321
    result = conflicts.check_conflicts_with_the_same_label(
        tuid, territories, ownership_info)
    assert set(result) == set(expected_result)


def test_split_isrc_territories_by_internal_conflict():
    """Expect territories that have internal conflict to be separated."""
    isrc_item = {
        'isrc': 'QA123',
        'territories': {'AF': [{'tuid': 1}, {'tuid': 2}], 'AD': [{'tuid': 1}]}
    }

    territories, conflicting_territories = (
        conflicts._split_isrc_territories_by_internal_conflict(isrc_item))

    expected_territories = ['AD']
    expected_conflicting_territories = ['AF']

    assert territories == expected_territories
    assert conflicting_territories == expected_conflicting_territories


def test_split_isrc_territories_by_internal_conflict_handles_old_format():
    """Expect to handle territory record in old format."""
    isrc_item = {
        'isrc': 'QA123',
        'territories': {'AF': [{'tuid': 1}], 'AZ': {'tuid': 1}}
    }
    territories, conflicting_territories = (
        conflicts._split_isrc_territories_by_internal_conflict(isrc_item))

    assert sorted(territories) == ['AF', 'AZ']
    assert conflicting_territories == []


def test_filter_lock_territories_without_conflict():
    """Dict with separate ISRCs/territories which do/don't have conflict."""
    isrc_item = {
        'isrc': 'QA123',
        'territories': {'AF': [{'tuid': 1}, {'tuid': 2}], 'AD': [{'tuid': 1}]}
    }
    another_isrc_item = {
        'isrc': 'QA456',
        'territories': {'AF': [{'tuid': 1}], 'AX': [{'tuid': 1}]}
    }

    result = conflicts.filter_lock_territories_without_conflict(
        [isrc_item, another_isrc_item], ['AX'])
    result['accepted_isrcs']['QA456'] = sorted(
        result['accepted_isrcs']['QA456'])
    expected = {
        'accepted_isrcs': {'QA123': ['AD'], 'QA456': ['AF', 'AX']},
    }

    assert result == expected


def test_filter_lock_territories_with_conflict():
    """Dict with separate ISRCs/territories which do/don't have conflict."""
    isrc_item = {
        'isrc': 'QA123',
        'territories': {'AF': [{'tuid': 1}, {'tuid': 2}], 'AD': [{'tuid': 1}]}
    }
    another_isrc_item = {
        'isrc': 'QA456',
        'territories': {'AF': [{'tuid': 1}], 'AX': [{'tuid': 1}]}
    }

    result = conflicts.filter_lock_territories_without_conflict(
        [isrc_item, another_isrc_item], ['AF'])
    result['accepted_isrcs']['QA456'] = sorted(
        result['accepted_isrcs']['QA456'])
    expected = {
        'accepted_isrcs': {'QA123': ['AD'], 'QA456': ['AF', 'AX']},
        'conflicting_isrcs': {'QA123': ['AF']}
    }

    assert result == expected


def test_get_conflicts():
    """Test get_conflicts function"""
    ownership_territories = {
        'CA': [{'tuid': 222}, {'tuid': 333}, {'tuid': 555}],
        'PT': [{'tuid': 222}, {'tuid': 444}],
        'IT': [{'tuid': 222}],
        'QA': {'tuid': 222},
    }

    expected_conflicts = [
        (555, 222),
        (555, 333),
        (333, 222),
        (444, 222),
    ]

    result = conflicts.get_conflicts(ownership_territories)
    assert sorted(result) == sorted(expected_conflicts)


def conflicts_history_audit_patch(_):
    ownership_audit = [
        {
            field_const.OPCODE: opcode_const.LOCK,
            field_const.TIMESTAMP: 1523160000000,
            field_const.TERRITORIES: ['IT'],
            field_const.LOCK_REASON: 'Lorem Ipsum'
        },

        {
            field_const.OPCODE: opcode_const.CONFLICT_CREATED,
            field_const.TIMESTAMP: 1523250000000,
            field_const.TERRITORIES: {'CA': 222},
            field_const.CONFLICT: {
                'conflicting_tuid': [222, 333],
            },

        },
        {
            field_const.OPCODE: opcode_const.CONFLICT_CREATED,
            field_const.TIMESTAMP: 1523400000000,
            field_const.TERRITORIES: {'QA': 444},
            field_const.CONFLICT: {
                'conflicting_tuid': [333, 444],
            },

        },
        {
            field_const.TERRITORIES: {'QA': 333},
            field_const.OPCODE: opcode_const.CONFLICT_RESOLVED,
            field_const.TIMESTAMP: 1523300000000,
            field_const.CONFLICT: {
                field_const.CONFLICTING_TUID: [333, 222],
            },
        },
        {
            field_const.OPCODE: opcode_const.CONFLICT_CREATED,
            field_const.TIMESTAMP: 1523200000000,
            field_const.TERRITORIES: {'FR': 222},
            field_const.CONFLICT: {
                'conflicting_tuid': [222, 333],
            },
        },
        {
            field_const.OPCODE: opcode_const.CONFLICT_CREATED,
            field_const.TIMESTAMP: 1523100000000,
            field_const.TERRITORIES: {'QA': 333},
            field_const.CONFLICT: {
                'conflicting_tuid': [333, 444],
            },

        },
    ]
    return response.Response(message=ownership_audit)


@patch(
    'masters_registry.models.ownership.get_ownership_audit',
    new=conflicts_history_audit_patch)
def test_get_conflicts_history_for_ownership():
    """Tests get_conflicts_history_for_ownership function"""
    ownership_info = {
        field_const.ISRC: 'US4R30920517',
        field_const.LOCKED_TERRITORIES: {},
        field_const.TERRITORIES: {
            'CA': [{'tuid': 222}, {'tuid': 333}],
            'FR': [{'tuid': 222}, {'tuid': 333}],
            'PT': [{'tuid': 222}],
            'QA': [{'tuid': 333}, {'tuid': 444}],
        }
    }

    expected_history = {
        '333V222': {
            field_const.DATETIME: '2018-04-08T15:06:40',  # 1523200000000
            field_const.CREATED_BY: 333
        },
        '444V333': {
            field_const.DATETIME: '2018-04-10T22:40:00',  # 1523400000000
            field_const.CREATED_BY: 444
        }
    }

    assert conflicts.get_conflicts_history_for_ownership(ownership_info)

    conflicts_history = ownership_info[field_const.CONFLICTS_HISTORY]
    assert conflicts_history.keys() == expected_history.keys()

    for key, value in conflicts_history.items():
        assert value == expected_history[key]