"""Tests for VendorContract model."""

from unittest.mock import MagicMock

import pytest
from flask import g

from contracts import response
from contracts.connectors import mysql
from contracts.models import vendor_contract


def test_get_digital_mech_admin_found(db_fixture):
    """Test getting mech admin object."""
    expected_response = {
        'vendor_id': 1,
        'ringtone_publishing_type': 'both',
        'oms_type': 'both',
    }
    response = vendor_contract.get_digital_mech_admin(vendor_contract_id=1, vendor_id=1)
    assert response.status == 200
    assert response.message == expected_response


def test_get_digital_mech_admin_not_found(db_fixture):
    """Test response status when given vendor is not mech admin."""
    response = vendor_contract.get_digital_mech_admin(vendor_contract_id=1, vendor_id=5)
    assert response.status == 404


def setup_mock_active_contract(monkeypatch, active_contract):
    """Create an active contract.

    Args:
        monkeypatch (Patch): the monkeypatch.
        active_contract: a single active contract for a vendor
    """
    monkeypatch.setattr(mysql, '_db_engine', MagicMock())
    cursor = MagicMock()
    cursor.fetchone.return_value = active_contract

    connection = MagicMock()
    mysql._db_engine.raw_connection.return_value = connection
    connection.cursor.return_value = cursor


def test_get_active_contract(monkeypatch):
    """Test getting active contract for a vendor."""
    active_contract = (1, 1)
    setup_mock_active_contract(monkeypatch, active_contract)

    vendor_id = 1
    expected_response = {'vendor_contract_id': 1, 'vendor_id': vendor_id}
    response = vendor_contract.get_active_contract(vendor_id)
    assert response.message == expected_response


def test_no_active_contract(monkeypatch):
    """Test getting no active contract for a vendor."""
    active_contract = ()
    setup_mock_active_contract(monkeypatch, active_contract)

    vendor_id = 1
    expected_response = 404
    response = vendor_contract.get_active_contract(vendor_id)
    assert response.status == expected_response


def test_get_contract(db_fixture, fixture_vendor_contract):
    """Test getting contract."""
    expected_response = fixture_vendor_contract
    response = vendor_contract.get_contract(1)
    assert response.message == expected_response


def test_get_missing_contract(db_fixture):
    """Test getting missing contract."""
    expected_response = 404
    response = vendor_contract.get_contract(100)
    assert response.status == expected_response


def test_get_physical_mech_admin(db_fixture):
    """Test getting physical mech admin object."""
    response = vendor_contract.get_physical_mech_admin(
        vendor_contract_id=1, vendor_id=1
    )
    expected_message = {'physical_track_publishing_type': 'both', 'vendor_id': 1}
    assert response.status == 200
    assert response.message == expected_message


def test_get_mech_admin_for_account(db_fixture):
    """Test getting digital and physical physical mech admin object."""
    response = vendor_contract.get_mech_admin_for_account(
        vendor_contract_id=1, vendor_id=1
    )
    expected_message = {'mechadmin_digital': True, 'mechadmin_physical': True}

    assert response.status == 200
    assert response.message == expected_message


def test_get_physical_mech_admin_not_found(db_fixture):
    """Test response status when given vendor is not mech admin."""
    response = vendor_contract.get_physical_mech_admin(
        vendor_contract_id=1, vendor_id=5
    )
    assert response.status == 404


@pytest.mark.parametrize(
    'get_digital_return_value, get_physical_return_value,'
    'expected_digital_value, expected_physical_value',
    [
        (response.Response(), response.create_not_found_response(), True, False),
        (response.create_not_found_response(), response.Response(), False, True),
        (
            response.create_not_found_response(),
            response.create_not_found_response(),
            False,
            False,
        ),
        (response.Response(), response.Response(), True, True),
    ],
)
def test_get_mech_admin_for_account_correct_response(
    mocker,
    get_digital_return_value,
    get_physical_return_value,
    expected_digital_value,
    expected_physical_value,
):
    """Test getting digital and physical physical mech admin object."""
    mock_is_digital_mech_admin = mocker.patch.object(
        vendor_contract, 'get_digital_mech_admin', return_value=get_digital_return_value
    )
    mock_is_physical_mech_admin = mocker.patch.object(
        vendor_contract,
        'get_physical_mech_admin',
        return_value=get_physical_return_value,
    )
    response = vendor_contract.get_mech_admin_for_account(
        vendor_contract_id=1, vendor_id=1
    )
    expected_message = {
        'mechadmin_digital': expected_digital_value,
        'mechadmin_physical': expected_physical_value,
    }

    mock_is_digital_mech_admin.assert_called_with(1, 1)
    mock_is_physical_mech_admin.assert_called_with(1, 1)
    assert response.status == 200
    assert response.message == expected_message


@pytest.mark.parametrize(
    'contract_id, expected_message, expected_status',
    [
        (1, {}, 200),
        (2, {'id': 1, 'service_type': 'Artist Services'}, 200),
        (3, None, 404),
    ],
)
def test_get_contract_service_type(
    db_fixture, contract_id, expected_message, expected_status
):
    """Test getting contract service type."""
    response = vendor_contract.get_contract_service_type(contract_id)
    assert response.message == expected_message
    assert response.status == expected_status


def test_get_vendor_currency():
    """Test get vendor currency."""
    vendor_id = 1
    expected_result = {
        'id': 1,
        'vendor_id': 1,
        'currency_id': 1,
        'code': 'USD',
        'symbol': 'USD',
    }

    result = vendor_contract.get_vendor_currency(vendor_id)

    assert result.message == expected_result


def setup_mock_update_vendor_contract(
    monkeypatch, update_result, vendor_contract_result, service_type_dict_result
):
    """Mock the database session for updating vendor contract service type ID."""
    monkeypatch.setattr(mysql, 'db_session', MagicMock())
    session_mock = MagicMock()
    session_mock.query.return_value.filter.return_value.update.return_value = (
        update_result
    )
    session_mock.query.return_value.filter.return_value.one_or_none.return_value = (
        vendor_contract_result
    )
    if vendor_contract_result:
        vendor_contract_result.service_type.to_dict.return_value = (
            service_type_dict_result
        )
    mysql.db_session.return_value.__enter__.return_value = session_mock


def test_update_vendor_contract_service_type_id_null(monkeypatch):
    """Test updating vendor contract service type when service type is None."""
    vendor_contract_result = MagicMock()

    setup_mock_update_vendor_contract(
        monkeypatch,
        update_result=1,
        vendor_contract_result=vendor_contract_result,
        service_type_dict_result={},
    )

    result = vendor_contract.update_vendor_contract_service_type_id(None, 123, 22)
    assert result == 1


def test_update_vendor_contract_service_type_id_not_found(monkeypatch, app_context):
    """Test when no contract is found, raising an exception."""
    g.log = MagicMock()
    setup_mock_update_vendor_contract(
        monkeypatch,
        update_result=0,
        vendor_contract_result=None,
        service_type_dict_result=None,
    )

    with pytest.raises(Exception) as exc_info:
        vendor_contract.update_vendor_contract_service_type_id(4, 123, 999)

    assert (
        str(exc_info.value)
        == 'No contract found for vendor_id 123 and contract_id 999.'
    )


def test_update_vendor_contract_service_type_id_success(monkeypatch):
    """Test updating vendor contract service type when contract exists."""
    vendor_contract_result = MagicMock()
    service_type_dict_result = {'id': 1, 'service_type': 'Artist Services (Full)'}

    setup_mock_update_vendor_contract(
        monkeypatch,
        update_result=1,
        vendor_contract_result=vendor_contract_result,
        service_type_dict_result=service_type_dict_result,
    )
    result = vendor_contract.update_vendor_contract_service_type_id(4, 123, 22)
    assert result == 1