"""Unit tests for the release subgenre model."""

from unittest import mock

import pytest

from product_digital.connectors import mysql
from product_digital.models import release_subgenre
from product_digital.utils import error_handling
from tests.factories import release_subgenre as factory
from tests.testutils import db


@pytest.fixture
def test_release_subgenre():
    """Create a set of release subgenre data for testing."""
    return {
        'release_id': 1234,
        'subgenre_id': 5678,
        'upc': 123456789012}


def last_release_subgenre(session):
    """Get the last record from the db."""
    id_column = release_subgenre.ReleaseSubgenre.release_subgenre_id
    return session.query(
        release_subgenre.ReleaseSubgenre).order_by(id_column.desc()).first()


@db.test_schema
def test_get_release_subgenre_by_release_id_success():
    """Test that a release-subgenre mapping is returned."""
    release_id = 12345
    test_release_subgenre = factory.ReleaseSubgenreFactory.build(
        release_id=release_id)
    db.seed_models(test_release_subgenre)
    result = release_subgenre.get_release_subgenre_by_release_id(release_id)

    assert result.status == 200
    assert 'release_subgenre_id' in result.message
    assert result.message['subgenre_id'] == test_release_subgenre.subgenre_id


@db.test_schema
def test_get_release_subgenre_by_release_id_not_found():
    """Test that a 404 status is returned if no release subgenre is found."""
    result = release_subgenre.get_release_subgenre_by_release_id(12345)

    assert result.status == 404
    assert result.errors == {
        'code': 'not_found_error',
        'message': 'release subgenre mapping not found'}


def test_get_release_subgenre_by_release_id_db_error(db_exception, mocker):
    """Test that DB exceptions are logged and a 500 is returned."""
    mock_session = db.mock_db_session(mocker)
    mock_session.query.side_effect = db_exception
    mocker.patch.object(error_handling, 'log_db_exception', mock.Mock())

    result = release_subgenre.get_release_subgenre_by_release_id(12345)

    assert result.status == 500
    error_handling.log_db_exception.assert_called_once_with(db_exception)


def test_to_json_properties():
    """Test that the expected properties are returned."""
    new_release_subgenre = release_subgenre.ReleaseSubgenre(
        release_subgenre_id=1234, release_id=5678,
        upc=123456789012, subgenre_id=9012)
    assert new_release_subgenre.to_dict() == {
        'release_subgenre_id': new_release_subgenre.release_subgenre_id,
        'release_id': new_release_subgenre.release_id,
        'subgenre_id': new_release_subgenre.subgenre_id}


@db.test_schema
def test_save_release_subgenre_new_response(test_release_subgenre):
    """Test response contents when creating a new release-subgenre mapping."""
    result = release_subgenre.save_release_subgenre(test_release_subgenre)
    message = result.message

    assert result.status == 200
    assert 'release_subgenre_id' in message
    assert message['release_id'] == test_release_subgenre['release_id']
    assert message['subgenre_id'] == test_release_subgenre['subgenre_id']


@db.test_schema
def test_save_release_subgenre_new_persistence(test_release_subgenre):
    """Test that a new release-subgenre mapping is saved to the database."""
    result = release_subgenre.save_release_subgenre(test_release_subgenre)

    with mysql.db_session() as session:
        last_record = last_release_subgenre(session)
        last_id = last_record.release_subgenre_id

        assert result.message['release_subgenre_id'] == last_id
        assert last_record.upc == test_release_subgenre['upc']
        assert last_record.release_id == test_release_subgenre['release_id']
        assert last_record.subgenre_id == test_release_subgenre['subgenre_id']


@db.test_schema
def test_save_release_subgenre_update_response(test_release_subgenre):
    """Test response contents when updating a release-subgenre mapping."""
    existing_rs = factory.ReleaseSubgenreFactory.build(**test_release_subgenre)
    db.seed_models(existing_rs)
    result = release_subgenre.save_release_subgenre(test_release_subgenre)
    message = result.message

    assert result.status == 200
    assert message['release_subgenre_id'] == existing_rs.release_subgenre_id
    assert message['release_id'] == test_release_subgenre['release_id']
    assert message['subgenre_id'] == test_release_subgenre['subgenre_id']


@db.test_schema
def test_save_release_subgenre_update_persistence(test_release_subgenre):
    """Test that a release-subgenre mapping is properly update in the db."""
    existing_rs = factory.ReleaseSubgenreFactory.build(**test_release_subgenre)
    db.seed_models(existing_rs)
    test_release_subgenre['subgenre_id'] += 500
    release_subgenre.save_release_subgenre(test_release_subgenre)

    with mysql.db_session() as session:
        id_column = release_subgenre.ReleaseSubgenre.release_subgenre_id
        last_record = session.query(
            release_subgenre.ReleaseSubgenre).order_by(
                id_column.desc()).first()

        existing_id = existing_rs.release_subgenre_id
        assert last_record.release_subgenre_id == existing_id
        assert last_record.upc == test_release_subgenre['upc']
        assert last_record.release_id == test_release_subgenre['release_id']
        assert last_record.subgenre_id == test_release_subgenre['subgenre_id']


def test_save_release_subgenre_db_error(
        db_exception, mocker, test_release_subgenre):
    """Test that a DB error is logged and 500 status is returned."""
    mock_session = db.mock_db_session(mocker)
    mock_session.query.side_effect = db_exception
    mocker.patch.object(error_handling, 'log_db_exception', mock.Mock())

    result = release_subgenre.save_release_subgenre(test_release_subgenre)

    assert result.status == 500
    error_handling.log_db_exception.assert_called_once_with(db_exception)


@db.test_schema
def test_delete_release_subgenre(test_release_subgenre):
    """Test that a release_subgenre is deleted when set to null."""
    existing_rs = factory.ReleaseSubgenreFactory.build(**test_release_subgenre)
    db.seed_models(existing_rs)
    release_id = test_release_subgenre.get('release_id')

    with mysql.db_session() as session:
        existing_release_subgenre = session.query(
            release_subgenre.ReleaseSubgenre).filter_by(
                release_id=release_id).first()

        assert existing_release_subgenre.release_id == release_id

    delete_result = release_subgenre.delete_release_subgenre(release_id)

    with mysql.db_session() as session:
        still_existing_release_subgenre = session.query(
            release_subgenre.ReleaseSubgenre).filter_by(
                release_id=release_id).first()

        assert still_existing_release_subgenre is None

    assert delete_result.status == 200