"""Test label model class."""

from unittest.mock import MagicMock, patch

import pytest

from permissions.connectors import mysql, neo4j
from permissions.constants import constants
from permissions.exceptions.incomplete_result_error import IncompleteResultError
from permissions.models import label
from tests.unit.conftest import get_session_mock


def test_no_db_records_found_returns_empty():
    """Test get_label_resources when no db records found."""
    session_mock = get_session_mock([])
    with patch.object(mysql, 'db_read_session', return_value=session_mock):
        actual = label.get_label_resources(constants.LABELPROFILE, 123)
        assert actual
        assert actual.message == []


def test_non_label_profile_returns_empty():
    """Test get_label_resources for a non-label profile."""
    session_mock = get_session_mock([(1, 2), (3, 4)])
    with patch.object(mysql, 'db_read_session', return_value=session_mock):
        actual = label.get_label_resources(constants.ARTISTPROFILE, 123)
        assert actual
        assert actual.message == []


def test_label_profile_returns_vendors():
    """Test get_label_resources when the database returns vendors."""
    vendor_ids = [1, 2, 3]
    session_mock = get_session_mock(list(map(lambda vendor_id: [vendor_id, None], vendor_ids)))
    with patch.object(mysql, 'db_read_session', return_value=session_mock):
        actual = label.get_label_resources(constants.LABELPROFILE, 123)
        assert actual
        assert actual.message == list(
            map(
                lambda vendor_id: {'type': constants.VENDOR_RESOURCE_TYPE, 'id': vendor_id},
                vendor_ids,
            )
        )


def test_label_profile_returns_subaccounts():
    """Test get_label_resources when the database returns subaccounts."""
    subaccount_ids = [[1, 2], [3, 4]]
    session_mock = get_session_mock(list(map(lambda ids: [ids[0], ids[1]], subaccount_ids)))
    with patch.object(mysql, 'db_read_session', return_value=session_mock):
        actual = label.get_label_resources(constants.LABELPROFILE, 123)
        assert actual
        assert actual.message == list(
            map(
                lambda ids: {
                    'type': constants.SUBACCOUNT_RESOURCE_TYPE,
                    'id': ids[1],
                    'vendor_id': ids[0],
                },
                subaccount_ids,
            )
        )


@pytest.mark.parametrize('resource_type', ['ArtistInfo', 'LabelParticipant'])
def test_get_labels_for_artist_id(resource_type, make_graph_node):
    """Test get_labels_for_artist_id when label is found."""
    data = make_graph_node(node_id=100, labels=('Label',))
    session_mock = get_session_mock([{'label': data}])

    with patch.object(neo4j, 'db_session', return_value=session_mock):
        actual = label.get_labels_for_artist_id(resource_type, 12345)
        assert actual
        assert actual.message == {'type': 'Label', 'id': 100}
        args = session_mock.__enter__().run.call_args
        assert f'MATCH (l:Label)-[]->(r:{resource_type})' in args[0][0]
        assert 'r.id = $artist_id' in args[0][0]


def test_get_labels_for_artist_id_no_result():
    """Test get_labels_for_artist_id when no label is found."""
    session_mock = get_session_mock([])
    with patch.object(neo4j, 'db_session', return_value=session_mock):
        actual = label.get_labels_for_artist_id('labelParticipant', 200)
        assert not actual
        assert actual.errors['message'] == 'Label not found.'


def test_get_vend_contact_user():
    """Test get_vend_contact_user."""
    session_mock = MagicMock()
    result_mock = MagicMock()
    session_mock.execute.return_value = result_mock
    result_mock.fetchone.return_value = {'id': 1234, 'active': 'Y', 'all_roles': '4'}
    auth0_id = 'foo'
    vendor_id = 7123
    subaccount_id = None
    with patch.object(mysql, 'db_session', return_value=session_mock):
        actual = label.get_vend_contact_user(session_mock, auth0_id, vendor_id, subaccount_id)
        assert actual == {'id': 1234, 'active': 'Y', 'all_roles': {4}}


def test_get_vend_contact_with_auth0_user_id():
    """Test get_vend_contact_with_auth0_user_id."""
    session_mock = MagicMock()
    result_mock = MagicMock()
    session_mock.execute.return_value = result_mock
    result_mock.fetchall.return_value = [
        {'id': 1234, 'active': 'Y', 'all_roles': '4', 'vendor_id': 7123, 'subaccount_id': None},
        {'id': 5678, 'active': 'Y', 'all_roles': '2', 'vendor_id': 4444, 'subaccount_id': None},
    ]
    auth0_id = 'foo'
    vendor_id = 7123
    subaccount_id = None
    with patch.object(mysql, 'db_session', return_value=session_mock):
        actual = label.get_vend_contact_with_auth0_user_id(
            session_mock, auth0_id, vendor_id, subaccount_id
        )
        assert actual == (
            {'id': 1234, 'active': 'Y', 'all_roles': {4}, 'vendor_id': 7123, 'subaccount_id': None},
            None,
        )


def test_get_vend_contact_with_auth0_user_id_for_subaccount():
    """Test get_vend_contact_with_auth0_user_id."""
    session_mock = MagicMock()
    result_mock = MagicMock()
    session_mock.execute.return_value = result_mock
    result_mock.fetchall.return_value = [
        {'id': 1234, 'active': 'Y', 'all_roles': '4', 'vendor_id': 7123, 'subaccount_id': 12345},
        {'id': 1234, 'active': 'Y', 'all_roles': '3,5', 'vendor_id': 7123, 'subaccount_id': 898989},
        {'id': 5678, 'active': 'Y', 'all_roles': '2', 'vendor_id': 4444, 'subaccount_id': None},
    ]
    auth0_id = 'foo'
    vendor_id = 7123
    subaccount_id = 898989
    with patch.object(mysql, 'db_session', return_value=session_mock):
        actual = label.get_vend_contact_with_auth0_user_id(
            session_mock, auth0_id, vendor_id, subaccount_id
        )
        assert actual == (
            {
                'id': 1234,
                'active': 'Y',
                'all_roles': {3, 5},
                'vendor_id': 7123,
                'subaccount_id': 898989,
            },
            None,
        )


def test_get_vend_contact_with_auth0_user_id_for_d3_and_subaccount():
    """Test get_vend_contact_with_auth0_user_id."""
    session_mock = MagicMock()
    result_mock = MagicMock()
    session_mock.execute.return_value = result_mock
    result_mock.fetchall.return_value = [
        {'id': 1234, 'active': 'Y', 'all_roles': '4', 'vendor_id': 7123, 'subaccount_id': 12345}
    ]
    auth0_id = 'foo'
    vendor_id = 7123
    subaccount_id = None
    with patch.object(mysql, 'db_session', return_value=session_mock):
        actual = label.get_vend_contact_with_auth0_user_id(
            session_mock, auth0_id, vendor_id, subaccount_id
        )
        assert actual == ([], None)


def test_get_vend_contact_with_auth0_user_id_for_new_user():
    """Test get_vend_contact_with_auth0_user_id."""
    session_mock = MagicMock()
    result_mock = MagicMock()
    session_mock.execute.return_value = result_mock
    result_mock.fetchall.return_value = []
    auth0_id = 'foo'
    vendor_id = 7123
    subaccount_id = 12345
    with patch.object(mysql, 'db_session', return_value=session_mock):
        actual = label.get_vend_contact_with_auth0_user_id(
            session_mock, auth0_id, vendor_id, subaccount_id
        )
        assert actual == ([], 'Y')


def test_update_auth0_primary():
    """Test update_auth0_primary."""
    session_mock = MagicMock()
    auth0_data = {
        'auth0_id1': {'vend_contact_id': 1344},
        'auth0_id2': {'vend_contact_id': 5566},
    }

    with patch.object(mysql, 'db_session', return_value=session_mock):
        label.update_auth0_primary(auth0_data)
        assert session_mock.__enter__().execute.call_count == 4  # 2 queries each


def test_create_full_vend_contact_user():
    """Test create_full_vend_contact_user."""
    fetch_mock = MagicMock()
    fetch_mock.fetchone.return_value = {'new': 'vc_user'}
    session_mock = MagicMock()
    session_mock.execute.side_effect = [{'success': 'insert'}, fetch_mock]
    session_mock.execute.return_value = {'success': 'insert'}

    auth0_id = 'foo'
    vendor_id = 7123
    subaccount_id = None
    auth0_primary = None
    with patch.object(mysql, 'db_session', return_value=session_mock):
        actual = label.create_full_vend_contact_user(
            session_mock,
            auth0_id,
            'foo',
            'foo@theorchard.io',
            {4},
            vendor_id,
            auth0_primary,
            False,
            subaccount_id,
        )
        assert actual == {'new': 'vc_user'}


def test_create_full_vend_contact_user_with_master_contact():
    """Test create_full_vend_contact_user."""
    fetch_mock = MagicMock()
    fetch_mock.fetchone.return_value = {'new': 'vc_user'}
    session_mock = MagicMock()
    session_mock.execute.side_effect = [{'success': 'insert'}, fetch_mock]
    session_mock.execute.return_value = {'success': 'insert'}

    auth0_id = 'foo'
    vendor_id = 7123
    subaccount_id = None
    auth0_primary = None
    master_contact = True
    with patch.object(mysql, 'db_session', return_value=session_mock):
        actual = label.create_full_vend_contact_user(
            session_mock,
            auth0_id,
            'foo',
            'foo@theorchard.io',
            {4},
            vendor_id,
            auth0_primary,
            master_contact,
            subaccount_id,
        )
        assert actual == {'new': 'vc_user'}


def test_create_full_vend_contact_user_err():
    """Test create_full_vend_contact_user raises error."""
    fetch_mock = MagicMock()
    fetch_mock.fetchone.return_value = None
    session_mock = MagicMock()
    session_mock.execute.side_effect = [None, fetch_mock]
    auth0_id = 'foo'
    vendor_id = None
    subaccount_id = None
    auth0_primary = None
    with patch.object(mysql, 'db_session', return_value=session_mock):
        with pytest.raises(IncompleteResultError):
            label.create_full_vend_contact_user(
                session_mock,
                auth0_id,
                'foo',
                'foo@theorchard.io',
                {4},
                vendor_id,
                auth0_primary,
                False,
                subaccount_id,
            )
            assert False


def test_update_vend_contact_roles():
    """Test update_vend_contact_roles."""
    session_mock = MagicMock()
    session_mock.execute.return_value = {'success': 'replace'}

    with patch.object(mysql, 'db_session', return_value=session_mock):
        actual = label.update_vend_contact_roles(session_mock, 1234, {4})
        assert actual == {'success': 'replace'}


@pytest.mark.parametrize(
    ('vend_contact_id', 'role_ids_to_add', 'role_ids_to_remove', 'ar_query'),
    [
        (  # Add new roles
            123456,
            [1, 3],
            [],
            """INSERT INTO vend_contact_roles (vend_contact_id, role_id)
            SELECT :vend_contact_id, id FROM vendor_roles WHERE id IN :role_ids_to_add;""",
        ),
        (  # Remove roles
            123456,
            [],
            [1],
            """DELETE FROM vend_contact_roles
                WHERE vend_contact_id = :vend_contact_id AND role_id IN :role_ids_to_remove;""",
        ),
        (  # Remove all roles
            123456,
            [],
            [0],
            """DELETE FROM vend_contact_roles WHERE vend_contact_id = :vend_contact_id;""",
        ),
    ],
)
def test_add_remove_vend_contact_roles(
    vend_contact_id, role_ids_to_add, role_ids_to_remove, ar_query
):
    """Test add_remove_vend_contact_roles."""
    session_mock = MagicMock()

    with patch.object(mysql, 'db_session', return_value=session_mock):
        label.add_remove_vend_contact_roles(
            session_mock, vend_contact_id, role_ids_to_add, role_ids_to_remove
        )
        assert session_mock.execute.call_count == 1
        if role_ids_to_remove:
            assert session_mock.execute.call_args[0] == (
                ar_query,
                {'vend_contact_id': vend_contact_id, 'role_ids_to_remove': role_ids_to_remove},
            )
        if role_ids_to_add:
            assert session_mock.execute.call_args[0] == (
                ar_query,
                {'vend_contact_id': vend_contact_id, 'role_ids_to_add': role_ids_to_add},
            )


def test_update_vend_contact():
    """Test update_vend_contact."""
    session_mock = MagicMock()
    session_mock.execute.return_value = {'success': 'update'}

    with patch.object(mysql, 'db_session', return_value=session_mock):
        actual = label.update_vend_contact(session_mock, 1234, True)
        assert actual == {'success': 'update'}


def test_deactivate_other_vend_contacts():
    """Test deactivate_other_vend_contacts."""
    session_mock = MagicMock()
    session_mock.execute.return_value = {'success': 'replace'}

    with patch.object(mysql, 'db_session', return_value=session_mock):
        actual = label.deactivate_other_vend_contacts(session_mock, 1234, [1, 2])
        assert actual == {'success': 'replace'}