"""Tests for get asset by filename logic layer."""

from datetime import datetime
from unittest.mock import MagicMock

import flexmock
from oto import response
import pytest

from assets.constants import asset_types
from assets.constants import error
from assets.logic.legacy import import_asset as import_asset_logic
from assets.models import ows_product
from assets.models.legacy import import_asset
from assets.models.legacy import import_asset_batch
from assets.models.legacy import import_asset_detail


@pytest.fixture
def fixture_import_asset():
    """Fixture return import asset entry."""
    return response.Response({
        'id': 1,
        'import_asset_batch_id': 1,
        'foldername': 'import_assets_folder',
        'asset_type': asset_types.TYPE_IMPORT_AUDIO,
        'status': 'error',
        'upload_completed': datetime.strptime(
            '2017-01-10T11:41:12.997656', '%Y-%m-%dT%H:%M:%S.%f'),
        'encoding_completed': datetime.strptime(
            '2017-02-15T17:40:12.997656', '%Y-%m-%dT%H:%M:%S.%f'),
        'result': 'ooh, something went really wrong here',
        'filename': 'test_file',
    })


@pytest.fixture
def fixture_import_asset_detail():
    """Fixture return import asset detail entry."""
    return response.Response({
        'import_asset_id': 1,
        'upc': '123456'
    })


@pytest.fixture
def fixture_get_product_by_upc():
    """Fixture return correct get_product_by_upc response."""
    return response.Response({
        'product_id': 321
    })


@pytest.fixture
def fixture_ownership_response():
    """Fixture return correct ownership response."""
    return response.Response()


@pytest.fixture
def get_status_by_filename_fixtures(fixture_import_asset):
    """Fixture return all mocks for get_status_by_filename."""
    return {
        'import_asset': MagicMock(return_value=fixture_import_asset),
        'ownership': MagicMock(return_value=fixture_ownership_response)
    }


@pytest.fixture
def check_import_asset_ownership_fixtures(
        fixture_import_asset_detail, fixture_get_product_by_upc,
        fixture_ownership_response):
    """Fixture return all mocks for _check_import_asset_ownership."""
    return {
        'asset_detail': MagicMock(return_value=fixture_import_asset_detail),
        'get_product_by_upc': MagicMock(
            return_value=fixture_get_product_by_upc),
        'ownership': MagicMock(return_value=fixture_ownership_response)
    }


def test_get_import_status_by_filename_success(
        monkeypatch, fixture_import_asset):
    """Test getting import asset by filename."""
    response_mock = MagicMock(return_value=fixture_import_asset)
    monkeypatch.setattr(
        import_asset, 'get_import_asset_by_filename', response_mock)

    filename = 'test_file'
    result = import_asset_logic.get_status_by_filename(filename)
    assert result
    assert result.message['status'] == fixture_import_asset.message['status']
    assert result.message['message'] == fixture_import_asset.message['result']

    assert response_mock.call_args[0][0] == filename


def test_get_import_status_by_filename_ownership_check_success(
        monkeypatch, fixture_import_asset, get_status_by_filename_fixtures):
    """Test getting import asset by filename."""
    monkeypatch.setattr(
        import_asset, 'get_import_asset_by_filename',
        get_status_by_filename_fixtures['import_asset'])
    monkeypatch.setattr(
        import_asset_logic, '_check_import_asset_ownership',
        get_status_by_filename_fixtures['ownership'])

    filename = 'test_file'
    result = import_asset_logic.get_status_by_filename(filename, 'vendor', 123)
    assert result
    assert result.message['status'] == fixture_import_asset.message['status']

    call_args = get_status_by_filename_fixtures['import_asset'].call_args
    assert call_args[0][0] == filename


@pytest.mark.parametrize('failing_mock', [
    'import_asset',
    'ownership'
])
def test_get_import_status_by_filename_alw_failure(
        monkeypatch, failing_mock, get_status_by_filename_fixtures):
    """Test getting import asset by filename failure for alw user."""
    get_status_by_filename_fixtures[failing_mock] = MagicMock(
        return_value=response.create_fatal_response('Test error'))

    monkeypatch.setattr(
        import_asset, 'get_import_asset_by_filename',
        get_status_by_filename_fixtures['import_asset'])
    monkeypatch.setattr(
        import_asset_logic, '_check_import_asset_ownership',
        get_status_by_filename_fixtures['ownership'])

    filename = 'test_file'
    result = import_asset_logic.get_status_by_filename(filename, 'vendor', 123)
    assert result.status == 500


@pytest.fixture
def ownership_check_args():
    """Mock to return _check_import_asset_ownership call args."""
    return {
        'import_asset_id': 123,
        'account_type': 'vendor',
        'account_id': 54321
    }


def test_check_import_asset_ownership_success(
        monkeypatch, check_import_asset_ownership_fixtures,
        ownership_check_args):
    """Test _check_import_asset_ownership failure."""
    monkeypatch.setattr(
        import_asset_detail, 'get_by_import_asset_id',
        check_import_asset_ownership_fixtures['asset_detail'])
    monkeypatch.setattr(
        ows_product, 'get_product_by_upc',
        check_import_asset_ownership_fixtures['get_product_by_upc'])
    monkeypatch.setattr(
        ows_product, 'check_ownership',
        check_import_asset_ownership_fixtures['ownership'])

    result = import_asset_logic._check_import_asset_ownership(
        **ownership_check_args)
    assert result


@pytest.mark.parametrize('failing_mock', [
    'asset_detail',
    'get_product_by_upc',
    'ownership'
])
def test_check_import_asset_ownership_failure(
        monkeypatch, check_import_asset_ownership_fixtures, failing_mock,
        ownership_check_args):
    """Test _check_import_asset_ownership failure."""
    check_import_asset_ownership_fixtures[failing_mock] = MagicMock(
        return_value=response.create_fatal_response('Test error'))

    monkeypatch.setattr(
        import_asset_detail, 'get_by_import_asset_id',
        check_import_asset_ownership_fixtures['asset_detail'])
    monkeypatch.setattr(
        ows_product, 'get_product_by_upc',
        check_import_asset_ownership_fixtures['get_product_by_upc'])
    monkeypatch.setattr(
        ows_product, 'check_ownership',
        check_import_asset_ownership_fixtures['ownership'])

    result = import_asset_logic._check_import_asset_ownership(
        **ownership_check_args)
    assert result.status == 500


def test_get_import_status_by_filename_internal_error_failure_oa_user(
        monkeypatch):
    """Test getting import asset by filename failure for oa user."""
    monkeypatch.setattr(
        import_asset, 'get_import_asset_by_filename',
        MagicMock(return_value=response.create_fatal_response('Test error')))

    filename = 'test_file'
    result = import_asset_logic.get_status_by_filename(filename)
    assert result.status == 500


def test_get_import_status_by_empty_filename_failure(
        monkeypatch):
    """Test getting import asset by empty filename failure."""
    response_mock = MagicMock(return_value=response.create_not_found_response(
        error.ERROR_MESSAGE_ASSET_NOT_FOUND))
    monkeypatch.setattr(
        import_asset, 'get_import_asset_by_filename', response_mock)

    result = import_asset_logic.get_status_by_filename('')
    assert result.status == 400


def test_create_import_asset_batch_alw_user():
    """Test import asset batch record creation for alw user."""
    (flexmock(import_asset_batch)
     .should_receive('create_import_asset_batch')
     .with_args(
        impersonated=0,
        vendor_contact_id=10,
        ip_address=0,
        import_type='upload')
     .and_return(response.Response())
     .once())

    result = import_asset_logic.create_import_asset_batch(
        full_user_id='alw:10')

    assert result


def test_create_import_asset_batch_oa_user():
    """Test import asset batch record creation for oa user."""
    (flexmock(import_asset_batch)
     .should_receive('create_import_asset_batch')
     .with_args(
        impersonated=20,
        vendor_contact_id=None,
        ip_address=0,
        import_type='upload')
     .and_return(response.Response())
     .once())

    result = import_asset_logic.create_import_asset_batch(full_user_id='oa:20')

    assert result


def test_create_import_asset_batch_no_user():
    """Test import asset batch record creation no user failure."""
    result = import_asset_logic.create_import_asset_batch(full_user_id=None)

    assert not result
    assert result.status == 400