"""Logic module that works with asset stream info."""

import datetime
import hashlib
import uuid

from oto import response

from assets import config
from assets.constants import asset_types
from assets.constants import field_const
from assets.logic.legacy import asset_filename
from assets.logic.legacy import asset_location
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
from assets.utils import user


def _get_track_stream_url(track_id, product=None):
    """Get track stream url.

    Args:
        track_id (int): Unique track id
        product (dict): Dictionary with information about the product

    Returns:
        response.Response: Response with stream url or error
    """
    track_response = ows_track.get_track_by_id(track_id)
    if not track_response:
        return track_response
    track = track_response.message

    if product is None:
        product_response = ows_product.get_product_by_id(track['product_id'])
        if not product_response:
            return product_response
        product = product_response.message

    asset_type_response = asset_type.get_asset_type_by_name(
        asset_types.DEFAULT_STREAM_AUDIO_TYPE)
    if not asset_type_response:
        return asset_type_response
    default_asset_type = asset_type_response.message

    track_filename_search_string = asset_filename.get_track_search_filename(
        product, track)
    stream_data_response = asset.get_streaming_info(
        track['upc'], default_asset_type['id'],
        config.SERVER_LOCATION_AVL, track_filename_search_string)
    if not stream_data_response:
        return stream_data_response
    stream_data = stream_data_response.message

    stream_url = asset_location.get_track_url(
        stream_data['storage_id'], stream_data['initial_folder'],
        stream_data['folder_structure'], {'upc': str(stream_data['upc'])},
        stream_data['filename'])

    result = {
        'stream_url': stream_url,
        'duration': stream_data['duration']
    }

    return response.Response(result)


def _generate_stream_token():
    """Genarate random stream token.

    Returns:
        str: New random token.
    """
    random_uuid = str(uuid.uuid4())
    md5 = hashlib.md5()
    md5.update(random_uuid.encode())
    stream_token = md5.hexdigest()[0:30]
    return stream_token


def _get_stream_token(user_id, user_type):
    """Return stream token.

    Args:
        user_id(int): User id.
        user_type(str): User type.
    Returns:
        response.Response: Response with stream token info or error
    """
    stream_token_response = trackdown_media_access.get_trackdown_media_access(
        user_id, user_type, token_type=field_const.TOKEN_TYPE_STREAM)

    if not stream_token_response and stream_token_response.status != 404:
        return stream_token_response

    if stream_token_response.status == 404:
        token = _generate_stream_token()
        create_token_response = (
            trackdown_media_access.create_track_media_access(
                user_id, user_type, token,
                token_type=field_const.TOKEN_TYPE_STREAM))
        if not create_token_response:
            return create_token_response
        stream_token_data = create_token_response.message
    else:
        trackdown_media_access_id = stream_token_response.message[
            'id']
        last_accessed = datetime.datetime.now()
        update_last_access_response = (
            trackdown_media_access.update_last_accessed_datetime(
                trackdown_media_access_id, last_accessed))
        if not update_last_access_response:
            return update_last_access_response
        stream_token_data = stream_token_response.message

    result = {
        'user_id': stream_token_data['trackdown_user_id'],
        'user_type': stream_token_data['user_type'],
        'token': stream_token_data['token'],
        'token_type': stream_token_data['token_type']
    }
    return response.Response(message=result)


def get_stream(track_id, user_info):
    """Return track stream info (stream url and access token).

    Args:
        product_id (int): Unique track id.
        user_info (str): String with orchard user info.

    Returns:
        response.Response: Response with stream info or error.
    """
    user_data = user.get_user_data(user_info)
    url_result = _get_track_stream_url(track_id)
    if not url_result:
        return url_result
    token_result = _get_stream_token(user_data['id'], user_data['type'])
    if not token_result:
        return token_result
    stream_data = {
        'track_unique_id': track_id,
        'url': url_result.message['stream_url'],
        'duration': url_result.message['duration']
    }
    result = {
        'stream': stream_data,
        'access': token_result.message
    }
    return response.Response(result)