"""Tests for product module."""

import flexmock

from oto import response

import pytest

from assets.constants import error
from assets.logic import image_location
from assets.logic.legacy import product
from assets.logic.legacy import stream_info
from assets.models import ows_product
from assets.models.legacy import asset_received_queue
from assets.models.legacy import asset_type
from assets.models.legacy import import_asset


@pytest.fixture
def fixture_product():
    """Fixture for product model return."""
    return {
        'product_id': 10,
        'upc': 123456789
    }


@pytest.fixture
def fixture_asset_received():
    """Fixture for asset_received_queue model return."""
    return [{
        'asset_received_item': {
            'import_asset_id': 1,
            'asset_type_id': 2
        },
        'asset_received_details': {
            'track_id': 0
        }
    }, {
        'asset_received_item': {
            'import_asset_id': 2,
            'asset_type_id': 1
        },
        'asset_received_details': {
            'track_id': 99
        }
    }, {
        'asset_received_item': {
            'import_asset_id': 3,
            'asset_type_id': 1
        },
        'asset_received_details': {
            'track_id': 99
        }
    }, {
        'asset_received_item': {
            'import_asset_id': 4,
            'asset_type_id': 1
        },
        'asset_received_details': {
            'track_id': 777
        }
    }]


@pytest.fixture
def fixture_import_assets_ids():
    """Fixture for list of import_asset ids."""
    return [1, 2, 3, 4]


@pytest.fixture
def fixture_import_assets():
    """Fixture for import_assets model return."""
    return [{
        'import_asset': {
            'id': 1,
            'filename': 'filename1.jpg',
            'asset_type': 'image',
            'status': 'finished'
        },
        'import_asset_detail': {
            'track_id': 0
        }
    }, {
        'import_asset': {
            'id': 2,
            'filename': 'filename2.wav',
            'asset_type': 'audio',
            'status': 'finished'
        },
        'import_asset_detail': {
            'track_id': 111
        }
    }, {
        'import_asset': {
            'id': 3,
            'filename': 'filename2.wav',
            'asset_type': 'audio',
            'status': 'new'
        },
        'import_asset_detail': {
            'track_id': 111
        }
    }, {
        'import_asset': {
            'id': 4,
            'filename': 'filename3.wav',
            'asset_type': 'audio',
            'status': 'new'
        },
        'import_asset_detail': {
            'track_id': 222
        }
    }]


@pytest.fixture
def fixture_stream():
    """Fixture for get_stream return."""
    return {
        'stream': {
            'url': 'stream_url',
            'duration': 10,
            'track_unique_id': 111
        },
        'access': {
            'user_id': 123,
            'user_type': 'alw'
        }
    }


@pytest.fixture
def fixture_image_location():
    """Fixture for get_image_location."""
    return 'image_location'


@pytest.fixture
def fixture_asset_type():
    """Fixture for asset types."""
    return [{
        'asset': 'JPG'
    }, {
        'asset': 'WAV'
    }]


@pytest.fixture
def fixture_expected_product_assets(
        fixture_asset_received, fixture_import_assets,
        fixture_stream, fixture_image_location):
    """Fixture for successful getting product assets."""
    return [{
        'filename': fixture_import_assets[0]['import_asset']['filename'],
        'asset_type': fixture_import_assets[0]['import_asset']['asset_type'],
        'status': fixture_import_assets[0]['import_asset']['status'],
        'url': fixture_image_location
    }, {
        'filename': fixture_import_assets[1]['import_asset']['filename'],
        'asset_type': fixture_import_assets[1]['import_asset']['asset_type'],
        'status': fixture_import_assets[1]['import_asset']['status'],
        'track_unique_id': (
            fixture_asset_received[1]['asset_received_details']['track_id']),
        'stream': fixture_stream['stream'],
        'access': fixture_stream['access']
    }, {
        'filename': fixture_import_assets[3]['import_asset']['filename'],
        'asset_type': fixture_import_assets[3]['import_asset']['asset_type'],
        'status': fixture_import_assets[3]['import_asset']['status'],
        'track_unique_id': (
            fixture_asset_received[3]['asset_received_details']['track_id'])
    }]


def test_get_product_assets(
        fixture_product, fixture_asset_received,
        fixture_import_assets_ids, fixture_import_assets, fixture_asset_type,
        fixture_image_location, fixture_stream,
        fixture_expected_product_assets):
    """Test for getting product assets."""
    expected_user_info = 'alw:123'

    (flexmock(ows_product)
     .should_receive('get_product_by_id')
     .with_args(product_id=fixture_product['product_id'])
     .and_return(response.Response(fixture_product))
     .once())

    (flexmock(asset_received_queue)
     .should_receive('get_assets_by_upc')
     .with_args(upc=fixture_product['upc'])
     .and_return(response.Response(fixture_asset_received))
     .once())

    (flexmock(import_asset)
     .should_receive('get_assets_by_ids')
     .with_args(ids=fixture_import_assets_ids)
     .and_return(response.Response(fixture_import_assets))
     .once())

    (flexmock(asset_type)
     .should_receive('get_asset_type_by_id')
     .with_args(2)
     .and_return(response.Response(fixture_asset_type[0]))
     .once())

    (flexmock(asset_type)
     .should_receive('get_asset_type_by_id')
     .with_args(1)
     .and_return(response.Response(fixture_asset_type[1]))
     .twice())

    (flexmock(image_location)
     .should_receive('get_image_location')
     .with_args(fixture_product['product_id'], 'product', 'cover')
     .and_return(response.Response(fixture_image_location))
     .once())

    (flexmock(stream_info)
     .should_receive('get_stream')
     .with_args(
        fixture_asset_received[1]['asset_received_details']['track_id'],
        expected_user_info)
     .and_return(response.Response(fixture_stream))
     .once())

    result = product.get_product_assets(
        fixture_product['product_id'], expected_user_info)

    assert result
    assert result.message['product_id'] == fixture_product['product_id']
    assert result.message['upc'] == fixture_product['upc']
    assert result.message['assets'] == fixture_expected_product_assets


def test_get_product_assets_with_product_error():
    """Test for getting product assets with error in ows_product."""
    (flexmock(ows_product)
     .should_receive('get_product_by_id')
     .with_args(product_id=10)
     .and_return(response.create_fatal_response('error')))

    result = product.get_product_assets(10, 'alw:123')

    assert not result
    assert result.errors['message'] == 'error'


def test_get_product_assets_with_import_assets_error(
        fixture_product, fixture_asset_received,
        fixture_import_assets_ids):
    """Test for getting product assets with error in import_assets."""
    expected_user_info = 'alw:123'

    (flexmock(ows_product)
     .should_receive('get_product_by_id')
     .with_args(product_id=fixture_product['product_id'])
     .and_return(response.Response(fixture_product))
     .once())

    (flexmock(asset_received_queue)
     .should_receive('get_assets_by_upc')
     .with_args(upc=fixture_product['upc'])
     .and_return(response.Response(fixture_asset_received))
     .once())

    (flexmock(import_asset)
     .should_receive('get_assets_by_ids')
     .with_args(ids=fixture_import_assets_ids)
     .and_return(response.create_fatal_response('error'))
     .once())

    result = product.get_product_assets(
        fixture_product['product_id'], expected_user_info)

    assert not result
    assert result.errors['message'] == 'error'


def test_get_product_assets_with_asset_received_queue_error(
        fixture_product):
    """Test for getting product assets with error in asset_received_queue."""
    expected_user_info = 'alw:123'

    (flexmock(ows_product)
     .should_receive('get_product_by_id')
     .with_args(product_id=fixture_product['product_id'])
     .and_return(response.Response(fixture_product))
     .once())

    (flexmock(asset_received_queue)
     .should_receive('get_assets_by_upc')
     .with_args(upc=fixture_product['upc'])
     .and_return(response.create_fatal_response('error'))
     .once())

    result = product.get_product_assets(
        fixture_product['product_id'], expected_user_info)

    assert not result
    assert result.errors['message'] == 'error'


def test_get_product_assets_with_asset_type_error(
        fixture_product, fixture_asset_received,
        fixture_import_assets_ids, fixture_import_assets):
    """Test for getting product assets with error in asset_type."""
    expected_user_info = 'alw:123'

    (flexmock(ows_product)
     .should_receive('get_product_by_id')
     .with_args(product_id=fixture_product['product_id'])
     .and_return(response.Response(fixture_product))
     .once())

    (flexmock(asset_received_queue)
     .should_receive('get_assets_by_upc')
     .with_args(upc=fixture_product['upc'])
     .and_return(response.Response(fixture_asset_received))
     .once())

    (flexmock(import_asset)
     .should_receive('get_assets_by_ids')
     .with_args(ids=fixture_import_assets_ids)
     .and_return(response.Response(fixture_import_assets))
     .once())

    (flexmock(asset_type)
     .should_receive('get_asset_type_by_id')
     .with_args(2)
     .and_return(response.create_fatal_response('error'))
     .once())

    result = product.get_product_assets(
        fixture_product['product_id'], expected_user_info)

    assert not result
    assert result.errors['message'] == 'error'


def test_get_product_assets_with_wrong_asset_type(
        fixture_product, fixture_asset_received,
        fixture_import_assets_ids, fixture_import_assets):
    """Test for getting product assets with wrong asset_type."""
    expected_user_info = 'alw:123'

    (flexmock(ows_product)
     .should_receive('get_product_by_id')
     .with_args(product_id=fixture_product['product_id'])
     .and_return(response.Response(fixture_product))
     .once())

    (flexmock(asset_received_queue)
     .should_receive('get_assets_by_upc')
     .with_args(upc=fixture_product['upc'])
     .and_return(response.Response(fixture_asset_received))
     .once())

    (flexmock(import_asset)
     .should_receive('get_assets_by_ids')
     .with_args(ids=fixture_import_assets_ids)
     .and_return(response.Response(fixture_import_assets))
     .once())

    (flexmock(asset_type)
     .should_receive('get_asset_type_by_id')
     .with_args(2)
     .and_return(response.Response({'asset': 'SOMETHING'}))
     .once())

    result = product.get_product_assets(
        fixture_product['product_id'], expected_user_info)

    assert not result
    assert result.errors['message'] == error.ERROR_WRONG_ASSET_TYPE


def test_get_product_assets_with_image_location_error(
        fixture_product, fixture_asset_received,
        fixture_import_assets_ids, fixture_import_assets,
        fixture_asset_type):
    """Test for getting product assets with error in import_assets."""
    expected_user_info = 'alw:123'

    (flexmock(ows_product)
     .should_receive('get_product_by_id')
     .with_args(product_id=fixture_product['product_id'])
     .and_return(response.Response(fixture_product))
     .once())

    (flexmock(asset_received_queue)
     .should_receive('get_assets_by_upc')
     .with_args(upc=fixture_product['upc'])
     .and_return(response.Response(fixture_asset_received))
     .once())

    (flexmock(import_asset)
     .should_receive('get_assets_by_ids')
     .with_args(ids=fixture_import_assets_ids)
     .and_return(response.Response(fixture_import_assets))
     .once())

    (flexmock(asset_type)
     .should_receive('get_asset_type_by_id')
     .with_args(2)
     .and_return(response.Response(fixture_asset_type[0]))
     .once())

    (flexmock(image_location)
     .should_receive('get_image_location')
     .with_args(fixture_product['product_id'], 'product', 'cover')
     .and_return(response.create_fatal_response('error'))
     .once())

    result = product.get_product_assets(
        fixture_product['product_id'], expected_user_info)

    assert not result
    assert result.errors['message'] == 'error'


def test_get_product_assets_with_stream_info_error(
        fixture_product, fixture_asset_received,
        fixture_import_assets_ids, fixture_import_assets, fixture_asset_type,
        fixture_image_location):
    """Test for getting product assets."""
    expected_user_info = 'alw:123'

    (flexmock(ows_product)
     .should_receive('get_product_by_id')
     .with_args(product_id=fixture_product['product_id'])
     .and_return(response.Response(fixture_product))
     .once())

    (flexmock(asset_received_queue)
     .should_receive('get_assets_by_upc')
     .with_args(upc=fixture_product['upc'])
     .and_return(response.Response(fixture_asset_received))
     .once())

    (flexmock(import_asset)
     .should_receive('get_assets_by_ids')
     .with_args(ids=fixture_import_assets_ids)
     .and_return(response.Response(fixture_import_assets))
     .once())

    (flexmock(asset_type)
     .should_receive('get_asset_type_by_id')
     .with_args(2)
     .and_return(response.Response(fixture_asset_type[0]))
     .once())

    (flexmock(asset_type)
     .should_receive('get_asset_type_by_id')
     .with_args(1)
     .and_return(response.Response(fixture_asset_type[1]))
     .once())

    (flexmock(image_location)
     .should_receive('get_image_location')
     .with_args(fixture_product['product_id'], 'product', 'cover')
     .and_return(response.Response(fixture_image_location))
     .once())

    (flexmock(stream_info)
     .should_receive('get_stream')
     .with_args(
        fixture_asset_received[1]['asset_received_details']['track_id'],
        expected_user_info)
     .and_return(response.create_fatal_response('error'))
     .once())

    result = product.get_product_assets(
        fixture_product['product_id'], expected_user_info)

    assert not result
    assert result.errors['message'] == 'error'