"""Tests for track spatial logic."""

from oto import response
from oto import status as response_code

from backend.constants import error
from backend.logic import track_spatial as track_spatial_logic
from backend.models.track_persister import TrackPersister
from backend.utils import api as api_utils
from tests.testutils import mocks


def test_get_track_spatial_success(mocker, track_factory):
    """Verify track spatial is retrieved."""
    tuid = 100
    track = track_factory.create(product_id=1, tuid=tuid)

    mocks.ows_product_verify_product_ownership(mocker)
    mocks.track_persister.get_by_tuid(mocker, track)

    expected_response = response.Response(
        message={
            'track_id': tuid,
            'isrc': 'US1234567890',
            'created_at': None,
            'updated_at': None,
        }
    )
    mocker.patch(
        'backend.models.track_spatial.get_track_spatial',
        return_value=expected_response,
    )

    result = track_spatial_logic.get_track_spatial(
        tuid=tuid, account_type='vendor', account_id=1
    )

    assert result
    assert result.message['track_id'] == tuid
    assert result.message['isrc'] == 'US1234567890'


def test_get_track_spatial_not_found(mocker, track_factory):
    """Verify error when track spatial does not exist."""
    tuid = 100

    track = track_factory.create(product_id=1, tuid=tuid)

    mocks.ows_product_verify_product_ownership(mocker)
    mocks.track_persister.get_by_tuid(mocker, track)

    not_found_response = api_utils.create_validation_error_response(
        error.ERROR_MESSAGE_TRACK_SPATIAL_NOT_FOUND
    )
    mocker.patch(
        'backend.models.track_spatial.get_track_spatial',
        return_value=not_found_response,
    )

    result = track_spatial_logic.get_track_spatial(
        tuid=tuid, account_type='vendor', account_id=1
    )

    assert not result
    assert result.errors


def test_create_track_spatial_with_isrc(mocker, track_factory):
    """Verify track spatial is created with provided ISRC."""
    tuid = 100
    track = track_factory.create(product_id=1, tuid=tuid)

    mocks.ows_product_verify_product_ownership(mocker)
    mocks.track_persister.get_by_tuid(mocker, track)

    spatial_data = {
        'track_id': tuid,
        'isrc': 'US1234567890'
    }

    # Mock the model's create_track_spatial function
    expected_response = response.Response(
        message={
            'track_id': tuid,
            'isrc': 'US1234567890',
            'created_at': None,
            'updated_at': None
        }
    )
    mocker.patch(
        'backend.models.track_spatial.create_track_spatial',
        return_value=expected_response
    )

    result = track_spatial_logic.create_track_spatial(
        tuid=tuid,
        data=spatial_data,
        account_type='vendor',
        account_id=1
    )

    assert result
    assert result.message['isrc'] == 'US1234567890'
    assert result.message['track_id'] == tuid


def test_create_track_spatial_without_isrc_auto_generates(mocker, track_factory):
    """Verify track spatial auto-generates ISRC when not provided."""
    tuid = 100
    track = track_factory.create(product_id=1, tuid=tuid)

    mocks.ows_product_verify_product_ownership(mocker)
    mocks.track_persister.get_by_tuid(mocker, track)

    spatial_data = {
        'track_id': tuid,
        'isrc': ''
    }

    # Mock the ISRC generation
    isrc_claim_response = response.Response(
        message={'isrc': 'USABC1234567'}
    )
    mocker.patch(
        'backend.models.track_additional_isrc.get_atmos_isrc',
        return_value=response.Response(message=None)
    )
    mocker.patch(
        'backend.models.track_persister.TrackPersister.claim_new_isrc',
        return_value=isrc_claim_response
    )

    expected_response = response.Response(
        message={
            'track_id': tuid,
            'isrc': 'USABC1234567',
            'created_at': None,
            'updated_at': None
        }
    )
    mocker.patch(
        'backend.models.track_spatial.create_track_spatial',
        return_value=expected_response
    )

    result = track_spatial_logic.create_track_spatial(
        tuid=tuid,
        data=spatial_data,
        account_type='vendor',
        account_id=1
    )

    assert result
    assert result.message['isrc'] == 'USABC1234567'


def test_create_track_spatial_without_isrc_auto_generates_error(mocker, track_factory):
    """Verify track spatial auto-generates ISRC error when not provided."""
    tuid = 100
    track = track_factory.create(product_id=1, tuid=tuid)

    mocks.ows_product_verify_product_ownership(mocker)
    mocks.track_persister.get_by_tuid(mocker, track)

    spatial_data = {
        'track_id': tuid,
        'isrc': ''
    }

    # Mock the ISRC generation
    mocker.patch(
        'backend.models.track_additional_isrc.get_atmos_isrc',
        return_value=response.Response(message=None)
    )
    invalid_isrc_claim_response = api_utils.create_validation_error_response(
        error.INTERNAL_ERROR
    )
    mocker.patch(
        'backend.models.track_persister.TrackPersister.claim_new_isrc',
        return_value=invalid_isrc_claim_response
    )

    result = track_spatial_logic.create_track_spatial(
        tuid=tuid,
        data=spatial_data,
        account_type='vendor',
        account_id=1
    )

    assert not result
    assert result.errors


def test_update_track_spatial_success(mocker, track_factory):
    """Verify track spatial is updated successfully."""
    tuid = 100
    track = track_factory.create(product_id=1, tuid=tuid)

    mocks.ows_product_verify_product_ownership(mocker)
    mocks.track_persister.get_by_tuid(mocker, track)

    spatial_data = {
        'track_id': tuid,
        'isrc': 'USNEW1234567'
    }

    expected_response = response.Response(
        message={
            'track_id': tuid,
            'isrc': 'USNEW1234567',
            'created_at': None,
            'updated_at': None
        }
    )
    mocker.patch(
        'backend.models.track_spatial.update_track_spatial',
        return_value=expected_response
    )

    result = track_spatial_logic.update_track_spatial(
        tuid=tuid,
        data=spatial_data,
        account_type='vendor',
        account_id=1
    )

    assert result
    assert result.message['isrc'] == 'USNEW1234567'


def test_update_track_spatial_without_isrc_auto_generates(mocker, track_factory):
    """Verify update_track_spatial claims a new ISRC when none is provided."""
    tuid = 100
    track = track_factory.create(product_id=1, tuid=tuid)

    mocks.ows_product_verify_product_ownership(mocker)
    mocks.track_persister.get_by_tuid(mocker, track)

    spatial_data = {
        'track_id': tuid,
        'isrc': ''
    }

    isrc_claim_response = response.Response(
        message={'isrc': 'USABC1234567'}
    )
    mocker.patch(
        'backend.models.track_additional_isrc.get_atmos_isrc',
        return_value=response.Response(message=None)
    )
    mocker.patch(
        'backend.models.track_persister.TrackPersister.claim_new_isrc',
        return_value=isrc_claim_response
    )

    expected_response = response.Response(
        message={
            'track_id': tuid,
            'isrc': 'USABC1234567',
            'created_at': None,
            'updated_at': None
        }
    )
    mocker.patch(
        'backend.models.track_spatial.update_track_spatial',
        return_value=expected_response
    )

    result = track_spatial_logic.update_track_spatial(
        tuid=tuid,
        data=spatial_data,
        account_type='vendor',
        account_id=1
    )

    assert result
    assert result.message['isrc'] == 'USABC1234567'


def test_update_track_spatial_without_isrc_auto_generates_error(mocker, track_factory):
    """Verify error is returned when claiming a new ISRC fails on update."""
    tuid = 100
    track = track_factory.create(product_id=1, tuid=tuid)

    mocks.ows_product_verify_product_ownership(mocker)
    mocks.track_persister.get_by_tuid(mocker, track)

    spatial_data = {
        'track_id': tuid,
        'isrc': ''
    }

    mocker.patch(
        'backend.models.track_additional_isrc.get_atmos_isrc',
        return_value=response.Response(message=None)
    )
    invalid_isrc_claim_response = api_utils.create_validation_error_response(
        error.INTERNAL_ERROR
    )
    mocker.patch(
        'backend.models.track_persister.TrackPersister.claim_new_isrc',
        return_value=invalid_isrc_claim_response
    )

    result = track_spatial_logic.update_track_spatial(
        tuid=tuid,
        data=spatial_data,
        account_type='vendor',
        account_id=1
    )

    assert not result
    assert result.errors


def test_update_track_spatial_track_not_found(mocker):
    """Verify error when the target track does not exist."""
    tuid = 100

    mocks.ows_product_verify_product_ownership(mocker)

    # Mock track not found
    invalid_response = api_utils.create_validation_error_response(
        error.ERROR_MESSAGE_TRACK_NOT_FOUND
    )
    mocker.patch(
        'backend.models.track_persister.TrackPersister.get_by_tuid',
        return_value=invalid_response
    )

    spatial_data = {
        'track_id': tuid,
        'isrc': 'USNEW1234567'
    }

    result = track_spatial_logic.update_track_spatial(
        tuid=tuid,
        data=spatial_data,
        account_type='vendor',
        account_id=1
    )

    assert not result
    assert result.errors


def test_delete_track_spatial_success(mocker, track_factory):
    """Verify track spatial is deleted successfully."""
    tuid = 100
    track = track_factory.create(product_id=1, tuid=tuid)

    mocks.ows_product_verify_product_ownership(mocker)
    mocks.track_persister.get_by_tuid(mocker, track)

    expected_response = response.Response()
    mocker.patch(
        'backend.models.track_spatial.delete_track_spatial',
        return_value=expected_response
    )

    result = track_spatial_logic.delete_track_spatial(
        tuid=tuid,
        account_type='vendor',
        account_id=1
    )

    assert result
    assert result.status == response_code.OK


def test_delete_track_spatial_invalid_track(mocker):
    """Verify error when deleting spatial for invalid track."""
    tuid = 100

    mocks.ows_product_verify_product_ownership(mocker)

    # Mock track not found
    invalid_response = api_utils.create_validation_error_response(
        error.ERROR_MESSAGE_TRACK_NOT_FOUND
    )
    mocker.patch(
        'backend.models.track_persister.TrackPersister.get_by_tuid',
        return_value=invalid_response
    )

    result = track_spatial_logic.delete_track_spatial(
        tuid=tuid,
        account_type='vendor',
        account_id=1
    )

    assert not result
    assert result.errors


def test_get_spatial_isrc_map_by_product_id_success(mocker):
    """Verify spatial ISRC map is retrieved by product_id."""
    mocks.ows_product_verify_product_ownership(mocker)
    mocker.patch.object(
        TrackPersister,
        'get_spatial_isrc_map_by_product_id',
        return_value=response.Response(message={100: 'US1234567890', 101: 'US0987654321'}),
    )

    result = track_spatial_logic.get_spatial_isrc_map_by_product_id(
        product_id=1, account_type='vendor', account_id=1
    )

    assert result
    assert result.message == {100: 'US1234567890', 101: 'US0987654321'}


def test_get_spatial_isrc_map_by_product_id_empty(mocker):
    """Verify empty dict returned when no spatial records exist for product."""
    mocks.ows_product_verify_product_ownership(mocker)
    mocker.patch.object(
        TrackPersister,
        'get_spatial_isrc_map_by_product_id',
        return_value=response.Response(message={}),
    )

    result = track_spatial_logic.get_spatial_isrc_map_by_product_id(
        product_id=1, account_type='vendor', account_id=1
    )

    assert result
    assert result.message == {}


def test_create_track_spatial_reuses_existing_isrc(mocker, track_factory):
    """Reuse the track's existing atmos ISRC instead of claiming a new one."""
    tuid = 100
    track = track_factory.create(product_id=1, tuid=tuid)

    mocks.ows_product_verify_product_ownership(mocker)
    mocks.track_persister.get_by_tuid(mocker, track)

    mocker.patch(
        'backend.models.track_additional_isrc.get_atmos_isrc',
        return_value=response.Response(message='USEXIST12345'),
    )
    claim = mocker.patch(
        'backend.models.track_persister.TrackPersister.claim_new_isrc')
    create = mocker.patch(
        'backend.models.track_spatial.create_track_spatial',
        return_value=response.Response(
            message={'track_id': tuid, 'isrc': 'USEXIST12345'}),
    )

    result = track_spatial_logic.create_track_spatial(
        tuid=tuid, data={'track_id': tuid, 'isrc': ''},
        account_type='vendor', account_id=1)

    assert result
    claim.assert_not_called()
    create.assert_called_once_with({'track_id': tuid, 'isrc': 'USEXIST12345'})


def test_update_track_spatial_reuses_existing_isrc(mocker, track_factory):
    """Reuse the track's existing atmos ISRC on update instead of claiming a new one."""
    tuid = 100
    track = track_factory.create(product_id=1, tuid=tuid)

    mocks.ows_product_verify_product_ownership(mocker)
    mocks.track_persister.get_by_tuid(mocker, track)

    mocker.patch(
        'backend.models.track_additional_isrc.get_atmos_isrc',
        return_value=response.Response(message='USEXIST12345'),
    )
    claim = mocker.patch(
        'backend.models.track_persister.TrackPersister.claim_new_isrc')
    update = mocker.patch(
        'backend.models.track_spatial.update_track_spatial',
        return_value=response.Response(
            message={'track_id': tuid, 'isrc': 'USEXIST12345'}),
    )

    result = track_spatial_logic.update_track_spatial(
        tuid=tuid, data={'track_id': tuid, 'isrc': ''},
        account_type='vendor', account_id=1)

    assert result
    claim.assert_not_called()
    update.assert_called_once_with({'track_id': tuid, 'isrc': 'USEXIST12345'})


def test_create_track_spatial_reuse_lookup_db_error(mocker, track_factory):
    """A DB error during the ISRC reuse lookup surfaces -- no fallback claim."""
    tuid = 100
    track = track_factory.create(product_id=1, tuid=tuid)

    mocks.ows_product_verify_product_ownership(mocker)
    mocks.track_persister.get_by_tuid(mocker, track)

    mocker.patch(
        'backend.models.track_additional_isrc.get_atmos_isrc',
        return_value=response.create_fatal_response(),
    )
    claim = mocker.patch(
        'backend.models.track_persister.TrackPersister.claim_new_isrc')

    result = track_spatial_logic.create_track_spatial(
        tuid=tuid, data={'track_id': tuid, 'isrc': ''},
        account_type='vendor', account_id=1)

    assert not result
    claim.assert_not_called()


def test_update_track_spatial_reuse_lookup_db_error(mocker, track_factory):
    """A DB error during the ISRC reuse lookup on update surfaces -- no fallback claim."""
    tuid = 100
    track = track_factory.create(product_id=1, tuid=tuid)

    mocks.ows_product_verify_product_ownership(mocker)
    mocks.track_persister.get_by_tuid(mocker, track)

    mocker.patch(
        'backend.models.track_additional_isrc.get_atmos_isrc',
        return_value=response.create_fatal_response(),
    )
    claim = mocker.patch(
        'backend.models.track_persister.TrackPersister.claim_new_isrc')

    result = track_spatial_logic.update_track_spatial(
        tuid=tuid, data={'track_id': tuid, 'isrc': ''},
        account_type='vendor', account_id=1)

    assert not result
    claim.assert_not_called()