"""Tests for stream info module."""

import datetime
from unittest.mock import MagicMock

import flexmock
from freezegun import freeze_time
from oto import response
import pytest

from assets import config
from assets.constants import asset_types
from assets.constants import field_const
from assets.logic.legacy import stream_info
from assets.models import ows_product
from assets.models import ows_track
from assets.models.legacy import asset
from assets.models.legacy import asset_type
from assets.models.legacy import trackdown_media_access


@pytest.fixture
def fixture_track():
    """Fixture for a track info."""
    return {
        'product_id': 125,
        'upc': '111222333444',
        'volume_number': 1,
        'track_number': 1
    }


@pytest.fixture
def fixture_product():
    """Fixture for a product info."""
    return {
        'status': 'in_content',
        'upc': '111222333444'
    }


@pytest.fixture
def fixture_asset_type():
    """Fixture for asset type."""
    return {
        'id': 1,
        'asset': 'MP3_192',
        'file_type': asset_types.TYPE_PATH_STRUCTURE_DIRECTORY
    }


@pytest.fixture
def fixture_asset_stream_info():
    """Fixture for asset streaming info."""
    return {
        'upc': 111222333444,
        'cd': 0,
        'track_id': 0,
        'local_ip': 168437923,
        'storage_id': 43,
        'initial_folder': 'wav/',
        'folder_structure': '{upc(0,6)}/{upc(6,3)}/{upc}',
        'filename': '111222333444_1_1.wav',
        'duration': 100.50,
        'path_structure_type': asset_types.TYPE_PATH_STRUCTURE_DIRECTORY
    }


@pytest.fixture
def fixture_asset_stream_url():
    """Fixture for asset streaming url."""
    return {
        'stream_url': 'url',
        'duration': 100.50
    }


@pytest.fixture
def fixture_stream_token():
    """Fixture for asset stream token data."""
    return {
        'user_id': 123,
        'user_type': 'oa',
        'token': 'stream_token',
        'token_type': 'type'
    }


def test_get_track_stream_url(
        monkeypatch, fixture_track, fixture_product, fixture_asset_type,
        fixture_asset_stream_info):
    """Test getting track stream url."""
    monkeypatch.setattr(
        ows_track, 'get_track_by_id',
        MagicMock(return_value=response.Response(fixture_track)))
    monkeypatch.setattr(
        ows_product, 'get_product_by_id',
        MagicMock(return_value=response.Response(fixture_product)))
    monkeypatch.setattr(
        asset_type, 'get_asset_type_by_name',
        MagicMock(return_value=response.Response(fixture_asset_type)))
    monkeypatch.setattr(
        asset, 'get_streaming_info',
        MagicMock(return_value=response.Response(fixture_asset_stream_info))
    )
    stream_response = stream_info._get_track_stream_url(100)

    ows_track.get_track_by_id.assert_called_with(100)
    asset_type.get_asset_type_by_name.assert_called_with(
        asset_types.DEFAULT_STREAM_AUDIO_TYPE)
    asset.get_streaming_info.assert_called_with(
        fixture_track['upc'], fixture_asset_type['id'],
        config.SERVER_LOCATION_AVL, '111222333444_1_1.%')
    assert stream_response.status == 200
    assert (stream_response.message['duration'] ==
            fixture_asset_stream_info['duration'])
    assert (stream_response.message['stream_url'] ==
            config.STREAM_URL_PREFIX +
            '/43/wav/111222/333/111222333444/' +
            '111222333444_1_1')


def test_get_track_stream_url_with_wrong_track_id(monkeypatch):
    """Test getting track stream url for wrong track id."""
    monkeypatch.setattr(
        ows_track, 'get_track_by_id',
        MagicMock(return_value=response.create_not_found_response()))
    stream_response = stream_info._get_track_stream_url(100)

    ows_track.get_track_by_id.assert_called_with(100)
    assert stream_response.status == 404


def test_get_track_stream_url_with_wrong_asset_type(
        monkeypatch, fixture_track, fixture_product):
    """Test getting track stream url for wrong asset type."""
    monkeypatch.setattr(
        ows_track, 'get_track_by_id',
        MagicMock(return_value=response.Response(fixture_track)))
    monkeypatch.setattr(
        ows_product, 'get_product_by_id',
        MagicMock(return_value=response.Response(fixture_product)))
    monkeypatch.setattr(
        asset_type, 'get_asset_type_by_name',
        MagicMock(return_value=response.create_not_found_response()))
    stream_response = stream_info._get_track_stream_url(100)

    ows_track.get_track_by_id.assert_called_with(100)
    asset_type.get_asset_type_by_name.assert_called_with(
        asset_types.DEFAULT_STREAM_AUDIO_TYPE)
    assert stream_response.status == 404


def test_get_track_stream_url_with_not_found_asset(
        monkeypatch, fixture_track, fixture_product, fixture_asset_type):
    """Test getting track stream url for non-existed asset."""
    monkeypatch.setattr(
        ows_track, 'get_track_by_id',
        MagicMock(return_value=response.Response(fixture_track)))
    monkeypatch.setattr(
        ows_product, 'get_product_by_id',
        MagicMock(return_value=response.Response(fixture_product)))
    monkeypatch.setattr(
        asset_type, 'get_asset_type_by_name',
        MagicMock(return_value=response.Response(fixture_asset_type)))
    monkeypatch.setattr(
        asset, 'get_streaming_info',
        MagicMock(return_value=response.create_not_found_response()))

    stream_response = stream_info._get_track_stream_url(100)

    ows_track.get_track_by_id.assert_called_with(100)
    asset_type.get_asset_type_by_name.assert_called_with(
        asset_types.DEFAULT_STREAM_AUDIO_TYPE)
    asset.get_streaming_info.assert_called_with(
        fixture_track['upc'], fixture_asset_type['id'],
        config.SERVER_LOCATION_AVL, '111222333444_1_1.%')
    assert stream_response.status == 404


def test_generate_stream_token():
    """Test for _generate_stream_token method."""
    result = stream_info._generate_stream_token()
    assert len(result) == 30


@pytest.fixture
def get_stream_token_args():
    """Return _get_stream_token args."""
    return {
        'user_id': 12345,
        'user_type': field_const.USER_TYPE_OA,
    }


@pytest.fixture
def get_stream_token_mocks():
    """Return stream token mocks."""
    stream_data_1 = {
        'token': 'session_token',
        'trackdown_user_id': 12345,
        'user_type': field_const.USER_TYPE_OA,
        'token_type': field_const.TOKEN_TYPE_STREAM,
        'id': 1,
        'last_accessed': datetime.datetime(2000, 1, 1, 0, 0, 1)
    }
    stream_data_2 = {
        'token': 'generated_stream_token',
        'trackdown_user_id': 12345,
        'user_type': field_const.USER_TYPE_OA,
        'token_type': field_const.TOKEN_TYPE_STREAM,
        'id': 1,
        'last_accessed': datetime.datetime(2000, 1, 1, 0, 0, 1)
    }
    not_found_response = response.create_not_found_response()
    return {
        'get_trackdown_media_access_ok': response.Response(
            message=stream_data_1),
        'get_trackdown_media_access_404': not_found_response,
        'update_last_accessed_datetime': response.Response(),
        'create_track_media_access': response.Response(
            message=stream_data_2)
    }


@freeze_time('2000-01-01 00:00:02')
def test_get_stream_token_success_token_exists(
        get_stream_token_args, get_stream_token_mocks):
    """Test for _get_stream_token success with existing token."""
    (flexmock(trackdown_media_access)
     .should_receive('get_trackdown_media_access')
     .with_args(token_type='stream', **get_stream_token_args)
     .and_return(get_stream_token_mocks['get_trackdown_media_access_ok']))

    (flexmock(trackdown_media_access)
     .should_receive('update_last_accessed_datetime')
     .with_args(
        trackdown_media_access_id=1,
        last_accessed=datetime.datetime(2000, 1, 1, 0, 0, 2))
     .and_return(get_stream_token_mocks['update_last_accessed_datetime']))

    result = stream_info._get_stream_token(**get_stream_token_args)
    assert result
    assert result.message['token'] == 'session_token'


def test_get_stream_token_success_token_not_exists(
        get_stream_token_args, get_stream_token_mocks):
    """Test for _get_stream_token success with no token."""
    (flexmock(trackdown_media_access)
     .should_receive('get_trackdown_media_access')
     .with_args(token_type='stream', **get_stream_token_args)
     .and_return(get_stream_token_mocks['get_trackdown_media_access_404']))

    (flexmock(stream_info)
     .should_receive('_generate_stream_token')
     .and_return('generated_stream_token'))

    (flexmock(trackdown_media_access)
     .should_receive('create_track_media_access')
     .with_args(
        user_id=12345, user_type='oa', token='generated_stream_token',
        token_type='stream')
     .and_return(get_stream_token_mocks['create_track_media_access']))

    result = stream_info._get_stream_token(**get_stream_token_args)
    assert result
    assert result.message['token'] == 'generated_stream_token'


def test_get_stream_token_failure_get_access_failure(
        get_stream_token_args, get_stream_token_mocks):
    """Test for failure of get_trackdown_media_access."""
    (flexmock(trackdown_media_access)
     .should_receive('get_trackdown_media_access')
     .and_return(response.create_fatal_response('get_trackdown_failure')))

    result = stream_info._get_stream_token(**get_stream_token_args)
    assert not result
    assert result.errors['message'] == 'get_trackdown_failure'


def test_get_stream_token_failure_update_failure(
        get_stream_token_args, get_stream_token_mocks):
    """Test for failure of update_last_accessed_datetime."""
    (flexmock(trackdown_media_access)
     .should_receive('get_trackdown_media_access')
     .and_return(get_stream_token_mocks['get_trackdown_media_access_ok']))

    (flexmock(trackdown_media_access)
     .should_receive('update_last_accessed_datetime')
     .and_return(response.create_fatal_response('update_failure')))

    result = stream_info._get_stream_token(**get_stream_token_args)
    assert not result
    assert result.errors['message'] == 'update_failure'


def test_get_stream_token_failure_create_failure(
        get_stream_token_args, get_stream_token_mocks):
    """Test for failure of update_last_accessed_datetime."""
    (flexmock(trackdown_media_access)
     .should_receive('get_trackdown_media_access')
     .and_return(get_stream_token_mocks['get_trackdown_media_access_404']))

    (flexmock(trackdown_media_access)
     .should_receive('create_track_media_access')
     .and_return(response.create_fatal_response('create_failure')))

    result = stream_info._get_stream_token(**get_stream_token_args)
    assert not result
    assert result.errors['message'] == 'create_failure'


def test_get_stream_success(fixture_asset_stream_url, fixture_stream_token):
    """Test getting stream info."""
    expected_track_id = 10

    (flexmock(stream_info)
     .should_receive('_get_track_stream_url')
     .with_args(track_id=expected_track_id)
     .and_return(response.Response(fixture_asset_stream_url)))

    (flexmock(stream_info)
     .should_receive('_get_stream_token')
     .with_args(
        user_id=fixture_stream_token['user_id'],
        user_type=fixture_stream_token['user_type'])
     .and_return(response.Response(fixture_stream_token)))

    result = stream_info.get_stream(expected_track_id, 'oa:123')
    assert result
    assert result.message.get('stream') == {
        'track_unique_id': expected_track_id,
        'url': fixture_asset_stream_url['stream_url'],
        'duration': fixture_asset_stream_url['duration']}
    assert result.message.get('access') == fixture_stream_token


def test_get_stream_with_url_error():
    """Test getting stream with error during getting stream url."""
    expected_track_id = 10

    (flexmock(stream_info)
     .should_receive('_get_track_stream_url')
     .with_args(track_id=expected_track_id)
     .and_return(response.create_fatal_response('error')))

    result = stream_info.get_stream(expected_track_id, '')
    assert not result
    assert result.errors['message'] == 'error'


def test_get_stream_with_token_error(
        fixture_asset_stream_url, fixture_stream_token):
    """Test getting stream with error during getting stream token."""
    expected_track_id = 10

    (flexmock(stream_info)
     .should_receive('_get_track_stream_url')
     .with_args(track_id=expected_track_id)
     .and_return(response.Response(fixture_asset_stream_url)))

    (flexmock(stream_info)
     .should_receive('_get_stream_token')
     .with_args(user_id=0, user_type='')
     .and_return(response.create_fatal_response('error')))

    result = stream_info.get_stream(expected_track_id, '')
    assert not result
    assert result.errors['message'] == 'error'