"""Tests digital projections logic."""

from oto import response

from sales_goals.logic import digital_projections
from sales_goals.models import digital_projections as digital_projections_model
from sales_goals.models import ows_product_digital, ows_project


def test_get_digital_projections_by_product_id_removes_internal(
        mocker):
    """Test get digital projections."""
    mocker.patch.object(
        digital_projections_model, 'get_projections_by_product_id',
        return_value=response.Response(message={'internal_note': 'hi'}))

    result = digital_projections.get_digital_projections_by_product_id(
        1, 'alw:doo')
    assert result.message == {}


def test_get_digital_projections_by_product_id_failure(
        mocker):
    """Test get digital projections failure."""
    mocker.patch.object(
        digital_projections_model, 'get_projections_by_product_id',
        return_value=response.Response(message={}, status=404))

    result = digital_projections.get_digital_projections_by_product_id(
        1, 'alw:doo')
    assert result.message == {}


def test_dataload_digital_product_projections(mocker):
    """Test dataload digital product projections."""
    product_ids = [92949, 92950, 92951, 92952]
    expected_result = [
        {
            'internal_note': 'abc',
            'product_id': 92949,
            'projections': [
                {
                    'priority': 'a',
                    'product_id': 92949,
                    'territory_id': 1
                },
                {
                    'priority': 'b',
                    'product_id': 92949,
                    'territory_id': 2
                }
            ]
        },
        {
            'internal_note': 'cde',
            'product_id': 92950,
            'projections': [{
                'priority': 'b',
                'product_id': 92950,
                'territory_id': 3
            }]
        },
        {
            'internal_note': 'fgh',
            'product_id': 92951,
            'projections': [{
                'priority': 'a',
                'product_id': 92951,
                'territory_id': 4
            }]
        },
        {
            'internal_note': None,
            'product_id': 92952,
            'projections': None
        }
    ]

    mocker.patch.object(
        digital_projections_model, 'dataload_digital_product_projections',
        return_value=response.Response(message=[
            {
                'internal_note': 'abc',
                'product_id': 92949,
                'projections': [
                    {
                        'territory_id': 1,
                        'product_id': 92949,
                    },
                    {
                        'territory_id': 2,
                        'product_id': 92949,
                    }
                ],
            },
            {
                'internal_note': 'fgh',
                'product_id': 92951,
                'projections': [{
                    'territory_id': 4,
                    'product_id': 92951,
                }],
            },
            {
                'internal_note': 'cde',
                'product_id': 92950,
                'projections': [{
                    'territory_id': 3,
                    'product_id': 92950,
                }],
            },
        ]))

    mocker.patch.object(
        ows_product_digital, 'dataload_marketing_priorities',
        return_value=response.Response(message=[
            {
                'id': 1,
                'upc': 829410910552,
                'priority': 'a',
                'country_id': 1,
                'release_id': 92949
            },
            {
                'id': 2,
                'upc': 829410750950,
                'priority': 'b',
                'country_id': 2,
                'release_id': 92949
            },
            {
                'id': 3,
                'upc': 829410910553,
                'priority': 'b',
                'country_id': 3,
                'release_id': 92950
            },
            {
                'id': 4,
                'upc': 829410750954,
                'priority': 'a',
                'country_id': 4,
                'release_id': 92951
            }
        ]))

    result = digital_projections.dataload_digital_product_projections(
        product_ids)

    assert result.message == expected_result


def test_upsert_global_projections(
        mocker):
    """Test upserting a global projection."""
    mocker.patch.object(
        digital_projections_model, 'upsert_global_projections',
        return_value=1)

    result = digital_projections.upsert_global_projections(1, {}, 'alw:1')
    assert result == 1


def test_upsert_territory_projections(
        mocker):
    """Test upserting a territory projection."""
    mocker.patch.object(
        digital_projections_model, 'upsert_territory_projections',
        return_value=1)

    result = digital_projections.upsert_territory_projections(1, {}, 'alw:1')
    assert result == 1


def test_get_digital_projections_by_product_id_for_oa(
        mocker, mock_get_marketing_priority):
    """Test get digital projections."""
    mocker.patch.object(
        digital_projections_model, 'get_projections_by_product_id',
        return_value=response.Response(
            message={
                'product_id': 1,
                'internal_note': 'hi',
                'projections': [
                    {'product_id': 1, 'territory_id': 1},
                    {'product_id': 1, 'territory_id': 10002},
                ]}
        ))

    result = digital_projections.get_digital_projections_by_product_id(
        1, 'oa:doo')
    assert result.message == {
        'product_id': 1,
        'internal_note': 'hi',
        'projections': [
            {'priority': 'a', 'product_id': 1, 'territory_id': 1},
            {'product_id': 1, 'territory_id': 10002}
        ]
    }


def test_upsert_territory_projections_for_oa(
        mocker, mock_set_marketing_priority):
    """Test upserting a territory projection."""
    mocker.patch.object(
        digital_projections_model, 'upsert_territory_projections',
        return_value=1)

    mocker.patch.object(
        digital_projections, 'get_digital_projections_by_product_id',
        return_value=response.Response({
            'internal_note': 'test',
            'projections': [
                {'id': 123, 'priority': 'a', 'territory_id': 1},
                {'id': 567, 'territory_id': 10002}
            ]
        })
    )

    mocker.patch.object(
        digital_projections, 'delete_territory_projection')

    mocker.patch.object(
        digital_projections, 'clear_project_marketing_priorities')

    data = {'items': [
        {'priority': 'a', 'territory_id': 1}
    ]}

    result = digital_projections.upsert_territory_projections(
        1, data, 'oa:1', delete=True)

    assert result == 1

    digital_projections.delete_territory_projection.assert_called_with(1, 567)


def test_delete_territory_projection(mocker):
    """Test deleting a territory projection."""
    delete_response = response.Response(
        message=digital_projections_model.DigitalProjectionByCountry(
            country_id=1)
    )
    mocker.patch.object(
        digital_projections_model, 'delete_territory_projection',
        return_value=delete_response)

    mocker.patch.object(
        ows_product_digital, 'delete_marketing_priority',
        return_value=1)

    result = digital_projections.delete_territory_projection(1, 1)
    assert result == delete_response


def test_upsert_project_territory_projections_for_oa(mocker):
    """Test upserting a project territory projection."""
    data = {'items': [
        {'priority': 'a', 'territory_id': 1}
    ]}
    mkt_priority_obj = {
        'internal_note': 'test',
        'projections': [
            {'id': 123, 'priority': 'a', 'territory_id': 1},
            {'id': 567, 'territory_id': 10002}
        ]
    }

    mocker.patch.object(
        ows_project, 'set_project_marketing_priority',
        return_value=1)

    mocker.patch.object(
        digital_projections, 'clear_project_product_marketing_priorities')

    mocker.patch.object(
        digital_projections, 'clear_project_product_territory_projections')

    mocker.patch.object(
        digital_projections, 'get_territory_priorities_for_project',
        return_value=response.Response(message=mkt_priority_obj))

    mocker.patch.object(
        digital_projections, 'delete_project_territory_projection')

    result = digital_projections.upsert_project_territory_projections(
        1, data, 'oa:1', delete=True)

    assert result.message == mkt_priority_obj

    digital_projections.delete_project_territory_projection.assert_called_with(1, 567)


def test_delete_project_territory_projections(mocker):
    """Test upserting a project territory projection."""

    mocker.patch.object(
        ows_project, 'delete_project_marketing_priority',
        return_value=1)

    result = digital_projections.delete_project_territory_projection(1, 1)
    assert result == 1


def test_get_project_territory_projections_for_oa(mocker):
    """Test upserting a project territory projection."""
    mocker.patch.object(
        ows_project, 'get_project_marketing_priorities',
        return_value=response.Response(
            message=[
                {'id': 123, 'priority': 'a', 'territory_id': 1},
                {'id': 567, 'territory_id': 10002}
            ]
        ))
    mocker.patch.object(
        digital_projections_model, 'get_project_marketing_projection',
        return_value={'internal_note': 'test'})

    result = digital_projections.get_territory_priorities_for_project(1)
    assert result.message == {
        'internal_note': 'test',
        'projections': [
            {'id': 123, 'priority': 'a', 'territory_id': 1},
            {'id': 567, 'territory_id': 10002}
        ]
    }


def test_dataload_project_marketing_priorities(mocker):
    """Test dataload project territory priorities."""
    project_ids = [1, 2, 3, 4]
    expected_result = [
        {
            'internal_note': 'note 1',
            'project_id': 1,
            'projections': [
                {
                    'priority': 'a',
                    'country_id': 1,
                    'project_id': 1
                },
                {
                    'priority': 'b',
                    'country_id': 2,
                    'project_id': 1
                },
            ],
        },
        {
            'internal_note': 'note 2',
            'project_id': 2,
            'projections': [{
                'priority': 'b',
                'country_id': 3,
                'project_id': 2
            }],
        },
        {
            'internal_note': 'note 3',
            'project_id': 3,
            'projections': [],
        },
        {
            'internal_note': None,
            'project_id': 4,
            'projections': None
        }
    ]

    mocker.patch.object(
        digital_projections_model, 'dataload_project_marketing_projection',
        return_value=response.Response(message=[
            {
                'internal_note': 'note 1',
                'project_id': 1,
            },
            {
                'internal_note': 'note 3',
                'project_id': 3,
            },
            {
                'internal_note': 'note 2',
                'project_id': 2,
            },
        ]))

    mocker.patch.object(
        ows_project, 'dataload_project_marketing_priorities',
        return_value=response.Response(message=[
            {
                'priority': 'a',
                'country_id': 1,
                'project_id': 1
            },
            {
                'priority': 'b',
                'country_id': 2,
                'project_id': 1
            },
            {
                'priority': 'b',
                'country_id': 3,
                'project_id': 2
            }
        ]))

    result = digital_projections.dataload_project_marketing_priorities(
        project_ids)

    assert result.message == expected_result


def test_upsert_project_marketing_projections(
        mocker):
    """Test upserting a project marketing projection."""
    projection = {'internal_note': 'test'}
    mocker.patch.object(
        digital_projections_model, 'upsert_project_marketing_projection',
        return_value=response.Response(message=projection, status=201))

    result = digital_projections.upsert_global_projections_for_project(1, projection, 'oa:1')
    assert result.message == projection
    assert result.status == 201


def test_clear_project_product_territory_projections(
        mocker):
    """Test clear_project_product_territory_projections."""
    product_id = 123
    mocker.patch.object(
        ows_project, 'get_products_for_project',
        return_value={'items': [{'product_id': product_id}]})

    mock_clear_product_territory_projections = mocker.patch.object(
        digital_projections_model, 'clear_product_territory_projections')

    digital_projections.clear_project_product_territory_projections(456)

    mock_clear_product_territory_projections.assert_called_with(product_id)


def test_clear_project_product_marketing_priorities(
        mocker):
    """Test clear_project_product_marketing_priorities."""
    product_id = 123
    mocker.patch.object(
        ows_project, 'get_products_for_project',
        return_value={'items': [{'product_id': product_id}]})

    mock_delete_marketing_priority_for_product = mocker.patch.object(
        ows_product_digital, 'delete_marketing_priority_for_product')

    digital_projections.clear_project_product_marketing_priorities(456)

    mock_delete_marketing_priority_for_product.assert_called_with(product_id)


def test_clear_project_marketing_priorities(
        mocker):
    """Test clear_project_marketing_priorities."""
    project_id = 123
    mocker.patch.object(
        ows_product_digital, 'get_project_for_product',
        return_value=project_id)

    mock_delete_project_marketing_priority_in_bulk = mocker.patch.object(
        ows_project, 'delete_project_marketing_priority_in_bulk')

    digital_projections.clear_project_marketing_priorities(456)

    mock_delete_project_marketing_priority_in_bulk.assert_called_with(project_id)


def test_set_marketing_priority_for_product(
        mocker):
    """Test upserting a territory projection."""
    products = {'items': [{'product_id': 1}]}
    mocker.patch.object(
        ows_product_digital, 'get_project_for_product',
        return_value=1)

    mocker.patch.object(
        ows_project, 'get_project_marketing_priorities',
        return_value=response.Response(message={'internal_note': 'hi'}))

    mocker.patch.object(
        ows_project, 'get_products_for_project',
        return_value=products)

    mocker.patch.object(
        digital_projections_model, 'get_project_marketing_projection',
        return_value={'internal_note': 'test'})

    mocker.patch.object(
        digital_projections, 'clear_project_marketing_priorities')

    mocker.patch.object(
        digital_projections, 'upsert_territory_projections',
        return_value=1)

    mocker.patch.object(
        digital_projections_model, 'upsert_global_projections',
        return_value={'internal_note': 'test'})

    result = digital_projections.set_marketing_priority_for_product(1, {}, 'alw:1')
    assert result == 1