"""Test for artist name updates."""

from unittest.mock import MagicMock, patch

import pytest
from flask import g
from participant.api import app
from participant.models import artist_name_updates
from participant.models import base as base_models
from tests.unit.utils import db

mock_label_participant_response = {
    'name': 'test',
    'vendorId': 25824,
    'subaccountId': 0,
    'spotifyId': '5xaT2601i5MC4h6yZa7EOD',
    'id': 786281,
    'appleMusicId': 111000530,
}


@pytest.fixture(autouse=True)
def flask_app_context():
    """Provide Flask app context and g.log for tests."""
    with app.app_context():
        g.log = MagicMock()
        yield


@pytest.fixture
def vendor_id():
    """Create a vendor id for testing."""
    return 25824


@pytest.fixture
def current_artist_name():
    """Create a artist name before update for testing."""
    return 'test'


@pytest.fixture
def artist_name():
    """Create a artist name for testing."""
    return 'updated test'


@pytest.fixture
def artist_id():
    """Create a artist name for testing."""
    return 321


@patch("participant.models.artist_name_updates.response.Response")
@patch("participant.models.artist_name_updates.text")
@patch("participant.models.artist_name_updates.mysql.ar_db_session")
@patch(
    "participant.models.artist_name_updates.artist_select.UPDATE_RELEASE_ARTIST",
    "UPDATE release_artist ...",
)
def test_rename_release_artist_with_current_artist_id(
    mock_ar_db_session, mock_text, mock_response
):
    """Test a rename_release_artist with current_artist_id."""
    mock_session = MagicMock()
    mock_ar_db_session.return_value.__enter__.return_value = mock_session
    mock_text.return_value = "mock_sql"

    mock_resp = MagicMock()
    mock_resp.status = 200
    mock_response.return_value = mock_resp

    result = artist_name_updates.rename_release_artist(
        "old artist",
        1,
        "new artist",
        123,
        456,
    )

    mock_session.execute.assert_called_once_with(
        "mock_sql",
        {
            "artist_name": "old artist",
            "vendor_id": 1,
            "new_artist_name": "new artist",
            "artist_id": 123,
            "current_artist_id": 456,
        },
    )
    mock_session.commit.assert_called_once()
    assert result.status == 200


@patch("participant.models.artist_name_updates.response.Response")
@patch("participant.models.artist_name_updates.text")
@patch("participant.models.artist_name_updates.mysql.ar_db_session")
def test_rename_track_artist(mock_ar_db_session, mock_text, mock_response):
    """Test that existing records are updated."""
    mock_session = MagicMock()
    mock_ar_db_session.return_value.__enter__.return_value = mock_session
    mock_text.return_value = "mock_sql"

    mock_resp = MagicMock()
    mock_resp.status = 200
    mock_response.return_value = mock_resp

    result = artist_name_updates.rename_track_artist(
        "current artist",
        1,
        "new artist",
        123,
    )

    mock_session.execute.assert_called_once()
    mock_session.commit.assert_called_once()
    assert result.status == 200


@patch("participant.models.artist_name_updates.response.Response")
@patch("participant.models.artist_name_updates.text")
@patch("participant.models.artist_name_updates.mysql.ar_db_session")
@patch(
    "participant.models.artist_name_updates.artist_select.UPDATE_TRACK_WRITER",
    "UPDATE track_writer ...",
)
def test_rename_track_writer(mock_ar_db_session, mock_text, mock_response):
    """Test that existing records are updated."""
    mock_session = MagicMock()
    mock_ar_db_session.return_value.__enter__.return_value = mock_session
    mock_text.return_value = "mock_sql"

    mock_resp = MagicMock()
    mock_resp.status = 200
    mock_response.return_value = mock_resp

    result = artist_name_updates.rename_track_writer(
        "old artist",
        1,
        "new artist",
        123,
    )

    mock_session.execute.assert_called_once_with(
        "mock_sql",
        {
            "artist_name": "old artist",
            "vendor_id": 1,
            "new_artist_name": "new artist",
            "artist_id": 123,
            "current_artist_id": None,
        },
    )
    mock_session.commit.assert_called_once()
    assert result.status == 200


@patch("participant.models.artist_name_updates.mysql.ar_db_session")
def test_get_artist_info_by_artist_name(mock_ar_db_session):
    """Test get_artist_info_by_artist_name success."""
    mock_session = MagicMock()
    mock_ar_db_session.return_value.__enter__.return_value = mock_session

    expected_artist = MagicMock()
    (mock_session.query.return_value.filter.return_value.first.return_value) = (
        expected_artist
    )

    result = artist_name_updates.get_artist_info_by_artist_name(
        "Test Artist",
        1,
    )

    mock_ar_db_session.assert_called_once_with(read_only=True)
    mock_session.query.assert_called_once()
    mock_session.query.return_value.filter.assert_called_once()
    mock_session.query.return_value.filter.return_value.first.assert_called_once()
    assert result == expected_artist


@patch("participant.models.artist_name_updates.response.create_error_response")
@patch("participant.models.artist_name_updates.get_artist_info_by_artist_name")
@patch(
    "participant.models.artist_name_updates.ows_artist_model.get_artist_info_by_artist_id"
)
def test_update_artist_name_duplicate_artist(
    mock_get_artist_info_by_id,
    mock_get_artist_info_by_name,
    mock_create_error_response,
):
    """Test update_artist_name with error."""
    artist_id = 123
    new_artist_name = "New Artist"
    vendor_id = 456

    mock_artist_info = MagicMock()
    mock_artist_info.message = {
        "name": "Old Artist",
        "vendor_id": vendor_id,
    }
    mock_get_artist_info_by_id.return_value = mock_artist_info

    duplicate_artist = MagicMock()
    duplicate_artist.artist_id = 999
    mock_get_artist_info_by_name.return_value = duplicate_artist

    mock_error = MagicMock()
    mock_create_error_response.return_value = mock_error

    result = artist_name_updates.update_artist_name(artist_id, new_artist_name)

    assert result == mock_error


@db.test_schema
def test_update_label_participant(vendor_id, artist_name, monkeypatch):
    """Test that label participant node is updated."""
    artist_id = 123
    monkeypatch.setattr(
        base_models, 'get_node', MagicMock(return_value=mock_label_participant_response)
    )
    monkeypatch.setattr(
        base_models,
        'update_node',
        MagicMock(return_value=mock_label_participant_response),
    )
    result = artist_name_updates.rename_label_participant(
        vendor_id, artist_id, artist_name
    )

    assert result.status == 200


@patch("participant.models.artist_name_updates.response.Response")
@patch(
    "participant.models.artist_name_updates.update_last_updated_for_affected_products"
)
@patch(
    "participant.models.artist_name_updates.ows_artist_model.update_artist_info_by_artist_id"
)
@patch("participant.models.artist_name_updates.remove_all_artist_id_references")
@patch("participant.models.artist_name_updates.merge_label_participant")
@patch("participant.models.artist_name_updates.reassign_artist_for_product")
@patch("participant.models.artist_name_updates.reassign_artist_for_project")
@patch("participant.models.artist_name_updates.rename_track_writer")
@patch("participant.models.artist_name_updates.rename_track_artist")
@patch("participant.models.artist_name_updates.rename_release_artist")
@patch(
    "participant.models.artist_name_updates.ows_artist_model.get_artist_info_by_artist_id"
)
def test_merge_artist_success(
    mock_get_artist_info_by_artist_id,
    mock_rename_release_artist,
    mock_rename_track_artist,
    mock_rename_track_writer,
    mock_reassign_artist_for_project,
    mock_reassign_artist_for_product,
    mock_merge_label_participant,
    mock_remove_all_artist_id_references,
    mock_update_artist_info_by_artist_id,
    mock_update_last_updated_for_affected_products,
    mock_response,
):
    """Test merge_artist success case."""
    current_artist_id = 123
    target_artist_id = 567
    artist_name = "Merged Artist"
    vendor_id = 456
    current_artist_name = "Old Artist"

    target_artist_response = MagicMock()
    target_artist_response.message = {
        "artist_id": target_artist_id,
        "vendor_id": vendor_id,
        "name": "Target Artist",
    }

    current_artist_response = MagicMock()
    current_artist_response.message = {
        "artist_id": current_artist_id,
        "vendor_id": vendor_id,
        "name": current_artist_name,
    }

    mock_get_artist_info_by_artist_id.side_effect = [
        target_artist_response,
        current_artist_response,
    ]

    mock_merge_label_participant.return_value = MagicMock()
    mock_update_artist_info_by_artist_id.return_value = MagicMock()

    mock_success_response = MagicMock()
    mock_success_response.status = 200
    mock_response.return_value = mock_success_response

    result = artist_name_updates.merge_artist(
        current_artist_id,
        target_artist_id,
        artist_name,
    )

    mock_get_artist_info_by_artist_id.assert_any_call(target_artist_id)
    mock_get_artist_info_by_artist_id.assert_any_call(current_artist_id)

    mock_rename_release_artist.assert_called_once_with(
        current_artist_name,
        vendor_id,
        artist_name,
        target_artist_id,
        current_artist_id,
    )
    mock_rename_track_artist.assert_called_once_with(
        current_artist_name,
        vendor_id,
        artist_name,
        target_artist_id,
        current_artist_id,
    )
    mock_rename_track_writer.assert_called_once_with(
        current_artist_name,
        vendor_id,
        artist_name,
        target_artist_id,
        current_artist_id,
    )
    mock_reassign_artist_for_project.assert_called_once_with(
        current_artist_id,
        target_artist_id,
    )
    mock_reassign_artist_for_product.assert_called_once_with(
        current_artist_id,
        target_artist_id,
    )
    mock_merge_label_participant.assert_called_once_with(
        current_artist_id,
        target_artist_id,
        vendor_id,
        artist_name,
    )
    mock_remove_all_artist_id_references.assert_called_once_with(current_artist_id)
    mock_update_artist_info_by_artist_id.assert_called_once_with(
        target_artist_id,
        artist_name,
    )
    mock_update_last_updated_for_affected_products.assert_called_once_with(
        target_artist_id
    )
    mock_response.assert_called_once_with(
        status=200,
        message="Artist is merged successfully.",
    )
    assert result.status == 200


@db.test_schema
def test_reassign_artist_for_project():
    """Test that existing records are updated."""
    db.insert_project_data()
    current_artist_id = 321
    target_artist_id = 567
    result = artist_name_updates.reassign_artist_for_project(
        current_artist_id, target_artist_id
    )
    assert result.status == 200


@db.test_schema
def test_reassign_artist_for_product():
    """Test that existing records are updated."""
    db.insert_releases_data()
    current_artist_id = 321
    target_artist_id = 567
    result = artist_name_updates.reassign_artist_for_product(
        current_artist_id, target_artist_id
    )
    assert result.status == 200


@db.test_schema
def test_merge_label_participant(vendor_id, artist_name, monkeypatch):
    """Test that label participant node is updated."""
    current_artist_id = 321
    target_artist_id = 567
    monkeypatch.setattr(
        base_models, 'get_node', MagicMock(return_value=mock_label_participant_response)
    )
    monkeypatch.setattr(
        base_models,
        'update_node',
        MagicMock(return_value=mock_label_participant_response),
    )
    result = artist_name_updates.merge_label_participant(
        current_artist_id, target_artist_id, vendor_id, artist_name
    )

    assert result.status == 200


@db.test_schema
def test_remove_all_artist_id_references(monkeypatch, artist_id):
    """Test that label participant node is updated."""
    current_artist_id = artist_id
    db.insert_artist_yt_delivery_settings()
    db.insert_artist_info_data()
    monkeypatch.setattr(
        base_models, 'get_node', MagicMock(return_value=mock_label_participant_response)
    )
    monkeypatch.setattr(
        base_models,
        'update_node',
        MagicMock(return_value=mock_label_participant_response),
    )
    result = artist_name_updates.remove_all_artist_id_references(current_artist_id)

    assert result.status == 200


@db.test_schema
def test_update_label_participant_by_uuid(artist_name, monkeypatch):
    """Test that label participant node is updated."""
    artist_id = 'efg-abc'
    monkeypatch.setattr(
        base_models, 'get_node', MagicMock(return_value=mock_label_participant_response)
    )
    monkeypatch.setattr(
        base_models,
        'update_node',
        MagicMock(return_value=mock_label_participant_response),
    )
    result = artist_name_updates.rename_label_participant_by_uuid(
        artist_id, artist_name
    )

    assert result.status == 200


@patch("participant.models.artist_name_updates.response.create_error_response")
@patch("participant.models.artist_name_updates.get_artist_info_by_artist_name")
@patch("participant.models.artist_name_updates.base_models.get_node")
def test_update_lp_and_artist_name_duplicate_artist(
    mock_get_node,
    mock_get_artist_info_by_artist_name,
    mock_create_error_response,
):
    """Test update_lp_and_artist_name error case."""
    label_participant_uuid = "lp-uuid-123"
    current_artist_name = "Old Artist"
    new_artist_name = "New Artist"
    vendor_id = 456
    artist_info_id = 789

    mock_get_node.return_value = {
        "name": current_artist_name,
        "vendorId": vendor_id,
    }

    current_artist_info = MagicMock()
    current_artist_info.artist_id = artist_info_id

    duplicate_artist_info = MagicMock()
    duplicate_artist_info.artist_id = 999

    mock_get_artist_info_by_artist_name.side_effect = [
        current_artist_info,
        duplicate_artist_info,
    ]

    expected_error = MagicMock()
    mock_create_error_response.return_value = expected_error

    result = artist_name_updates.update_lp_and_artist_name(
        label_participant_uuid,
        new_artist_name,
    )

    assert result == expected_error


@patch(
    "participant.models.artist_name_updates.update_last_updated_for_affected_products"
)
@patch(
    "participant.models.artist_name_updates.ows_artist_model.update_artist_info_by_artist_id"
)
@patch("participant.models.artist_name_updates.rename_track_writer")
@patch("participant.models.artist_name_updates.rename_track_artist")
@patch("participant.models.artist_name_updates.rename_release_artist")
@patch("participant.models.artist_name_updates.rename_label_participant_by_uuid")
@patch("participant.models.artist_name_updates.get_artist_info_by_artist_name")
@patch("participant.models.artist_name_updates.base_models.get_node")
@patch("participant.models.artist_name_updates.response.Response")
def test_update_lp_and_artist_name_success(
    mock_response,
    mock_get_node,
    mock_get_artist_info_by_artist_name,
    mock_rename_label_participant_by_uuid,
    mock_rename_release_artist,
    mock_rename_track_artist,
    mock_rename_track_writer,
    mock_update_artist_info_by_artist_id,
    mock_update_last_updated_for_affected_products,
):
    """Test update_lp_and_artist_name success."""
    label_participant_uuid = "lp-uuid-123"
    current_artist_name = "Old Artist"
    new_artist_name = "New Artist"
    vendor_id = 456
    artist_info_id = 789

    mock_get_node.return_value = {
        "name": current_artist_name,
        "vendorId": vendor_id,
    }

    current_artist_info = MagicMock()
    current_artist_info.artist_id = artist_info_id

    mock_get_artist_info_by_artist_name.side_effect = [
        current_artist_info,
        None,
    ]

    mock_rename_label_participant_by_uuid.return_value = MagicMock()
    mock_rename_release_artist.return_value = MagicMock()
    mock_rename_track_artist.return_value = MagicMock()
    mock_rename_track_writer.return_value = MagicMock()
    mock_update_artist_info_by_artist_id.return_value = MagicMock()

    mock_resp = MagicMock()
    mock_resp.status = 200
    mock_response.return_value = mock_resp

    result = artist_name_updates.update_lp_and_artist_name(
        label_participant_uuid,
        new_artist_name,
    )

    mock_rename_label_participant_by_uuid.assert_called_once_with(
        label_participant_uuid,
        new_artist_name,
    )
    mock_rename_release_artist.assert_called_once_with(
        current_artist_name,
        vendor_id,
        new_artist_name,
        artist_info_id,
    )
    mock_rename_track_artist.assert_called_once_with(
        current_artist_name,
        vendor_id,
        new_artist_name,
        artist_info_id,
    )
    mock_rename_track_writer.assert_called_once_with(
        current_artist_name,
        vendor_id,
        new_artist_name,
        artist_info_id,
    )
    mock_update_artist_info_by_artist_id.assert_called_once_with(
        artist_info_id,
        new_artist_name,
    )
    mock_update_last_updated_for_affected_products.assert_called_once_with(
        artist_info_id
    )
    mock_response.assert_called_once_with(
        status=200,
        message="Artist name is updated successfully.",
    )
    assert result.status == 200


@db.test_schema
def test_update_label_participant_by_name(vendor_id, artist_name, monkeypatch):
    """Test that label participant node is updated."""
    monkeypatch.setattr(
        base_models, 'get_node', MagicMock(return_value=mock_label_participant_response)
    )
    monkeypatch.setattr(
        base_models,
        'update_node',
        MagicMock(return_value=mock_label_participant_response),
    )
    result = artist_name_updates.rename_lp_by_name(artist_name, 'new name', vendor_id)

    assert result.status == 200


@db.test_schema
def test_get_products_and_tracks_for_lp(monkeypatch):
    """Test that existing records are updated."""
    lp_uuid = 'f3c91c39-9e56-4bf9-9460-9c32605b5859'
    monkeypatch.setattr(
        base_models, 'get_node', MagicMock(return_value=mock_label_participant_response)
    )
    monkeypatch.setattr(
        artist_name_updates,
        'get_products_for_artist',
        MagicMock(return_value=2),
    )
    monkeypatch.setattr(
        artist_name_updates,
        'get_tracks_for_artist',
        MagicMock(return_value=2),
    )
    result = artist_name_updates.get_products_and_tracks_for_lp(lp_uuid)
    assert result.status == 200
    assert result.message == {'release': 2, 'track': 2}


@db.test_schema
def test_get_tracks_for_artist(vendor_id, current_artist_name):
    """Test that existing records are returned."""
    db.insert_releases_data()
    db.insert_track_data()
    db.insert_project_data()
    db.insert_track_artist_data()
    result = artist_name_updates.get_tracks_for_artist(vendor_id, current_artist_name)
    assert result == 1


@db.test_schema
def test_get_products_for_artist(vendor_id, current_artist_name):
    """Test that existing records are returned."""
    db.insert_releases_data()
    db.insert_project_data()
    db.insert_artist_info_data()
    db.insert_release_artist_data()
    result = artist_name_updates.get_products_for_artist(vendor_id, current_artist_name)
    assert result == 1


@db.test_schema
def test_merge_nodes_by_id(monkeypatch):
    """Test that label participant node is updated."""
    source_lp_id = 321
    target_lp_id = 567

    monkeypatch.setattr(
        base_models,
        'update_node',
        MagicMock(return_value=mock_label_participant_response),
    )
    result = artist_name_updates.merge_nodes_by_id(source_lp_id, target_lp_id)
    assert result.status == 200


@patch(
    "participant.models.artist_name_updates.update_last_updated_for_affected_products"
)
@patch("participant.models.artist_name_updates.remove_all_artist_id_references")
@patch("participant.models.artist_name_updates.merge_nodes_by_id")
@patch("participant.models.artist_name_updates.reassign_artist_for_product")
@patch("participant.models.artist_name_updates.reassign_artist_for_project")
@patch("participant.models.artist_name_updates.rename_track_writer")
@patch("participant.models.artist_name_updates.rename_track_artist")
@patch("participant.models.artist_name_updates.rename_release_artist")
@patch("participant.models.artist_name_updates.get_artist_info_by_artist_name")
@patch("participant.models.artist_name_updates.base_models.get_node")
@patch("participant.models.artist_name_updates.response.Response")
def test_merge_lp_and_artist_names_success(
    mock_response,
    mock_get_node,
    mock_get_artist_info_by_artist_name,
    mock_rename_release_artist,
    mock_rename_track_artist,
    mock_rename_track_writer,
    mock_reassign_artist_for_project,
    mock_reassign_artist_for_product,
    mock_merge_nodes_by_id,
    mock_remove_all_artist_id_references,
    mock_update_last_updated_for_affected_products,
):
    """Test merge_lp_and_artist_names success."""
    uuid_1 = "uuid-1"
    uuid_2 = "uuid-2"
    merged_artist_uuid = "uuid-1"

    merged_artist_name = "Merged Artist"
    target_artist_name = "Target Artist"
    vendor_id = 456
    merged_artist_id = 111
    target_artist_id = 222
    source_lp_id = 1001
    target_lp_id = 1002

    mock_get_node.side_effect = [
        {
            "name": merged_artist_name,
            "vendorId": vendor_id,
            "id": source_lp_id,
        },
        {
            "name": target_artist_name,
            "vendorId": vendor_id,
            "id": target_lp_id,
        },
    ]

    merged_artist_info = MagicMock()
    merged_artist_info.artist_id = merged_artist_id

    target_artist_info = MagicMock()
    target_artist_info.artist_id = target_artist_id
    target_artist_info.name = target_artist_name

    mock_get_artist_info_by_artist_name.side_effect = [
        merged_artist_info,
        target_artist_info,
    ]

    mock_resp = MagicMock()
    mock_resp.status = 200
    mock_response.return_value = mock_resp

    result = artist_name_updates.merge_lp_and_artist_names(
        uuid_1,
        uuid_2,
        merged_artist_uuid,
    )

    mock_rename_release_artist.assert_called_once_with(
        merged_artist_name,
        vendor_id,
        target_artist_name,
        target_artist_id,
        merged_artist_id,
    )
    mock_rename_track_artist.assert_called_once_with(
        merged_artist_name,
        vendor_id,
        target_artist_name,
        target_artist_id,
        merged_artist_id,
    )
    mock_rename_track_writer.assert_called_once_with(
        merged_artist_name,
        vendor_id,
        target_artist_name,
        target_artist_id,
        merged_artist_id,
    )
    mock_reassign_artist_for_project.assert_called_once_with(
        merged_artist_id,
        target_artist_id,
    )
    mock_reassign_artist_for_product.assert_called_once_with(
        merged_artist_id,
        target_artist_id,
    )
    mock_merge_nodes_by_id.assert_called_once_with(source_lp_id, target_lp_id)
    mock_remove_all_artist_id_references.assert_called_once_with(merged_artist_id)
    mock_update_last_updated_for_affected_products.assert_called_once_with(
        target_artist_id
    )
    mock_response.assert_called_once_with(
        status=200,
        message="Artist is merged successfully.",
    )
    assert result.status == 200