"""Unit tests for the adjustments validation Snowflake executor."""

from unittest.mock import MagicMock, patch

from abacus_common_logic.adjustments_validation.snowflake.executor import (
    AdjustmentsValidationSnowflakeExecutor,
)


@patch(
    'abacus_common_logic.adjustments_validation.snowflake.executor.SnowflakeSQLExecutor.__init__',
    MagicMock(),
)
def test_fetch_close_balance_statuses(sf_config_mock):
    """Test fetching the payment entities `close_balance` status."""
    statement_period_id = 1

    rows = [
        {'PAYMENT_ENTITY_ID': 1, 'ACTION_STATUS': 'init'},
        {'PAYMENT_ENTITY_ID': 2, 'ACTION_STATUS': 'complete'},
    ]

    fetch_mock = MagicMock(return_value=rows)
    executor = AdjustmentsValidationSnowflakeExecutor(sf_config_mock)
    executor.fetchall = fetch_mock

    results = executor.fetch_close_balance_statuses(statement_period_id)

    assert results == {
        '1': 'init',
        '2': 'complete',
    }


@patch(
    'abacus_common_logic.adjustments_validation.snowflake.executor.SnowflakeSQLExecutor.__init__',
    MagicMock(),
)
def test_fetch_accounts(sf_config_mock):
    """Test fetching accounts."""
    account_ids = {'1', '2', '3'}

    rows = [
        {
            'ACCOUNT_ID': 1,
        },
        {
            'ACCOUNT_ID': 2,
        },
    ]

    fetch_mock = MagicMock(return_value=rows)
    executor = AdjustmentsValidationSnowflakeExecutor(sf_config_mock)
    executor.fetchall = fetch_mock

    results = executor.fetch_accounts(account_ids)

    assert len(results) == 2
    assert '1' in results
    assert '2' in results
    assert '3' not in results

    # Empty args passed in
    assert executor.fetch_accounts(set()) == set()


@patch(
    'abacus_common_logic.adjustments_validation.snowflake.executor.SnowflakeSQLExecutor.__init__',
    MagicMock(),
)
def test_fetch_account_contracts(sf_config_mock):
    """Test fetching account contracts."""
    account_contract_map = {'1': {'11', '111'}, '2': {'22', '666'}}

    rows = [
        {
            'ACCOUNT_ID': 1,
            'CONTRACT_ID': 11,
        },
        {
            'ACCOUNT_ID': 1,
            'CONTRACT_ID': 111,
        },
        {
            'ACCOUNT_ID': 2,
            'CONTRACT_ID': 22,
        },
    ]

    fetch_mock = MagicMock(return_value=rows)
    executor = AdjustmentsValidationSnowflakeExecutor(sf_config_mock)
    executor.fetchall = fetch_mock

    results = executor.fetch_account_contracts(account_contract_map)

    assert len(results) == 2
    assert len(results['1']) == 2
    assert len(results['2']) == 1
    assert '11' in results['1']
    assert '111' in results['1']
    assert '22' in results['2']
    assert '666' not in results['2']

    # Empty args passed in
    assert executor.fetch_account_contracts({}) == {}


@patch(
    'abacus_common_logic.adjustments_validation.snowflake.executor.SnowflakeSQLExecutor.__init__',
    MagicMock(),
)
def test_fetch_payment_entities(sf_config_mock):
    """Test fetching payment entities."""
    account_ids = {'1', '2', '3'}

    rows = [
        {
            'ACCOUNT_ID': 1,
            'PAYMENT_ENTITY_ID': 11,
        },
        {
            'ACCOUNT_ID': 2,
            'PAYMENT_ENTITY_ID': 22,
        },
    ]

    fetch_mock = MagicMock(return_value=rows)
    executor = AdjustmentsValidationSnowflakeExecutor(sf_config_mock)
    executor.fetchall = fetch_mock

    results = executor.fetch_payment_entities(account_ids)

    assert results == {
        '1': '11',
        '2': '22',
    }

    # Empty args passed in
    assert executor.fetch_payment_entities(set()) == {}


@patch(
    'abacus_common_logic.adjustments_validation.snowflake.executor.SnowflakeSQLExecutor.__init__',
    MagicMock(),
)
def test_fetch_display_upcs(sf_config_mock):
    """Test fetching display upcs."""
    display_upcs = {'111122223333', '444455556666', '777788889999'}

    rows = [
        {
            'DISPLAY_UPC': '111122223333',
            'UPCS': '111111111111,222222222222',
        },
        {
            'DISPLAY_UPC': '444455556666',
            'UPCS': '444444444444',
        },
    ]

    fetch_mock = MagicMock(return_value=rows)
    executor = AdjustmentsValidationSnowflakeExecutor(sf_config_mock)
    executor.fetchall = fetch_mock

    results = executor.fetch_display_upcs(display_upcs)

    assert len(results) == 2
    assert len(results['111122223333']) == 2
    assert len(results['444455556666']) == 1
    assert '111111111111' in results['111122223333']
    assert '222222222222' in results['111122223333']
    assert '444444444444' in results['444455556666']
    assert '777788889999' not in results

    # Empty args passed in
    assert executor.fetch_display_upcs(set()) == {}


@patch(
    'abacus_common_logic.adjustments_validation.snowflake.executor.SnowflakeSQLExecutor.__init__',
    MagicMock(),
)
def test_fetch_product_terms(sf_config_mock):
    """Test fetching product terms."""
    contract_ids = {'1', '2', '3'}

    rows = [
        {
            'CONTRACT_ID': 1,
            'TERM_TYPE': 'product',
            'ATTACHMENTS': '["111111111111", "222222222222"]',
        },
        {
            'CONTRACT_ID': 2,
            'TERM_TYPE': 'product',
            'ATTACHMENTS': '["333333333333"]',
        },
        {
            'CONTRACT_ID': 3,
            'TERM_TYPE': 'product',
            'ATTACHMENTS': '',
        },
        {
            'CONTRACT_ID': 4,
            'TERM_TYPE': 'product',
            'ATTACHMENTS': None,
        },
    ]

    fetch_mock = MagicMock(return_value=rows)
    executor = AdjustmentsValidationSnowflakeExecutor(sf_config_mock)
    executor.fetchall = fetch_mock

    results = executor.fetch_product_terms(contract_ids)

    assert len(results) == 2
    assert len(results['1']) == 2
    assert len(results['2']) == 1
    assert '111111111111' in results['1']
    assert '222222222222' in results['1']
    assert '333333333333' in results['2']
    assert '3' not in results
    assert '4' not in results

    # Empty args passed in
    assert executor.fetch_product_terms(set()) == {}


@patch(
    'abacus_common_logic.adjustments_validation.snowflake.executor.SnowflakeSQLExecutor.__init__',
    MagicMock(),
)
def test_fetch_label_terms(sf_config_mock):
    """Test fetching label terms."""
    contract_ids = {'1', '2', '3'}

    rows = [
        {
            'CONTRACT_ID': 1,
            'TERM_TYPE': 'label',
            'ATTACHMENTS': '["1", "11"]',
        },
        {
            'CONTRACT_ID': 2,
            'TERM_TYPE': 'product',
            'ATTACHMENTS': '["2"]',
        },
        {
            'CONTRACT_ID': 3,
            'TERM_TYPE': 'product',
            'ATTACHMENTS': '',
        },
        {
            'CONTRACT_ID': 4,
            'TERM_TYPE': 'product',
            'ATTACHMENTS': None,
        },
    ]

    fetch_mock = MagicMock(return_value=rows)
    executor = AdjustmentsValidationSnowflakeExecutor(sf_config_mock)
    executor.fetchall = fetch_mock

    results = executor.fetch_label_terms(contract_ids)

    assert len(results) == 2
    assert len(results['1']) == 2
    assert len(results['2']) == 1
    assert '1' in results['1']
    assert '11' in results['1']
    assert '2' in results['2']
    assert '3' not in results
    assert '4' not in results

    # Empty args passed in
    assert executor.fetch_label_terms(set()) == {}


@patch(
    'abacus_common_logic.adjustments_validation.snowflake.executor.SnowflakeSQLExecutor.__init__',
    MagicMock(),
)
def test_fetch_account_upcs(sf_config_mock):
    """Test fetching UPCs by Account."""
    account_upc_map = {
        '1': {'111111111111', '101010101010'},
        '2': {'222222222222', '202020202020'},
        '3': {'111111111111'},
    }

    rows = [
        {
            'VENDOR_ID': 1,
            'UPC': '111111111111',
            'DISPLAY_UPC': '111111111111',
        },
        {
            'VENDOR_ID': 1,
            'UPC': '101010101010',
            'DISPLAY_UPC': '010101010101',
        },
        {
            'VENDOR_ID': 2,
            'UPC': '222222222222',
            'DISPLAY_UPC': '222222222222',
        },
    ]

    fetch_mock = MagicMock(return_value=rows)
    executor = AdjustmentsValidationSnowflakeExecutor(sf_config_mock)
    executor.fetchall = fetch_mock

    results = executor.fetch_account_upcs(account_upc_map)

    assert len(results) == 2
    assert len(results['1']) == 3
    assert len(results['2']) == 1
    assert '111111111111' in results['1']
    assert '101010101010' in results['1']
    assert '010101010101' in results['1']
    assert '222222222222' in results['2']
    assert '3' not in results

    # Empty args passed in
    assert executor.fetch_account_upcs({}) == {}


@patch(
    'abacus_common_logic.adjustments_validation.snowflake.executor.SnowflakeSQLExecutor.__init__',
    MagicMock(),
)
def test_fetch_statement_periods(sf_config_mock):
    """Test fetching statement periods."""
    statement_years = {'2024', '2025', '2026'}

    rows = [
        {
            'STATEMENT_YEAR': 2024,
            'STATEMENT_MONTH': 1,
            'STATEMENT_PERIOD_STATUS': 'closed',
        },
        {
            'STATEMENT_YEAR': 2024,
            'STATEMENT_MONTH': 2,
            'STATEMENT_PERIOD_STATUS': 'closed',
        },
        {
            'STATEMENT_YEAR': 2025,
            'STATEMENT_MONTH': 1,
            'STATEMENT_PERIOD_STATUS': 'open',
        },
    ]

    fetch_mock = MagicMock(return_value=rows)
    executor = AdjustmentsValidationSnowflakeExecutor(sf_config_mock)
    executor.fetchall = fetch_mock

    results = executor.fetch_statement_periods(statement_years)

    assert results == {
        '1/2024': 'closed',
        '2/2024': 'closed',
        '1/2025': 'open',
    }

    # Empty args passed in
    assert executor.fetch_statement_periods(set()) == {}


@patch(
    'abacus_common_logic.adjustments_validation.snowflake.executor.SnowflakeSQLExecutor.__init__',
    MagicMock(),
)
def test_fetch_adjustment_types(sf_config_mock):
    """Test fetching adjustment types."""
    rows = [
        {
            'TYPE_NAME': 'Adjustment',
        },
        {
            'TYPE_NAME': 'Settlement',
        },
    ]

    fetch_mock = MagicMock(return_value=rows)
    executor = AdjustmentsValidationSnowflakeExecutor(sf_config_mock)
    executor.fetchall = fetch_mock

    results = executor.fetch_adjustment_types()

    assert len(results) == 2
    assert 'adjustment' in results
    assert 'settlement' in results