"""TaxFormInfo models tests."""

import datetime
from unittest.mock import patch
from uuid import uuid4

from abacus_common_logic.connectors.database import db
import pytest
from werkzeug.exceptions import HTTPException

from payee.constants.constants import TAX_FORM_TYPES
from payee.logic.secure_document import (
    create_secure_document_details,
    has_secure_document_details,
)
from payee.models.tax_form import (
    TaxFormInfo,
    USTaxFormW8BENDocument,
    USTaxFormW8BENEDocument,
    USTaxFormW8ECIDocument,
    USTaxFormW8IMYDocument,
    USTaxFormW9Document,
)
from tests.constants import MOCK_AUDIT_FIELDS, MOCK_TAX_FORM_DETAILS


def test_tax_form_info_model(account_fixtures, account_payee_fixtures):
    """Test tax form info model."""
    TaxFormInfo.create(
        tax_form_type='W9',
        account_payee_id=1,
        signed_date=datetime.date(2024, 2, 1),
    )

    TaxFormInfo.create(
        tax_form_type='W9',
        account_payee_id=2,
        signed_date=datetime.date(2025, 2, 1),
        expiration_date=datetime.date(2027, 2, 1),
    )

    records = TaxFormInfo.query.all()
    recordW9, recordW8 = records[0], records[1]

    assert len(records) == 2
    assert recordW9.tax_form_type == 'W9'
    assert recordW9.account_payee_id == 1
    assert recordW9.signed_date == datetime.date(2024, 2, 1)
    assert recordW9.created_at is not None
    assert recordW9.created_by == 'default_user_id'
    assert recordW9.last_modified == recordW9.created_at
    assert recordW9.last_modified_by == 'default_user_id'
    assert recordW9.deleted_at is None
    assert recordW9.deleted_by is None

    recordW9.last_modified = datetime.datetime(2025, 2, 1)
    db.session.commit()

    recordW9 = TaxFormInfo.query.get(recordW9.account_payee_tax_form_info_id)
    assert recordW9.tax_form_type == 'W9'
    assert recordW9.last_modified == datetime.datetime(2025, 2, 1)

    assert recordW8.tax_form_type == 'W9'
    assert recordW8.account_payee_id == 2
    assert recordW8.signed_date == datetime.date(2025, 2, 1)
    assert recordW8.expiration_date == datetime.date(2027, 2, 1)
    assert recordW8.created_at is not None
    assert recordW8.created_by == 'default_user_id'
    assert recordW8.last_modified == recordW9.created_at
    assert recordW8.last_modified_by == 'default_user_id'
    assert recordW8.deleted_at is None
    assert recordW8.deleted_by is None

    revision_id = str(uuid4())
    recordW8.delete_with_revision(recordW8, revision_id)

    recordW8 = TaxFormInfo.query.get(recordW8.account_payee_tax_form_info_id)
    assert recordW8.deleted_at is not None
    assert recordW8.deleted_by == 'default_user_id'
    assert recordW8.revision_id == revision_id

    with pytest.raises(HTTPException):
        TaxFormInfo.get_by_id_or_error(recordW8.account_payee_tax_form_info_id)

    assert TaxFormInfo.get_by_id(recordW8.account_payee_tax_form_info_id) is None
    assert TaxFormInfo.get_by_account_payee_id(recordW8.account_payee_id) is None

    result = TaxFormInfo.get_by_account_payee_id(recordW9.account_payee_id)
    assert (
        result.account_payee_tax_form_info_id == recordW9.account_payee_tax_form_info_id
    )


@pytest.mark.parametrize(
    'tax_form_document_class',
    (
        USTaxFormW8BENDocument,
        USTaxFormW8BENEDocument,
        USTaxFormW8ECIDocument,
        USTaxFormW8IMYDocument,
        USTaxFormW9Document,
    ),
)
def test_tax_form_document_class(
    tax_form_document_class, account_fixtures, account_payee_fixtures
):
    """Test tax_form_document_class property."""
    tax_form = TaxFormInfo.create(
        tax_form_type=tax_form_document_class.document_type(),
        account_payee_id=1,
        signed_date=datetime.date(2024, 2, 1),
    )
    assert tax_form.tax_form_document_class == tax_form_document_class


@patch('payee.logic.secure_document.get_audit_fields')
def test_w9_form_roundtrip(mock_get_audit_fields, mock_config):
    account_payee_id = '1'

    mock_get_audit_fields.return_value = MOCK_AUDIT_FIELDS

    create_params = {
        **MOCK_TAX_FORM_DETAILS[TAX_FORM_TYPES.W9],
        'account_payee_id': account_payee_id,
    }

    create_secure_document_details(
        mock_config.SDM_CONFIG, USTaxFormW9Document, **create_params
    )

    result = has_secure_document_details(account_payee_id, USTaxFormW9Document)

    assert USTaxFormW9Document.build_response(account_payee_id, result) == {
        **create_params,
        **MOCK_AUDIT_FIELDS,
        'tax_form_type': USTaxFormW9Document.document_type(),
        'revision': '0',
    }

    assert USTaxFormW9Document.build_response(
        account_payee_id, result, obscure_pii=True
    ) == {
        **create_params,
        **MOCK_AUDIT_FIELDS,
        'tax_form_type': USTaxFormW9Document.document_type(),
        'revision': '0',
        'tin': None,
    }


@pytest.mark.parametrize('tax_treaty_claim', (True, False))
@patch('payee.logic.secure_document.get_audit_fields')
def test_w8ben_form_roundtrip(mock_get_audit_fields, mock_config, tax_treaty_claim):
    account_payee_id = '1'

    mock_get_audit_fields.return_value = MOCK_AUDIT_FIELDS

    create_params = {
        **MOCK_TAX_FORM_DETAILS[TAX_FORM_TYPES.W8BEN],
        'account_payee_id': account_payee_id,
        'tax_treaty_claim': tax_treaty_claim,
    }

    create_secure_document_details(
        mock_config.SDM_CONFIG, USTaxFormW8BENDocument, **create_params
    )

    result = has_secure_document_details(account_payee_id, USTaxFormW8BENDocument)

    assert USTaxFormW8BENDocument.build_response(account_payee_id, result) == {
        **create_params,
        **MOCK_AUDIT_FIELDS,
        'tax_form_type': USTaxFormW8BENDocument.document_type(),
        'revision': '0',
    }

    assert USTaxFormW8BENDocument.build_response(
        account_payee_id, result, obscure_pii=True
    ) == {
        **create_params,
        **MOCK_AUDIT_FIELDS,
        'tax_form_type': USTaxFormW8BENDocument.document_type(),
        'revision': '0',
        'tin': None,
    }


@pytest.mark.parametrize('tax_treaty_claim', (True, False))
@patch('payee.logic.secure_document.get_audit_fields')
def test_w8bene_form_roundtrip(mock_get_audit_fields, mock_config, tax_treaty_claim):
    account_payee_id = '1'

    mock_get_audit_fields.return_value = MOCK_AUDIT_FIELDS

    create_params = {
        **MOCK_TAX_FORM_DETAILS[TAX_FORM_TYPES.W8BENE],
        'account_payee_id': account_payee_id,
        'tax_treaty_claim': tax_treaty_claim,
    }

    create_secure_document_details(
        mock_config.SDM_CONFIG, USTaxFormW8BENEDocument, **create_params
    )

    result = has_secure_document_details(account_payee_id, USTaxFormW8BENEDocument)

    assert USTaxFormW8BENEDocument.build_response(account_payee_id, result) == {
        **create_params,
        **MOCK_AUDIT_FIELDS,
        'tax_form_type': USTaxFormW8BENEDocument.document_type(),
        'revision': '0',
    }

    assert USTaxFormW8BENEDocument.build_response(
        account_payee_id, result, obscure_pii=True
    ) == {
        **create_params,
        **MOCK_AUDIT_FIELDS,
        'tax_form_type': USTaxFormW8BENEDocument.document_type(),
        'revision': '0',
        'tin': None,
    }


@pytest.mark.parametrize('tax_treaty_claim', (True, False))
@patch('payee.logic.secure_document.get_audit_fields')
def test_w8imy_form_roundtrip(mock_get_audit_fields, mock_config, tax_treaty_claim):
    account_payee_id = '1'

    mock_get_audit_fields.return_value = MOCK_AUDIT_FIELDS

    create_params = {
        **MOCK_TAX_FORM_DETAILS[TAX_FORM_TYPES.W8IMY],
        'account_payee_id': account_payee_id,
        'tax_treaty_claim': tax_treaty_claim,
    }

    create_secure_document_details(
        mock_config.SDM_CONFIG, USTaxFormW8IMYDocument, **create_params
    )

    result = has_secure_document_details(account_payee_id, USTaxFormW8IMYDocument)

    assert USTaxFormW8IMYDocument.build_response(account_payee_id, result) == {
        **create_params,
        **MOCK_AUDIT_FIELDS,
        'tax_form_type': USTaxFormW8IMYDocument.document_type(),
        'revision': '0',
    }

    assert USTaxFormW8IMYDocument.build_response(
        account_payee_id, result, obscure_pii=True
    ) == {
        **create_params,
        **MOCK_AUDIT_FIELDS,
        'tax_form_type': USTaxFormW8IMYDocument.document_type(),
        'revision': '0',
        'tin': None,
    }


@pytest.mark.parametrize('tax_treaty_claim', (True, False))
@patch('payee.logic.secure_document.get_audit_fields')
def test_w8eci_form_roundtrip(mock_get_audit_fields, mock_config, tax_treaty_claim):
    account_payee_id = '1'

    mock_get_audit_fields.return_value = MOCK_AUDIT_FIELDS

    create_params = {
        **MOCK_TAX_FORM_DETAILS[TAX_FORM_TYPES.W8ECI],
        'account_payee_id': account_payee_id,
        'tax_treaty_claim': tax_treaty_claim,
    }

    create_secure_document_details(
        mock_config.SDM_CONFIG, USTaxFormW8ECIDocument, **create_params
    )

    result = has_secure_document_details(account_payee_id, USTaxFormW8ECIDocument)

    assert USTaxFormW8ECIDocument.build_response(account_payee_id, result) == {
        **create_params,
        **MOCK_AUDIT_FIELDS,
        'tax_form_type': USTaxFormW8ECIDocument.document_type(),
        'revision': '0',
    }

    assert USTaxFormW8ECIDocument.build_response(
        account_payee_id, result, obscure_pii=True
    ) == {
        **create_params,
        **MOCK_AUDIT_FIELDS,
        'tax_form_type': USTaxFormW8ECIDocument.document_type(),
        'revision': '0',
        'tin': None,
    }


def test_tax_form_build_response_with_none():
    """Test that build_response handles None secure_document_item gracefully."""
    account_payee_id = '1'

    # Test all tax form document classes
    result = USTaxFormW9Document.build_response(account_payee_id, None)
    assert result is None

    result = USTaxFormW8BENDocument.build_response(account_payee_id, None)
    assert result is None

    result = USTaxFormW8BENEDocument.build_response(account_payee_id, None)
    assert result is None

    result = USTaxFormW8IMYDocument.build_response(account_payee_id, None)
    assert result is None

    result = USTaxFormW8ECIDocument.build_response(account_payee_id, None)
    assert result is None