"""Test for asset_received_queue model."""

from unittest.mock import patch

import pytest

from sqlalchemy.exc import SQLAlchemyError

from assets.models.legacy import asset_received_queue
from tests.models.legacy import dd_operations


@pytest.fixture
def asset_received_queue_data():
    """Get data to seed asset_received_queue table."""
    return [
        {
            'asset_type_id': 2,
            'priority': 3,
            'picked_up': 'N',
            'import_asset_id': 4,
            'uploaded_asset_filename': 'fred.mp3',
            'job_type': 'upload'
        }, {
            'asset_type_id': 1,
            'priority': 5,
            'picked_up': 'N',
            'import_asset_id': 2,
            'uploaded_asset_filename': 'filename.wav',
            'job_type': 'upload'
        }, {
            'asset_type_id': 1,
            'priority': 15,
            'picked_up': 'Y',
            'import_asset_id': 3,
            'uploaded_asset_filename': 'filename.flac',
            'job_type': 'upload'
        }
    ]


@pytest.fixture
def asset_received_queue_details_data():
    """Get data to seed asset_received_destination_details table."""
    return [
        {
            'asset_received_queue_id': 1,
            'destination_upc': 111222333,
            'destination_track_id': 1,
            'destination_asset_name': 'asset_name1'
        }, {
            'asset_received_queue_id': 2,
            'destination_upc': 111222333,
            'destination_track_id': 2,
            'destination_asset_name': 'asset_name2'
        }, {
            'asset_received_queue_id': 3,
            'destination_upc': 999999999,
            'destination_track_id': 1,
            'destination_asset_name': 'name'
        }
    ]


@pytest.fixture
def db_fixture(asset_received_queue_data, asset_received_queue_details_data):
    """Set up the asset received queue table."""
    dd_operations.create_tables()
    dd_operations.seed_asset_received_queue_table(asset_received_queue_data)
    dd_operations.seed_asset_received_destination_details_table(
        asset_received_queue_details_data)


def test_get_asset_received_queue_by_id(db_fixture, asset_received_queue_data):
    """Test the model definition is interpretable by sqlalchemy."""
    result = asset_received_queue.get_asset_received_queue_by_id(1)
    assert result
    message = result.message
    assert (message.get('uploaded_asset_filename') ==
            asset_received_queue_data[0].get('uploaded_asset_filename'))


def test_get_asset_received_queue_by_id_not_found(db_fixture):
    """Test the model definition is interpretable by sqlalchemy."""
    result = asset_received_queue.get_asset_received_queue_by_id(100)
    assert not result
    assert result.status == 404


def test_create_asset_received_queue(db_fixture):
    """Test asset received queue record creation."""
    expected_asset_type_id = 10
    expected_priority = 2
    expected_picked_up = 'N'
    expected_import_asset_id = 111
    expected_uploaded_asset_filename = 'filename.ext'
    expected_job_type = 'upload'

    response = asset_received_queue.create_asset_received_queue(
        asset_type_id=expected_asset_type_id, priority=expected_priority,
        import_asset_id=expected_import_asset_id,
        uploaded_asset_filename=expected_uploaded_asset_filename)

    assert response.status
    assert response.message['id'] == 4
    assert response.message['asset_type_id'] == expected_asset_type_id
    assert response.message['priority'] == expected_priority
    assert response.message['picked_up'] == expected_picked_up
    assert response.message['import_asset_id'] == expected_import_asset_id
    assert response.message['uploaded_asset_filename'] ==\
        expected_uploaded_asset_filename
    assert response.message['job_type'] == expected_job_type


@patch('assets.connectors.mysql.dd_db_session', side_effect=SQLAlchemyError())
def test_create_asset_received_queue_error(monkeypatch):
    """Test asset received queue record with exception."""
    response = asset_received_queue.create_asset_received_queue(
        asset_type_id=10, priority=1, import_asset_id=111,
        uploaded_asset_filename='filename.ext')

    assert response.status == 500


def test_get_assets_by_upc(
        db_fixture, asset_received_queue_data):
    """Test getting asset received queue items by upc."""
    expected_upc = 111222333
    response = asset_received_queue.get_assets_by_upc(expected_upc)
    data = response.message

    queue_assertion_keys = [
        'asset_type_id', 'priority', 'picked_up', 'import_asset_id',
        'uploaded_asset_filename', 'job_type']

    assert response.status
    assert len(data) == 2
    for key in queue_assertion_keys:
        assert (data[0]['asset_received_item'][key] ==
                asset_received_queue_data[0][key])
        assert (data[1]['asset_received_item'][key] ==
                asset_received_queue_data[1][key])
    assert data[0]['asset_received_details']['upc'] == expected_upc
    assert data[1]['asset_received_details']['upc'] == expected_upc


def test_get_assets_by_upc_empty(db_fixture):
    """Test getting asset received queue items by upc with empty response."""
    response = asset_received_queue.get_assets_by_upc(999888)
    data = response.message

    assert response
    assert data == []


@patch('assets.connectors.mysql.dd_db_session', side_effect=SQLAlchemyError())
def test_get_assets_by_upc_error(monkeypatch):
    """Test getting asset received queue items by upc with exception."""
    response = asset_received_queue.get_assets_by_upc(111222333)

    assert response.status == 500