"""Test model user_info_raw."""

from owsresponse.response import Response
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.oa_user import OAUserFactory
from tests.unit.factories.vend_contact_roles import VendContactRolesFactory
from tests.unit.factories.vendor import VendorFactory
from users.models import user_info_raw


@pytest.mark.parametrize(('user_ids', 'expected_status'), [(123, 200), (900, 404)])
@db_utils.test_schema
def test_fetch_oa_user_raw(context, user_ids, expected_status):
    """Test fetch_oa_user_raw."""
    user = OAUserFactory.build(user_id=123)
    db_utils.seed_models(user)
    with context:
        result = user_info_raw.fetch_oa_user_raw(user_ids)

    assert result.status == expected_status
    if result.status == 200:
        assert result.message == user_info_raw._format_oa_user_data(user)
    else:
        assert result.errors['message'] == 'User not found.'


@pytest.mark.parametrize(('user_ids', 'expected_status'), [(123, 200), (900, 404)])
@db_utils.test_schema
def test_fetch_vend_contact_raw(context, user_ids, expected_status):
    """Test fetch_vend_contact_raw."""
    user = ALWUserVendContactFactory.build(user_id=123)
    db_utils.seed_models(user)
    with context:
        result = user_info_raw.fetch_vend_contact_raw(user_ids)

    assert result.status == expected_status
    if result.status == 200:
        assert result.message == user_info_raw._format_vend_contact_data(user)
    else:
        assert result.errors['message'] == 'User not found.'


@pytest.mark.parametrize(
    ('user_ids', 'auth0id', 'email', 'expected_status', 'with_roles', 'expected_brand'),
    [
        (123, 'auth01', 'test@example.com', 200, True, 'theorchard'),
        (123, None, 'test@example.com', 200, True, 'awal'),
        (900, 'auth01', 'test@example.com', 404, True, 'theorchard'),
        (123, 'auth01', 'test@example.com', 200, False, 'theorchard'),
        (900, 'auth01', 'test@example.com', 404, False, 'theorchard'),
    ],
)
@db_utils.test_schema
def test_fetch_vend_contact_details(
    context, user_ids, auth0id, email, expected_status, with_roles, expected_brand, mocker
):
    """Test fetch_vend_contact_details for valid and missing user ids."""
    vendor = VendorFactory.build(vendor_id=7123, company='foo')
    db_utils.seed_models(vendor)
    contact = ALWUserContactFactory.build(contact_id=111, email=email)
    db_utils.seed_models(contact)
    user = ALWUserVendContactFactory.build(
        user_id=123, vendor_id=7123, contact_id=111, auth0_user_id=auth0id
    )
    db_utils.seed_models(user)
    db_utils.seed_models(user)
    if with_roles:
        db_utils.seed_models(
            VendContactRolesFactory.build(vend_contact_id=user.user_id, role_id=100)
        )

    identity_by_email_response = Response(
        {
            'default_brand': 'awal',
        }
    )

    with (
        context,
        mocker.patch('users.models.identities.get_session'),
        mocker.patch(
            'users.models.user_info_raw.get_identity_by_email',
            return_value=identity_by_email_response,
        ),
    ):
        result = user_info_raw.fetch_vend_contact_details(user_ids)

    assert result.status == expected_status
    if result.status == 200:
        user_dict = user_info_raw._format_vend_contact_data(user)
        user_dict.update(user_info_raw._format_contact_data(contact))
        user_dict['currency'] = None
        user_dict['company'] = vendor.company
        if with_roles:
            user_dict['role_ids'] = [100]
        else:
            user_dict['role_ids'] = []
        user_dict['default_brand'] = expected_brand
        user_dict['wel_email_sender'] = 2233
        assert result.message == user_dict
    else:
        assert result.errors['message'] == 'User not found.'


@pytest.mark.parametrize(('user_ids', 'expected_status'), [(123, 200), (900, 404)])
@db_utils.test_schema
def test_fetch_vend_contact_raw_with_roles(context, user_ids, expected_status):
    """Test fetch_vend_contact_raw_with_roles for different user ids."""
    vendor = VendorFactory.build(vendor_id=7123, company='foo')
    db_utils.seed_models(vendor)
    contact = ALWUserContactFactory.build(contact_id=111)
    db_utils.seed_models(contact)
    user = ALWUserVendContactFactory.build(user_id=123, vendor_id=7123, contact_id=111)
    db_utils.seed_models(user)
    db_utils.seed_models(VendContactRolesFactory.build(vend_contact_id=user.user_id, role_id=100))

    with context:
        result = user_info_raw.fetch_vend_contact_raw_with_roles(user_ids)

    assert result.status == expected_status
    if result.status == 200:
        user_dict = user_info_raw._format_vend_contact_data(user)
        user_dict.update(user_info_raw._format_contact_data(contact))
        user_dict['company'] = vendor.company
        user_dict['role_ids'] = [100]
        assert result.message == user_dict
    else:
        assert result.errors['message'] == 'User not found.'


@pytest.mark.parametrize(
    ('loginname', 'password', 'auth0_id', 'expected_status', 'expected_code'),
    [
        # non-migrated user with valid credentials
        ('login', 'pass', None, 200, None),
        # migrated user with valid legacy credentials
        ('login', 'pass', 'auth01', 404, 'migrated_user'),
        # non-migrated user with invalid username
        ('foo', 'bar', None, 404, 'username_dont_match'),
        # non-migrated user with valid username but invalid password
        ('login', 'dummy', None, 404, 'username_password_dont_match'),
    ],
)
@db_utils.test_schema
def test_fetch_alw_user_by_login(
    context, loginname, password, auth0_id, expected_status, expected_code
):
    """Test fetch_alw_user_by_login."""
    contact = ALWUserContactFactory.build(contact_id=111)
    db_utils.seed_models(contact)
    user = ALWUserVendContactFactory.build(
        user_id=123, contact_id=111, login='login', password_hash='pass', auth0_user_id=auth0_id
    )
    db_utils.seed_models(user)

    with context:
        result = user_info_raw.fetch_alw_user_by_login(loginname, password)

    assert result.status == expected_status
    if result.status == 200:
        assert result.message == {
            'contact_email': contact.email,
            'password_hash': user.password_hash,
            'vend_contact_id': user.user_id,
            'login': user.login,
        }
    else:
        assert result.errors['code'] == expected_code


@pytest.mark.parametrize(
    ('email', 'expected_status', 'expected_code'),
    [
        # valid alw user
        ('email', 200, None),
        # invalid alw user
        ('invalid_email', 404, 'email_dont_match'),
    ],
)
@db_utils.test_schema
def test_fetch_alw_user_by_email(context, email, expected_status, expected_code):
    """Test fetch_alw_user_by_email."""
    contact = ALWUserContactFactory.build(contact_id=111)
    db_utils.seed_models(contact)
    user = ALWUserVendContactFactory.build(user_id=123, contact_id=111)
    db_utils.seed_models(user)

    with context:
        result = user_info_raw.fetch_alw_users_by_email(email)

    assert result.status == expected_status
    if result.status == 200:
        assert result.message == {
            'items': [
                {'email': contact.email, 'user_id': user.user_id, 'vendor_id': user.vendor_id}
            ]
        }
    else:
        assert result.errors['code'] == expected_code