"""Test user_info model.

Tests for functions working with AR DB records in the table 'orchadmin_users'.
"""

import pytest

from tests.unit import db_utils
from tests.unit.factories.alw_user_contact import ALWUserContactFactory
from tests.unit.factories.alw_user_vend_contact import ALWUserVendContactFactory  # noqa
from tests.unit.factories.contact import ContactFactory
from tests.unit.factories.currency import CurrencyFactory
from tests.unit.factories.feature import FeatureFactory
from tests.unit.factories.oa_roles import OARolesFactory
from tests.unit.factories.oa_user import OAUserFactory
from tests.unit.factories.oa_user_roles import OAUserRolesFactory
from tests.unit.factories.subaccount import SubaccountFactory
from tests.unit.factories.travelex import TravelexFactory
from tests.unit.factories.vend_contact import VendContactFactory
from tests.unit.factories.vend_contact_roles import VendContactRolesFactory
from tests.unit.factories.vendor import VendorFactory
from tests.unit.factories.vendor_contract import VendorContractFactory
from tests.unit.factories.vendor_permissions import VendorPermissionsFactory
from tests.unit.factories.vendor_privilege import VendorPrivilegeFactory
from tests.unit.factories.vendor_resource import VendorResourceFactory
from tests.unit.factories.vendor_restricted_feature import VendorRestrictedFeatureFactory  # noqa
from tests.unit.factories.vendor_role_permissions import VendorRolePermissionsFactory  # noqa
from tests.unit.factories.vendor_roles import VendorRolesFactory
from users import constants
from users.models import user_info


@pytest.mark.parametrize(
    ('user_ids', 'expected_result'),
    [
        (
            None,
            [
                OAUserFactory.build(user_id=123).to_dict(),
                OAUserFactory.build(user_id=456).to_dict(),
            ],
        ),
        ([], []),
        ([123], [OAUserFactory.build(user_id=123).to_dict()]),
    ],
)
@db_utils.test_schema
def test_fetch_oa_users(context, user_ids, expected_result):
    """Test fetch_oa_users."""
    db_utils.seed_models(OAUserFactory.build(user_id=123))
    db_utils.seed_models(OAUserFactory.build(user_id=456))
    with context:
        result = user_info.fetch_oa_users(user_ids)
    assert result.message == expected_result


@pytest.mark.parametrize(
    'user_ids,seed_users,expected_output',
    [
        pytest.param(
            ['123', '456'],
            [OAUserFactory.build(user_id=123), OAUserFactory.build(user_id=456, active='N')],
            [
                {
                    'user_id': '123',
                    'first_name': 'first name',
                    'last_name': 'last name',
                    'active': True,
                },
                {
                    'user_id': '456',
                    'first_name': 'first name',
                    'last_name': 'last name',
                    'active': False,
                },
            ],
            id='multiple valid users',
        ),
        pytest.param(
            [],
            [],
            [],
            id='empty user ids',
        ),
        pytest.param(
            ['123', '456'],
            [],
            [],
            id='invalid user ids',
        ),
        pytest.param(
            ['123', '456'],
            [OAUserFactory.build(user_id=123)],
            [
                {
                    'user_id': '123',
                    'first_name': 'first name',
                    'last_name': 'last name',
                    'active': True,
                },
            ],
            id='mixed valid invalid user ids',
        ),
    ],
)
@db_utils.test_schema
def test_get_orchadmin_users(context, seed_users, user_ids, expected_output):
    """Test get_orchadmin_users with various combinations of valid, invalid, and empty user IDs."""
    db_utils.seed_models(seed_users)
    with context:
        result = user_info.get_orchadmin_users(user_ids)
    assert result == expected_output


@pytest.mark.parametrize(
    ('user_ids', 'expected_result'),
    [
        (
            None,
            [
                {
                    **ALWUserVendContactFactory.build(
                        user_id=123, contact_id=1234, auth0_user_id='abc', login='a'
                    ).to_dict(),
                    **ALWUserContactFactory.build(contact_id=1234).to_dict(),
                },
                {
                    **ALWUserVendContactFactory.build(
                        user_id=456, contact_id=4567, auth0_user_id='abc', login='a'
                    ).to_dict(),
                    **ALWUserContactFactory.build(contact_id=4567).to_dict(),
                },
                {
                    **ALWUserVendContactFactory.build(
                        user_id=789, contact_id=7890, auth0_user_id='abc', login='a'
                    ).to_dict(),
                    **{'first_name': None, 'last_name': None, 'email': None, 'language': 'en'},
                },
                {
                    **ALWUserVendContactFactory.build(
                        user_id=3245, contact_id=111, vendor_id=888, auth0_user_id='abc', login='a'
                    ).to_dict(),
                    **ALWUserContactFactory.build(contact_id=111).to_dict(),
                    **{'currency': 'USD', 'company': 'company', 'role_id': 1},
                },
            ],
        ),
        ([], []),
        (
            [123],
            [
                {
                    **ALWUserVendContactFactory.build(
                        user_id=123, contact_id=1234, auth0_user_id='abc', login='a'
                    ).to_dict(),
                    **ALWUserContactFactory.build(contact_id=1234).to_dict(),
                }
            ],
        ),
        (
            [789],
            [
                {
                    **ALWUserVendContactFactory.build(
                        user_id=789, contact_id=7890, auth0_user_id='abc', login='a'
                    ).to_dict(),
                    **{'first_name': None, 'last_name': None, 'email': None, 'language': 'en'},
                }
            ],
        ),
        (
            [3245],
            [
                {
                    **ALWUserVendContactFactory.build(
                        user_id=3245, contact_id=111, vendor_id=888, auth0_user_id='abc', login='a'
                    ).to_dict(),
                    **ALWUserContactFactory.build(contact_id=111).to_dict(),
                    **{'currency': 'USD', 'company': 'company', 'role_ids': [1]},
                }
            ],
        ),
    ],
)
@db_utils.test_schema
def test_fetch_alw_users(context, user_ids, expected_result):
    """Test fetch_alw_users."""
    db_utils.seed_models(
        ALWUserVendContactFactory.build(
            user_id=123, contact_id=1234, auth0_user_id='abc', login='a'
        )
    )
    db_utils.seed_models(ALWUserContactFactory.build(contact_id=1234))
    db_utils.seed_models(
        ALWUserVendContactFactory.build(
            user_id=456, contact_id=4567, auth0_user_id='abc', login='a'
        )
    )
    db_utils.seed_models(ALWUserContactFactory.build(contact_id=4567))
    db_utils.seed_models(
        ALWUserVendContactFactory.build(
            user_id=789, contact_id=7890, auth0_user_id='abc', login='a'
        )
    )
    db_utils.seed_models(
        ALWUserVendContactFactory.build(
            user_id=3245, contact_id=111, vendor_id=888, auth0_user_id='abc', login='a'
        )
    )
    db_utils.seed_models(ALWUserContactFactory.build(contact_id=111))
    db_utils.seed_models(
        VendorFactory.build(
            vendor_id=888,
            company='company',
            is_distributor='1',
            language='en',
            label_identifier='Catalog',
            name='name',
            number_format='1',
            owner='theorchard',
        )
    )
    db_utils.seed_models(VendorContractFactory.build(vendor_id=888))
    db_utils.seed_models(
        CurrencyFactory.build(currency_id=1, currency_iso_code='USD', currency_name='US Dollars')
    )
    db_utils.seed_models(VendContactRolesFactory.build(vend_contact_id=3245, role_id=1))

    with context:
        result = user_info.fetch_alw_users(user_ids)
    assert result.message == expected_result


@pytest.mark.parametrize(
    ('vend_contact_id', 'expected_status', 'expected_message'),
    [
        # user and metadata exists
        (
            123,
            200,
            {
                'language': 'en',
                'number_format': 'us',
                'subaccount': {'subaccount_id': 5656, 'subaccount_name': 'El Subaccount'},
                'contact': {'contact_id': 4444, 'contact_email': 'test@test.com'},
                'login': 'pizzaman',
                'id': 123,
                'vendor': {
                    'language': 'en',
                    'owner': 'kdigital',
                    'label_identifier': 'Frontline',
                    'vendor_id': 1234,
                    'company': 'Pizza Records',
                    'number_format': 'us',
                    'name': 'Rick Moranis',
                    'is_distributor': 'N',
                    'assigned_to': None,
                },
                'vend_contact_roles': [
                    {
                        'vend_contact_id': 123,
                        'role': {
                            'role': 'Administrator',
                            'id': 4,
                            'vendor_role_permissions': [
                                {
                                    'role_id': 4,
                                    'permission': {
                                        'resource': {'resource': 'releasebuilder', 'id': 1},
                                        'id': 36,
                                        'privilege': None,
                                    },
                                    'id': 1,
                                    'allow': 'Y',
                                },
                                {
                                    'role_id': 4,
                                    'permission': {
                                        'resource': {'resource': 'account', 'id': 9},
                                        'id': 47,
                                        'privilege': {'id': 16, 'privilege': 'manageusers'},
                                    },
                                    'id': 2,
                                    'allow': 'Y',
                                },
                            ],
                        },
                        'id': 1,
                    },
                    {
                        'vend_contact_id': 123,
                        'role': {
                            'role': 'Accounting',
                            'id': 5,
                            'vendor_role_permissions': [
                                {
                                    'role_id': 5,
                                    'permission': {
                                        'resource': {'resource': 'releasebuilder', 'id': 1},
                                        'id': 36,
                                        'privilege': None,
                                    },
                                    'id': 3,
                                    'allow': 'N',
                                },
                                {
                                    'role_id': 5,
                                    'permission': {
                                        'resource': {'resource': 'account', 'id': 9},
                                        'id': 47,
                                        'privilege': {'id': 16, 'privilege': 'manageusers'},
                                    },
                                    'id': 4,
                                    'allow': 'N',
                                },
                                {
                                    'role_id': 5,
                                    'permission': {
                                        'resource': {'resource': 'legal', 'id': 19},
                                        'id': 183,
                                        'privilege': {'id': 167, 'privilege': 'terms'},
                                    },
                                    'id': 5,
                                    'allow': 'Y',
                                },
                            ],
                        },
                        'id': 2,
                    },
                ],
            },  # noqa
        ),
        # user does not exist
        (9999999, 404, None),
    ],
)
@db_utils.test_schema
def test_fetch_alw_session_user_metatada(
    context, vend_contact_id, expected_status, expected_message
):
    """Test fetch ALW user details for PHP $_SESSION."""
    # vendor roles
    db_utils.seed_models(VendorRolesFactory.build(_id=4, role='Administrator'))
    db_utils.seed_models(VendorRolesFactory.build(_id=5, role='Accounting'))

    # vendor role permissions
    db_utils.seed_models(
        VendorRolePermissionsFactory.build(_id=1, role_id=4, permission_id=36, allow='Y')
    )
    db_utils.seed_models(
        VendorRolePermissionsFactory.build(_id=2, role_id=4, permission_id=47, allow='Y')
    )
    db_utils.seed_models(
        VendorRolePermissionsFactory.build(_id=3, role_id=5, permission_id=36, allow='N')
    )
    db_utils.seed_models(
        VendorRolePermissionsFactory.build(_id=4, role_id=5, permission_id=47, allow='N')
    )
    db_utils.seed_models(
        VendorRolePermissionsFactory.build(_id=5, role_id=5, permission_id=183, allow='Y')
    )

    # vendor permissions
    db_utils.seed_models(VendorPermissionsFactory.build(_id=36, resource_id=1, privilege_id=None))
    db_utils.seed_models(VendorPermissionsFactory.build(_id=47, resource_id=9, privilege_id=16))
    db_utils.seed_models(VendorPermissionsFactory.build(_id=183, resource_id=19, privilege_id=167))

    # vendor privilege
    db_utils.seed_models(VendorPrivilegeFactory.build(_id=16, privilege='manageusers'))
    db_utils.seed_models(VendorPrivilegeFactory.build(_id=167, privilege='terms'))

    # vendor resource
    db_utils.seed_models(VendorResourceFactory.build(_id=1, resource='releasebuilder'))
    db_utils.seed_models(VendorResourceFactory.build(_id=9, resource='account'))
    db_utils.seed_models(VendorResourceFactory.build(_id=19, resource='legal'))

    # vend contact
    db_utils.seed_models(
        VendContactFactory.build(
            _id=123, vendor_id=1234, contact_id=4444, login='pizzaman', subaccount_id=5656
        )
    )

    # contact
    db_utils.seed_models(ContactFactory.build(contact_id=4444, contact_email='test@test.com'))

    # vendor
    db_utils.seed_models(
        VendorFactory.build(
            vendor_id=1234,
            company='Pizza Records',
            is_distributor='N',
            language='en',
            label_identifier='Frontline',
            name='Rick Moranis',
            number_format='us',
            owner='kdigital',
        )
    )

    # subaccount
    db_utils.seed_models(
        SubaccountFactory.build(subaccount_id=5656, subaccount_name='El Subaccount')
    )

    # vend contact roles
    db_utils.seed_models(VendContactRolesFactory.build(_id=1, vend_contact_id=123, role_id=4))
    db_utils.seed_models(VendContactRolesFactory.build(_id=2, vend_contact_id=123, role_id=5))

    with context:
        result = user_info.fetch_alw_session_user_metatada(vend_contact_id)

    assert expected_status == result.status
    assert expected_message == result.message


@pytest.mark.parametrize(
    ('vend_contact_id', 'expected_status', 'expected_message'),
    [
        # user and metadata exists
        (
            123,
            200,
            {
                'language': 'en',
                'id': 123,
                'subaccount': {'subaccount_id': 5656, 'subaccount_name': 'El Subaccount'},
                'contact': {
                    'contact_email': 'test@test.com',
                    'contact_id': 4444,
                    'contact_first_name': None,
                    'contact_last_name': None,
                },
                'number_format': 'us',
                'vend_contact_roles': [
                    {
                        'role': {
                            'id': '4',
                            'vendor_role_permissions': [
                                {
                                    'role_id': 4,
                                    'role': 'Administrator',
                                    'id': 1,
                                    'allow': 'Y',
                                    'vend_contact_role_id': 1,
                                    'vend_contact_id': 123,
                                    'permission': {
                                        'resource': {'resource': 'releasebuilder', 'id': 1},
                                        'id': 36,
                                        'privilege': None,
                                    },
                                },
                                {
                                    'role_id': 4,
                                    'role': 'Administrator',
                                    'id': 2,
                                    'allow': 'Y',
                                    'vend_contact_role_id': 1,
                                    'vend_contact_id': 123,
                                    'permission': {
                                        'resource': {'resource': 'account', 'id': 9},
                                        'id': 47,
                                        'privilege': 'manageusers',
                                    },
                                },
                            ],
                            'role': 'Administrator',
                        },
                        'id': 1,
                        'vend_contact_id': 123,
                    },
                    {
                        'role': {
                            'id': '5',
                            'vendor_role_permissions': [
                                {
                                    'role_id': 5,
                                    'role': 'Accounting',
                                    'id': 5,
                                    'allow': 'Y',
                                    'vend_contact_role_id': 2,
                                    'vend_contact_id': 123,
                                    'permission': {
                                        'resource': {'resource': 'legal', 'id': 19},
                                        'id': 183,
                                        'privilege': 'terms',
                                    },
                                }
                            ],
                            'role': 'Accounting',
                        },
                        'id': 2,
                        'vend_contact_id': 123,
                    },
                ],
                'vendor': {
                    'language': 'en',
                    'number_format': 'us',
                    'name': 'Rick Moranis',
                    'vendor_id': 1234,
                    'company': 'Pizza Records',
                    'image_asset_id': None,
                    'vendor_restricted_features': ['Film Release Builder'],
                    'travelex_enrollment_id': 'abc123',
                    'owner': 'kdigital',
                    'is_distributor': 'N',
                    'label_identifier': 'Frontline',
                    'assigned_to_email': 'email',
                    'assigned_to_phone': '281-330-8004',
                    'support_contact_email': 'support@test.com',
                    'migrated_to_abacus': 0,
                },
                'login': 'pizzaman',
                'auth0_user_id': None,
                'active': 'Y',
            },  # noqa
        ),
        # user does not exist
        (9999999, 404, None),
    ],
)
@db_utils.test_schema
def test_fetch_alw_session_user_metatada_raw(
    context, vend_contact_id, expected_status, expected_message
):
    """Test fetch ALW user details for PHP $_SESSION using raw SQL."""
    # vendor roles
    db_utils.seed_models(VendorRolesFactory.build(_id=4, role='Administrator'))
    db_utils.seed_models(VendorRolesFactory.build(_id=5, role='Accounting'))

    # vendor role permissions
    db_utils.seed_models(
        VendorRolePermissionsFactory.build(_id=1, role_id=4, permission_id=36, allow='Y')
    )
    db_utils.seed_models(
        VendorRolePermissionsFactory.build(_id=2, role_id=4, permission_id=47, allow='Y')
    )
    db_utils.seed_models(
        VendorRolePermissionsFactory.build(_id=3, role_id=5, permission_id=36, allow='N')
    )
    db_utils.seed_models(
        VendorRolePermissionsFactory.build(_id=4, role_id=5, permission_id=47, allow='N')
    )
    db_utils.seed_models(
        VendorRolePermissionsFactory.build(_id=5, role_id=5, permission_id=183, allow='Y')
    )

    # vendor permissions
    db_utils.seed_models(VendorPermissionsFactory.build(_id=36, resource_id=1, privilege_id=None))
    db_utils.seed_models(VendorPermissionsFactory.build(_id=47, resource_id=9, privilege_id=16))
    db_utils.seed_models(VendorPermissionsFactory.build(_id=183, resource_id=19, privilege_id=167))

    # vendor privilege
    db_utils.seed_models(VendorPrivilegeFactory.build(_id=16, privilege='manageusers'))
    db_utils.seed_models(VendorPrivilegeFactory.build(_id=167, privilege='terms'))

    # vendor resource
    db_utils.seed_models(VendorResourceFactory.build(_id=1, resource='releasebuilder'))
    db_utils.seed_models(VendorResourceFactory.build(_id=9, resource='account'))
    db_utils.seed_models(VendorResourceFactory.build(_id=19, resource='legal'))

    # vend contact
    db_utils.seed_models(
        VendContactFactory.build(
            _id=123, vendor_id=1234, contact_id=4444, login='pizzaman', subaccount_id=5656
        )
    )

    # contact
    db_utils.seed_models(ContactFactory.build(contact_id=4444, contact_email='test@test.com'))

    # oa user
    db_utils.seed_models(OAUserFactory.build(office_phone='281-330-8004', user_id=920))

    # vendor
    db_utils.seed_models(
        VendorFactory.build(
            vendor_id=1234,
            company='Pizza Records',
            is_distributor='N',
            language='en',
            label_identifier='Frontline',
            name='Rick Moranis',
            number_format='us',
            owner='kdigital',
            assigned_to=920,
            support_contact_email='support@test.com',
        )
    )

    # subaccount
    db_utils.seed_models(
        SubaccountFactory.build(subaccount_id=5656, subaccount_name='El Subaccount')
    )

    # vend contact roles
    db_utils.seed_models(VendContactRolesFactory.build(_id=1, vend_contact_id=123, role_id=4))
    db_utils.seed_models(VendContactRolesFactory.build(_id=2, vend_contact_id=123, role_id=5))

    # features
    db_utils.seed_models(
        FeatureFactory.build(feature_id=1, feature_name='Audio Release Builder', is_default=1)
    )
    db_utils.seed_models(
        FeatureFactory.build(feature_id=2, feature_name='Film Release Builder', is_default=1)
    )

    # vendor restricted features
    db_utils.seed_models(
        VendorRestrictedFeatureFactory.build(
            vendor_restricted_features_id=1, vendor_id=999, feature_id=1, preview=1
        )
    )
    db_utils.seed_models(
        VendorRestrictedFeatureFactory.build(
            vendor_restricted_features_id=2, vendor_id=1234, feature_id=2, preview=1
        )
    )

    # travelexes
    db_utils.seed_models(TravelexFactory.build(vendor_id=1234, enrollment_id='abc123'))

    with context:
        result = user_info.fetch_alw_session_user_metatada_raw(vend_contact_id)
    assert expected_status == result.status
    assert expected_message == result.message


@pytest.mark.parametrize(
    ('input_login', 'input_pass', 'auth0', 'status'),
    [
        ('testname', 'passhash', None, 200),
        ('testname', 'bad', None, 404),
        ('dummy', 'dummy', None, 404),
        ('testname', 'passhash', 'alreadymigrated', 404),
    ],
)
@db_utils.test_schema
def test_fetch_alw_user_by_login(context, input_login, input_pass, auth0, status):
    """Test fetch_alw_user_by_login."""
    login_name = 'testname'
    login_pass = 'passhash'
    user_id = 123
    contact_email = 'abc@theorchard.com'
    expected_message = {
        'contact_email': contact_email,
        'login': login_name,
        'password_hash': login_pass,
        'vend_contact_id': user_id,
    }

    vend_contact = ALWUserVendContactFactory.build(
        user_id=user_id,
        contact_id=1234,
        login=login_name,
        password_hash=login_pass,
        auth0_user_id=auth0,
    )
    contact = ALWUserContactFactory.build(contact_id=1234, email=contact_email)
    db_utils.seed_models(vend_contact)
    db_utils.seed_models(contact)

    with context:
        result = user_info.fetch_alw_user_by_login(input_login, input_pass)
    assert status == result.status
    if status == 200:
        assert expected_message == result.message


@pytest.mark.parametrize(
    ('input_user', 'data', 'status'),
    [
        ('88691', {'auth0_user_id': 'abc', 'active': 'Y', 'auth0_primary': 'Y'}, 200),
        ('11111', {'auth0_user_id': 'abc', 'active': 'Y'}, 404),
    ],
)
@db_utils.test_schema
def test_update_vend_contact_details(context, input_user, data, status):
    """Test update_vend_contact_details."""
    login_name = 'testname'
    login_pass = 'passhash'
    user_id = 88691
    contact_email = 'abc@theorchard.com'
    auth0_user_id = 'abc'
    expected_message = {
        'account': {'subaccount_id': 456, 'vendor_id': 123},
        'language': 'en',
        'type': 'alw',
        'user_id': 'alw:{}'.format(user_id),
        'login': login_name,
        'auth0_user_id': auth0_user_id,
        'primary': 'Y',
        'contact_id': 1234,
        'active': 'Y',
    }

    vend_contact = ALWUserVendContactFactory.build(
        user_id=user_id,
        contact_id=1234,
        login=login_name,
        password_hash=login_pass,
        auth0_user_id=auth0_user_id,
    )
    contact = ALWUserContactFactory.build(contact_id=1234, email=contact_email)
    db_utils.seed_models(vend_contact)
    db_utils.seed_models(contact)

    with context:
        result = user_info.update_vend_contact_details(input_user, data)
    assert status == result.status
    if status == 200:
        assert expected_message == result.message


@pytest.mark.parametrize(
    ('old_auth0_user_id', 'new_auth0_user_id', 'expected'),
    [
        ('identity-uuid', 'new-auth0-id', '1 rows updated.'),
        ('dummy', 'new-auth0-id', '0 rows updated.'),
    ],
)
@db_utils.test_schema
def test_update_vend_contacts(context, old_auth0_user_id, new_auth0_user_id, expected):
    """Test update_vend_contacts."""
    vend_contact = ALWUserVendContactFactory.build(
        user_id=90021, contact_id=1234, login='user_90021', auth0_user_id='identity-uuid'
    )
    db_utils.seed_models(vend_contact)

    with context:
        result = user_info.update_vend_contacts(old_auth0_user_id, new_auth0_user_id)
        assert result
        assert result.message == expected


@pytest.mark.parametrize(
    ('contact_id', 'status'),
    [
        ('78910', 200),
        ('11111', 404),
    ],
)
@db_utils.test_schema
def test_update_contact_details(context, contact_id, status):
    """Test update_contact_details."""
    data = {'first_name': 'new_name', 'requested_login_email': 'two@theorchard.test'}
    contact = ALWUserContactFactory.build(
        contact_id='78910',
        first_name='one',
        last_name='user',
        requested_login_email='one@theorchard.test',
    )
    db_utils.seed_models(contact)
    expected_message = contact.to_dict()
    expected_message.update(**data)
    with context:
        result = user_info.update_contact_details(contact_id, data)
    assert status == result.status
    if status == 200:
        assert expected_message == result.message


@pytest.mark.parametrize(
    ('request_id', 'message', 'status'),
    [
        ('16880', ['Fake vendor'], 200),
        ('33435345', [], 200),
        (None, constants.ERROR_MISSING_REQUIRED_ID, 500),
    ],
)
@db_utils.test_schema
def test_fetch_vendor_names(context, request_id, message, status):
    """Test fetch_vendor_names with user_id."""
    user_id = 16880
    vendor_id = 7123
    vendor_name = 'Fake vendor'
    vend_contact = ALWUserVendContactFactory.build(user_id=user_id, vendor_id=vendor_id)
    vendor = VendorFactory.build(vendor_id=vendor_id, name=vendor_name, company='')
    db_utils.seed_models(vendor)
    db_utils.seed_models(vend_contact)

    with context:
        result = user_info.fetch_vendor_names(request_id)
        assert result.status == status
        if status == 200:
            assert result.message == message
        else:
            assert result.errors['message'] == message


@pytest.mark.parametrize(
    ('auth0_id', 'user_id', 'message', 'status'),
    [
        ('auth0|5b7719d8ccde104ca215f8d3', None, [16880], 200),
        ('auth0|5b7719d8ccde104ca215f8d3', 16880, [], 200),
        ('auth0|sadasdasdasd', None, [], 200),
    ],
)
@db_utils.test_schema
def test_fetch_users_by_auth0_id(context, auth0_id, user_id, message, status):
    """Test fetch_vendor_names with user_id."""
    auth0_seed = 'auth0|5b7719d8ccde104ca215f8d3'
    user_id_seed = 16880
    vendor_id = 7123
    vend_contact = ALWUserVendContactFactory.build(
        user_id=user_id_seed, vendor_id=vendor_id, auth0_user_id=auth0_seed
    )
    db_utils.seed_models(vend_contact)

    with context:
        result = user_info.fetch_users_by_auth0_id(auth0_id, user_id)
        assert result.status == status
        if status == 200:
            assert result.message == message
        else:
            assert result.errors['message'] == message


@pytest.mark.parametrize(
    ('request_id', 'message', 'status'),
    [
        ('auth0|5b7719d8ccde104ca215f8d3', ['Music Company', 'Label1'], 200),
        ('auth0|sadasdasdasd', [], 200),
        (None, constants.ERROR_MISSING_REQUIRED_ID, 500),
    ],
)
@db_utils.test_schema
def test_fetch_vendor_names_auth0_id(context, request_id, message, status):
    """Test fetch_vendor_names with auth0 id."""
    auth0_id = 'auth0|5b7719d8ccde104ca215f8d3'
    vendor_id1 = 7123
    vendor_id2 = 8869
    # user 1 from vendor 7123 with auth0_id
    vendor = VendorFactory.build(vendor_id=vendor_id1, name='Label1', company='')
    vend_contact = ALWUserVendContactFactory.build(
        user_id=16880, vendor_id=vendor_id1, auth0_user_id=auth0_id
    )
    db_utils.seed_models(vendor)
    db_utils.seed_models(vend_contact)
    # user 2 with different vendor but with same auth0_id
    vendor = VendorFactory.build(vendor_id=vendor_id2, name='Has a name', company='Music Company')
    vend_contact = ALWUserVendContactFactory.build(
        user_id=15001, vendor_id=vendor_id2, auth0_user_id=auth0_id
    )
    db_utils.seed_models(vendor)
    db_utils.seed_models(vend_contact)

    with context:
        result = user_info.fetch_vendor_names(None, request_id)
        assert result.status == status
        if status == 200:
            assert result.message == message
        else:
            assert result.errors['message'] == message


@pytest.mark.parametrize('num_rows', (1, 5, 0))
@db_utils.test_schema
def test_reset_users_auth0_details(context, num_rows):
    """Test reset_users_auth0_details."""
    auth0_id = 'auth0|test'
    expected_message = '{} rows updated.'.format(num_rows)

    for _ in range(0, num_rows):
        vend_contact = ALWUserVendContactFactory.build(auth0_user_id=auth0_id)
        db_utils.seed_models(vend_contact)

    with context:
        result = user_info.reset_users_auth0_details(auth0_id)

    assert result
    assert expected_message == result.message


@pytest.mark.parametrize(
    ('user_id', 'message', 'status'),
    [
        (
            16880,
            ALWUserVendContactFactory.build(
                user_id=16880, vendor_id=7123, login='foo', contact_id=111, auth0_user_id='abc'
            ).to_dict(),
            200,
        ),
        (2, None, 404),
    ],
)
@db_utils.test_schema
def test_fetch_vend_contact_for_user(context, user_id, message, status):
    """Test fetch vend contact data for a user."""
    vend_contact = ALWUserVendContactFactory.build(
        user_id=16880, vendor_id=7123, login='foo', auth0_user_id='abc', contact_id=111
    )
    db_utils.seed_models(vend_contact)

    with context:
        result = user_info.fetch_vend_contact_for_user(user_id)
        assert result.status == status
        if status == 200:
            assert result.message == message
        else:
            assert result.errors['message'] == message


@pytest.mark.parametrize(('user_id', 'status'), [(16880, 200), (100, 404)])
@db_utils.test_schema
def test_fetch_vend_contact_and_contact(context, user_id, status):
    """Test fetch_vend_contact_and_contact."""
    contact = ALWUserContactFactory.build(contact_id=111)
    vend_contact = ALWUserVendContactFactory.build(
        user_id=16880, vendor_id=7123, login='foo', auth0_user_id='abc', contact_id=111
    )
    db_utils.seed_models(contact)
    db_utils.seed_models(vend_contact)
    expected = vend_contact.to_dict()
    expected.update(contact.to_dict())

    with context:
        result = user_info.fetch_vend_contact_and_contact(user_id)
        assert result.status == status
        if status == 200:
            assert result.message == expected


@pytest.mark.parametrize(
    ('auth0_id', 'message', 'status'),
    [
        (
            'abc',
            ALWUserVendContactFactory.build(
                user_id=16880,
                vendor_id=7123,
                login='foo',
                auth0_user_id='abc',
                contact_id=111,
                auth0_primary='Y',
            ).to_dict(),
            200,
        ),
        (2, None, 404),
    ],
)
@db_utils.test_schema
def test_fetch_primary_for_auth0_user(context, auth0_id, message, status):
    """Test fetch primary account for auth0 user."""
    vend_contact = ALWUserVendContactFactory.build(
        user_id=16880,
        vendor_id=7123,
        login='foo',
        auth0_user_id='abc',
        contact_id=111,
        auth0_primary='Y',
    )
    db_utils.seed_models(vend_contact)

    with context:
        result = user_info.fetch_primary_for_auth0_user(auth0_id)
        assert result.status == status
        if status == 200:
            assert result.message == message
        else:
            assert result.errors['message'] == message


@pytest.mark.parametrize(('user_id', 'status'), [(9992, 200), (None, 404)])
@db_utils.test_schema
def test_reset_user_auth0_details(context, user_id, status):
    """Test reset_user_auth0_details."""
    auth0_id = 'auth0|test'

    vend_contact = ALWUserVendContactFactory.build(
        user_id=user_id, auth0_user_id=auth0_id, auth0_primary='Y'
    )
    db_utils.seed_models(vend_contact)

    with context:
        result = user_info.reset_user_auth0_details(user_id)
        assert result.status == status
        if result.status == 200:
            assert result.message['auth0_user_id'] is None
            assert result.message['primary'] is None


@pytest.mark.parametrize(
    ('auth0_id', 'accounts', 'vendor_ids', 'subaccount_ids'),
    [
        ('dummy', 0, [None], [None]),
        ('bam', 1, [10570], [None]),
        ('foo', 2, [8869, 2244], [None]),
        ('bar', 3, [29138, 22589], [1, 2, 3]),
    ],
)
@db_utils.test_schema
def test_get_all_accounts_with_auth0_id(context, auth0_id, accounts, vendor_ids, subaccount_ids):
    """Test get_all_accounts_with_auth0_id."""
    users = [
        {'id': 102, 'auth0_id': 'foo', 'vendor_id': 8869},
        {'id': 103, 'auth0_id': 'foo', 'vendor_id': 2244},
        {'id': 104, 'auth0_id': 'bar', 'vendor_id': 29138, 'subaccount_id': 1},
        {'id': 105, 'auth0_id': 'bar', 'vendor_id': 29138, 'subaccount_id': 2},
        {'id': 106, 'auth0_id': 'bar', 'vendor_id': 22589, 'subaccount_id': 3},
        {'id': 107, 'auth0_id': 'bam', 'vendor_id': 10570},
    ]
    db_utils.seed_vendor_vc_subaccount(users)
    with context:
        result = user_info.get_all_accounts_with_auth0_id(auth0_id)
        assert result
        assert len(result.message) == accounts
        for actual_user in result.message:
            assert actual_user['vendor_id'] in vendor_ids
            assert actual_user['subaccount_id'] in subaccount_ids


@pytest.mark.parametrize(
    ('auth0_id', 'accounts', 'vendor_ids', 'subaccount_ids', 'support_contact_email'),
    [
        ('dummy', 0, [None], [None], ['']),
        ('bam', 1, [10570], [None], ['']),
        ('foo', 2, [8869, 2244], [None], ['contact@8869', 'contact@2244']),
        ('bar', 3, [29138, 22589], [1, 2, 3], ['contact@29138', '']),
    ],
)
@db_utils.test_schema
def test_get_all_account_details_with_auth0_id(
    context, auth0_id, accounts, vendor_ids, subaccount_ids, support_contact_email
):
    """Test get_all_account_details_with_auth0_id."""
    users = [
        {'id': 102, 'auth0_id': 'foo', 'vendor_id': 8869, 'support_contact_email': 'contact@8869'},
        {'id': 103, 'auth0_id': 'foo', 'vendor_id': 2244, 'support_contact_email': 'contact@2244'},
        {
            'id': 104,
            'auth0_id': 'bar',
            'vendor_id': 29138,
            'subaccount_id': 1,
            'support_contact_email': 'contact@29138',
        },  # noqa
        {
            'id': 105,
            'auth0_id': 'bar',
            'vendor_id': 29138,
            'subaccount_id': 2,
            'support_contact_email': 'contact@29138',
        },  # noqa
        {'id': 106, 'auth0_id': 'bar', 'vendor_id': 22589, 'subaccount_id': 3},
        {'id': 107, 'auth0_id': 'bam', 'vendor_id': 10570},
    ]
    db_utils.seed_vendor_vc_subaccount(users)
    with context:
        result = user_info.get_all_account_details_with_auth0_id(auth0_id)
        assert result
        assert len(result.message) == accounts
        for actual_user in result.message:
            assert actual_user['vendor_id'] in vendor_ids
            assert actual_user['subaccount_id'] in subaccount_ids
            assert actual_user['support_contact_email'] in support_contact_email


@pytest.mark.parametrize(
    ('auth0_id', 'accounts', 'vendor_ids', 'subaccount_ids', 'include_deleted'),
    [
        ('dummy', 0, [None], [None], False),
        ('dummy', 0, [None], [None], True),
        ('foo', 1, [8869], [None], False),
        ('foo', 2, [8869, 2244], [None], True),
        ('bar', 2, [29138], [1, 2], False),
        ('bar', 3, [29138, 22589], [1, 2, 3], True),
    ],
)
@db_utils.test_schema
def test_get_all_accounts_with_active(
    context, auth0_id, accounts, vendor_ids, subaccount_ids, include_deleted
):
    """Test get_all_accounts_with_auth0_id with include_deleted flag."""
    users = [
        {'id': 102, 'auth0_id': 'foo', 'vendor_id': 8869},
        {'id': 103, 'auth0_id': 'foo', 'vendor_id': 2244, 'active': 'N'},
        {'id': 104, 'auth0_id': 'bar', 'vendor_id': 29138, 'subaccount_id': 1},
        {'id': 105, 'auth0_id': 'bar', 'vendor_id': 29138, 'subaccount_id': 2},
        {'id': 106, 'auth0_id': 'bar', 'vendor_id': 22589, 'subaccount_id': 3, 'active': 'N'},
    ]
    db_utils.seed_vendor_vc_subaccount(users)
    with context:
        result = user_info.get_all_accounts_with_auth0_id(auth0_id, include_deleted)
        assert result
        assert len(result.message) == accounts
        for actual_user in result.message:
            assert actual_user['vendor_id'] in vendor_ids
            assert actual_user['subaccount_id'] in subaccount_ids


@pytest.mark.parametrize(
    ('vend_contact_id', 'contact_id', 'subaccount_id', 'expected_status', 'expected_message'),
    [
        (
            123,
            None,
            None,
            200,
            [
                {
                    'user_id': 123,
                    'subaccount': 'El Subaccount',
                    'is_active': 0,
                    'master': 'Y',
                    'vendor_id': 1234,
                    'contact_first_name': 'test',
                    'contact_last_name': 'test',
                    'contact_email': 'test@test.com',
                    'permissions': 'Administrator,Accounting',
                    'subaccount_id': 3,
                }
            ],
        ),
        (
            None,
            4444,
            None,
            200,
            [
                {
                    'user_id': 123,
                    'subaccount': 'El Subaccount',
                    'is_active': 0,
                    'master': 'Y',
                    'vendor_id': 1234,
                    'contact_first_name': 'test',
                    'contact_last_name': 'test',
                    'contact_email': 'test@test.com',
                    'permissions': 'Administrator,Accounting',
                    'subaccount_id': 3,
                }
            ],
        ),
        (
            None,
            None,
            '3',
            200,
            [
                {
                    'user_id': 123,
                    'subaccount': 'El Subaccount',
                    'is_active': 0,
                    'master': 'Y',
                    'vendor_id': 1234,
                    'contact_first_name': 'test',
                    'contact_last_name': 'test',
                    'contact_email': 'test@test.com',
                    'permissions': 'Administrator,Accounting',
                    'subaccount_id': 3,
                }
            ],
        ),
        (456, None, None, 404, None),
    ],
)
@db_utils.test_schema
def test_fetch_user_basic_info(
    context, vend_contact_id, contact_id, subaccount_id, expected_status, expected_message
):
    """Test fetch user details."""
    # vendor roles
    db_utils.seed_models(VendorRolesFactory.build(_id=4, role='Administrator'))
    db_utils.seed_models(VendorRolesFactory.build(_id=5, role='Accounting'))

    # vend contact
    db_utils.seed_models(
        VendContactFactory.build(
            _id=123, vendor_id=1234, contact_id=4444, active='N', master='Y', subaccount_id=3
        )
    )

    # contact
    db_utils.seed_models(
        ContactFactory.build(
            contact_id=4444,
            contact_email='test@test.com',
            contact_first_name='test',
            contact_last_name='test',
        )
    )

    # vendor
    db_utils.seed_models(VendorFactory.build(vendor_id=1234))

    # subaccount
    db_utils.seed_models(SubaccountFactory.build(subaccount_id=3, subaccount_name='El Subaccount'))

    # vend contact roles
    db_utils.seed_models(VendContactRolesFactory.build(_id=1, vend_contact_id=123, role_id=4))
    db_utils.seed_models(VendContactRolesFactory.build(_id=2, vend_contact_id=123, role_id=5))

    with context:
        result = user_info.fetch_user_basic_info(
            user_id=vend_contact_id, contact_id=contact_id, subaccount_id=subaccount_id
        )
    assert expected_status == result.status
    assert expected_message == result.message


@pytest.mark.parametrize(
    ('account_type', 'account_id', 'status', 'user_id'),
    [
        ('vendor', 1234, 200, None),
        ('subaccount', 5656, 200, None),
        ('vendor', 4567, 404, None),
    ],
)
@db_utils.test_schema
def test_get_contact_details(context, account_type, account_id, status, model_user_data, user_id):
    """Test get_contact_details."""
    vend_contact = VendContactFactory.build(
        _id=123, vendor_id=1234, contact_id=4444, subaccount_id=5656, active='N'
    )
    contact = ALWUserContactFactory.build(contact_id=4444)
    subaccount = SubaccountFactory.build(subaccount_id=5656, subaccount_name='El Subaccount')
    vend_contact_role_1 = VendContactRolesFactory.build(vend_contact_id=123, role_id=4)
    vend_contact_role_2 = VendContactRolesFactory.build(vend_contact_id=123, role_id=3)
    vendor_role_1 = VendorRolesFactory.build(_id=4, role='Administrator')
    vendor_role_2 = VendorRolesFactory.build(_id=3, role='Catalog')
    db_utils.seed_models(vend_contact)
    db_utils.seed_models(contact)
    db_utils.seed_models(subaccount)
    db_utils.seed_models(vend_contact_role_1)
    db_utils.seed_models(vend_contact_role_2)
    db_utils.seed_models(vendor_role_1)
    db_utils.seed_models(vendor_role_2)

    with context:
        result = user_info.get_contact_details(account_type, account_id, user_id, 'disable')
        assert result.status == status
        if result.status == 200:
            assert model_user_data == result.message


@pytest.mark.parametrize(
    ('account_type', 'account_id', 'status', 'expected_message'),
    [
        (
            'vendor',
            1234,
            200,
            {
                'type': 'alw',
                'user_id': 'alw:123',
                'account': {'vendor_id': 1234, 'subaccount_id': 5656},
                'login': 'login-123',
                'language': 'en',
                'auth0_user_id': 'user-123',
                'primary': None,
                'active': 'Y',
                'contact_id': 4444,
                'first_name': 'first name',
                'last_name': 'last name',
                'email': 'email',
                'requested_login_email': '',
            },
        ),
        (
            'subaccount',
            5656,
            200,
            {
                'type': 'alw',
                'user_id': 'alw:123',
                'account': {'vendor_id': 1234, 'subaccount_id': 5656},
                'login': 'login-123',
                'language': 'en',
                'auth0_user_id': 'user-123',
                'primary': None,
                'active': 'Y',
                'contact_id': 4444,
                'first_name': 'first name',
                'last_name': 'last name',
                'email': 'email',
                'requested_login_email': '',
            },
        ),
        ('vendor', 4567, 404, None),
    ],
)
@db_utils.test_schema
def test_get_primary_contact(context, account_type, account_id, status, expected_message):
    """Test get_primary_contact."""
    vend_contact = ALWUserVendContactFactory.build(
        user_id=123,
        vendor_id=1234,
        contact_id=4444,
        auth0_user_id='user-123',
        login='login-123',
        subaccount_id=5656,
        master='Y',
    )
    contact = ALWUserContactFactory.build(contact_id=4444)
    subaccount = SubaccountFactory.build(subaccount_id=5656, subaccount_name='El Subaccount')
    db_utils.seed_models(vend_contact)
    db_utils.seed_models(contact)
    db_utils.seed_models(subaccount)

    with context:
        result = user_info.get_primary_contact(account_type, account_id)
        assert result.status == status
        if result.status == 200:
            assert expected_message == result.message


@db_utils.test_schema
def test_get_product_managers(context):
    """Test fetch all product_managers data from DB."""
    expected_result = {
        'items': [
            {
                'type': 'oa',
                'user_id': 12,
                'full_name': 'first name last name',
                'email': 'email',
                'active': 'Y',
            }
        ]
    }
    db_utils.seed_models(OAUserFactory.build(user_id=12, active='Y', is_product_manager=1))
    with context:
        result = user_info.get_product_managers()
    assert result.message == expected_result


@db_utils.test_schema
def test_get_account_managers(context):
    """Test fetch all account managers data from DB."""
    expected = [{'user_id': 12, 'first_name': 'Test', 'last_name': 'AccountManager'}]
    db_utils.seed_models(
        OAUserFactory.build(user_id=12, active='Y', first_name='Test', last_name='AccountManager')
    )
    db_utils.seed_models(OAUserRolesFactory.build(orchadmin_user_id=12, orchadmin_role_id=3))
    result = user_info.get_account_managers()
    assert result
    assert result.message == expected


@db_utils.test_schema
def test_get_active_closers(context):
    """Test fetch all active closers from DB."""
    expected_result = {'items': [{'user_id': 12, 'first_name': 'Test', 'last_name': 'User 1'}]}
    db_utils.seed_models(
        OAUserFactory.build(
            user_id=12,
            first_name='Test',
            last_name='User 1',
            active='Y',
            is_product_manager=1,
            closer='Y',
        )
    )
    db_utils.seed_models(
        OAUserFactory.build(
            user_id=13,
            first_name='Test',
            last_name='User 2',
            active='Y',
            is_product_manager=1,
            closer='N',
        )
    )
    with context:
        result = user_info.get_active_closers()
    assert result.message == expected_result


@db_utils.test_schema
def test_get_alw_roles_for_user(context):
    """Test get workstation roles for user from DB."""
    expected_result = {'role_ids': [4], 'role_names': ['Administrator']}
    db_utils.seed_models(ALWUserVendContactFactory.build(user_id=12))
    db_utils.seed_models(VendContactRolesFactory.build(_id=712, vend_contact_id=12, role_id=4))
    db_utils.seed_models(VendorRolesFactory.build(_id=4, role='Administrator'))
    with context:
        result = user_info.get_alw_roles_for_user(12)
    assert result.message == expected_result


@db_utils.test_schema
def test_get_oa_roles_for_user(context):
    """Test get oa roles for user from DB."""
    expected_result = [{'id': 1, 'name': 'Engineering'}]
    db_utils.seed_models(OAUserFactory.build(user_id=12))
    db_utils.seed_models(
        OAUserRolesFactory.build(oa_user_roles_id=712, orchadmin_user_id=12, orchadmin_role_id=1)
    )
    db_utils.seed_models(OARolesFactory.build(orchadmin_role_id=1, orchadmin_role='Engineering'))
    with context:
        result = user_info.get_oa_roles_for_user(12)
    assert result.message == expected_result