"""Test validation functions."""
from unittest.mock import patch

from adjustment.validate.validation import Validation

@patch('adjustment.validate.validation.DataClass')
def test_validate_account(mock_data_class, mock_adjustment, mock_account_ids):
    """Test to validate_account function for valid account ids."""
    mock_data_class.account_ids = mock_account_ids
    validation = Validation(mock_adjustment)
    validation.validate_account()
    assert validation._validation_errors == []


def test_validate_account_no_account_id(mock_adjustment):
    """Test to validate_account function when account field is empty."""
    mock_adjustment[0] = None
    validation = Validation(mock_adjustment)
    validation.validate_account()
    assert validation._validation_errors == ['Account Id required']


@patch('adjustment.validate.validation.DataClass')
def test_validate_account_not_exist(mock_data_class, mock_adjustment, mock_account_ids):
    """Test to validate_account function when account doesn't exist in abacus db."""
    mock_data_class.account_ids = mock_account_ids
    mock_adjustment[0] = 1234
    validation = Validation(mock_adjustment)
    validation.validate_account()
    assert validation._validation_errors == ['1234 Account ID does not exist in Abacus']


@patch('adjustment.validate.validation.DataClass')
def test_validate_contract(mock_data_class, mock_adjustment, mock_contract_ids):
    """Test to validate_contract function for valid contract ids."""
    mock_data_class.contract_ids = mock_contract_ids
    validation = Validation(mock_adjustment)
    validation.validate_contract()
    assert validation._validation_errors == []


def test_validate_contract_no_contract_id(mock_adjustment):
    """Test to validate_contract function when contract field is empty."""
    mock_adjustment[1] = None
    validation = Validation(mock_adjustment)
    validation.validate_contract()
    assert validation._validation_errors == ['Contract Id required']


@patch('adjustment.validate.validation.DataClass')
def test_validate_contract_not_exist(mock_data_class, mock_adjustment, mock_contract_ids):
    """Test to validate_contract function when contract doesn't exist in abacus db."""
    mock_data_class.contract_ids = mock_contract_ids
    mock_adjustment[1] = 1234
    validation = Validation(mock_adjustment)
    validation.validate_contract()
    assert validation._validation_errors == ['1234 Contract ID does not exist in Abacus']


def test_validate_amount(mock_adjustment):
    """Test to validate_amount function for valid amount."""
    validation = Validation(mock_adjustment)
    validation.validate_amount()
    assert validation._validation_errors == []


def test_validate_no_amount_value(mock_adjustment):
    """Test to validate_amount function when amount field is empty."""
    mock_adjustment[3] = None
    validation = Validation(mock_adjustment)
    validation.validate_amount()
    assert validation._validation_errors == ['Amount is required / Amount cannot be zero']


def test_validate_zero_amount(mock_adjustment):
    """Test to validate_amount function for zero amount."""
    mock_adjustment[3] = 0
    validation = Validation(mock_adjustment)
    validation.validate_amount()
    assert validation._validation_errors == ['Amount is required / Amount cannot be zero']


def test_validate_currency(mock_adjustment):
    """Test to validate_currency function for valid currency."""
    validation = Validation(mock_adjustment)
    validation.validate_currency()
    assert validation._validation_errors == []


def test_validate_currency_field_empty(mock_adjustment):
    """Test to validate_currency function when currency field is empty."""
    mock_adjustment[4] = None
    validation = Validation(mock_adjustment)
    validation.validate_currency()
    assert validation._validation_errors == ['Currency code is required']


def test_validate_currency_not_exist(mock_adjustment):
    """Test to validate_currency function for invalid currency."""
    mock_adjustment[4] = 'Test'
    validation = Validation(mock_adjustment)
    validation.validate_currency()
    assert validation._validation_errors == ['Currency code is not supported']


def test_validate_distribution_type(mock_adjustment):
    """Test to validate_distribution_type function.
    
    for valid distribution_type and when upc field have value.
    """
    validation = Validation(mock_adjustment)
    validation.validate_distribution_type()
    assert validation._validation_errors == []


def test_validate_invalid_distribution_type(mock_adjustment):
    """Test to validate_distribution_type function for invalid distribution_type."""
    mock_adjustment[11] = 'Invalid Distribution Type'
    validation = Validation(mock_adjustment)
    validation.validate_distribution_type()
    assert validation._validation_errors == ['Distribution type not supported']


def test_validate_invalid_distribution_type(mock_adjustment):
    """Test to validate_distribution_type function when upc field is blank."""
    mock_adjustment[2] = None
    validation = Validation(mock_adjustment)
    validation.validate_distribution_type()
    assert validation._validation_errors == ['Distribution type must be blank if UPC is blank']


def test_validate_comment(mock_adjustment):
    """Test to validate_comment when comment length is more than 180 characters."""
    mock_adjustment[10] = 'Override royalty to Influence X Music II LP' * 20
    validation = Validation(mock_adjustment)
    validation.validate_comment()
    assert validation._validation_errors == ['Comment maximum length is 180 characters']


@patch('adjustment.validate.validation.DataClass')
def test_validate_adjustment_type(mock_data_class, mock_adjustment, mock_adjustments_types):
    """Test to validate_adjustment_type function for valid adjustment type."""
    mock_data_class.adjustment_types = mock_adjustments_types
    validation = Validation(mock_adjustment)
    validation.validate_adjustment_type()
    assert validation._validation_errors == []


@patch('adjustment.validate.validation.DataClass')
def test_validate_invalid_adjustment_type(mock_data_class, mock_adjustment, mock_adjustments_types):
    """Test to validate_adjustment_type function for invalid adjustment type."""
    mock_data_class.adjustment_types = mock_adjustments_types
    mock_adjustment[9] = 'Invalid Adjustment'
    validation = Validation(mock_adjustment)
    validation.validate_adjustment_type()
    assert validation._validation_errors == ['Adjustment type is not supported by Abacus']


def test_validate_no_adjustment_type(mock_adjustment):
    """Test to validate_adjustment_type function when adjustment type field empty."""
    mock_adjustment[9] = None
    validation = Validation(mock_adjustment)
    validation.validate_adjustment_type()
    assert validation._validation_errors == ['Adjustment type is required']


def test_validate_activity_month(mock_adjustment):
    """Test to validate_activity_month function."""
    validation = Validation(mock_adjustment)
    validation.validate_activity_month()
    assert validation._validation_errors == []


def test_validate_no_activity_month(mock_adjustment):
    """Test to validate_activity_month function when activity_month field is empty."""
    mock_adjustment[6] = None
    validation = Validation(mock_adjustment)
    validation.validate_activity_month()
    assert validation._validation_errors == ['Activity month is required']


def test_validate_invalid_activity_month(mock_adjustment):
    """Test to validate_activity_month function for invalid activity month."""
    mock_adjustment[6] = 15
    validation = Validation(mock_adjustment)
    validation.validate_activity_month()
    assert validation._validation_errors == ['Activity month must be a valid month number']


def test_validate_apply_month(mock_adjustment):
    """Test to validate_apply_month function."""
    validation = Validation(mock_adjustment)
    validation.validate_apply_month()
    assert validation._validation_errors == []


def test_validate_no_apply_month(mock_adjustment):
    """Test to validate_apply_month function when apply_month field is empty."""
    mock_adjustment[8] = None
    validation = Validation(mock_adjustment)
    validation.validate_apply_month()
    assert validation._validation_errors == ['Apply month is required']


def test_validate_invalid_apply_month(mock_adjustment):
    """Test to validate_apply_month function for invalid apply month."""
    mock_adjustment[8] = 15
    validation = Validation(mock_adjustment)
    validation.validate_apply_month()
    assert validation._validation_errors == ['Apply month must be a valid month number']


def test_validate_activity_year(mock_adjustment):
    """Test to validate_activity_year function."""
    validation = Validation(mock_adjustment)
    validation.validate_activity_year()
    assert validation._validation_errors == []


def test_validate_no_activity_year(mock_adjustment):
    """Test to validate_activity_year function when activity_year field is empty."""
    mock_adjustment[5] = None
    validation = Validation(mock_adjustment)
    validation.validate_activity_year()
    assert validation._validation_errors == ['Activity year is required']


def test_validate_invalid_activity_year(mock_adjustment):
    """Test to validate_activity_year function for invalid activity year."""
    mock_adjustment[5] = 20222
    validation = Validation(mock_adjustment)
    validation.validate_activity_year()
    assert validation._validation_errors == ['Activity year must be four digits']


def test_validate_apply_year(mock_adjustment):
    """Test to validate_apply_year function."""
    validation = Validation(mock_adjustment)
    validation.validate_apply_year()
    assert validation._validation_errors == []


def test_validate_no_apply_year(mock_adjustment):
    """Test to validate_apply_year function when apply statement year field is empty."""
    mock_adjustment[7] = None
    validation = Validation(mock_adjustment)
    validation.validate_apply_year()
    assert validation._validation_errors == ['Apply year is required']


def test_validate_invalid_apply_year(mock_adjustment):
    """Test to validate_apply_year function for invalid activity year."""
    mock_adjustment[7] = 20222
    validation = Validation(mock_adjustment)
    validation.validate_apply_year()
    assert validation._validation_errors == ['Apply year must be four digits']


@patch('adjustment.validate.validation.DataClass')
def test_validate_activity_date(mock_data_class, mock_adjustment, mock_statement_periods):
    """Test to validate_activity_date function for valid activity year and month."""
    mock_data_class.statement_periods = mock_statement_periods
    validation = Validation(mock_adjustment)
    validation.validate_activity_date()
    assert validation._validation_errors == []


@patch('adjustment.validate.validation.DataClass')
def test_validate_invalid_activity_date(mock_data_class, mock_adjustment, mock_statement_periods):
    """Test to validate_activity_date function for invalid activity year and month."""
    mock_adjustment[6] = 2
    mock_data_class.statement_periods = mock_statement_periods
    validation = Validation(mock_adjustment)
    validation.validate_activity_date()
    assert validation._validation_errors == ['Activity period does not exist in Abacus']


@patch('adjustment.validate.validation.DataClass')
def test_validate_apply_date(mock_data_class, mock_adjustment, mock_statement_periods):
    """Test to validate_apply_date function for valid apply statement year and month."""
    mock_data_class.statement_periods = mock_statement_periods
    validation = Validation(mock_adjustment)
    validation.validate_apply_date()
    assert validation._validation_errors == []


@patch('adjustment.validate.validation.DataClass')
def test_validate_invalid_apply_date(mock_data_class, mock_adjustment, mock_statement_periods):
    """Test to validate_apply_date function for invalid apply statement year and month."""
    mock_adjustment[8] = 12
    mock_data_class.statement_periods = mock_statement_periods
    validation = Validation(mock_adjustment)
    validation.validate_apply_date()
    assert validation._validation_errors == ['Apply period is either missing in Abacus or already closed']


@patch('adjustment.validate.validation.Contract')
def test_validate_upc(mock_contract, mock_adjustment):
    """Test to validate_upc function for valid upc."""
    mock_contract.check_contract_has_upc_attached.return_value = True
    validation = Validation(mock_adjustment)
    validation.validate_upc()
    assert validation._validation_errors == []


def test_validate_upc_blank_distribute_type(mock_adjustment):
    """Test to validate_upc function when distribution type field is empty."""
    mock_adjustment[11] = None
    validation = Validation(mock_adjustment)
    validation.validate_upc()
    assert validation._validation_errors == ['UPC must be blank if distribution type is blank']


def test_validate_invalid_upc(mock_adjustment):
    """Test to validate_upc function for invalid upc length."""
    mock_adjustment[2] = '1978621'
    validation = Validation(mock_adjustment)
    validation.validate_upc()
    assert validation._validation_errors == ['UPC must be 12 or 13 characters long']


@patch('adjustment.validate.validation.Contract')
def test_validate_contract_upc(mock_contract, mock_adjustment):
    """Test to validate_contract_upc function."""
    validation = Validation(mock_adjustment)

    mock_contract.return_value.check_contract_has_upc_attached.return_value = True
    assert validation.validate_contract_upc() == True

    mock_contract.return_value.check_contract_has_upc_attached_ignore_leading_zero.return_value = True
    assert validation.validate_contract_upc() == True

    mock_contract.return_value.check_contract_has_upc_attached_all_ignore_leading_zero.return_value = True
    assert validation.validate_contract_upc() == True

    mock_contract.return_value.check_upc_display_upc_mapping.return_value = True
    assert validation.validate_contract_upc() == True

    mock_contract.return_value.check_contract_label_owns_upc.return_value = True
    assert validation.validate_contract_upc() == True

    mock_contract.return_value.check_contract_has_upc_attached.return_value = False
    mock_contract.return_value.check_contract_has_upc_attached_ignore_leading_zero.return_value = False
    mock_contract.return_value.check_contract_has_upc_attached_all_ignore_leading_zero.return_value = False
    mock_contract.return_value.check_upc_display_upc_mapping.return_value = False
    mock_contract.return_value.check_contract_label_owns_upc.return_value = False
    assert validation.validate_contract_upc() == False