"""Track localization logic."""

from oto import response

from backend.constants import error as error_consts
from backend.constants import product as product_consts
from backend.constants import track_field as tf
from backend.models import ows_product
from backend.models import ows_product_digital
from backend.models.track_persister import TrackPersister
from backend.utils import logic as logic_util
from backend.validation.track_localization_validators import \
    validate_track_localization


@logic_util.verify_product_ownership
def update(
        tuid, language_id, localization_data, account_type, account_id):
    """Update track localization via ows-product service.

    Args:
        tuid (str): track unique id
        language_id (str): language identifier
        localization_data (dict): payload from PUT request
        account_type (str): vendor or subaccount
        account_id (int): orchard account ID

    Returns:
        response.Response
    """
    track_response = TrackPersister.get_by_tuid(tuid)
    if not track_response:
        return track_response

    product_id = track_response.message.get(tf.PRODUCT_ID)
    digital_product_response = \
        ows_product_digital.get_product_by_product_id(product_id)
    if not digital_product_response:
        return digital_product_response

    digital_product = digital_product_response.message
    product_meta_language = \
        digital_product.get(product_consts.META_LANGUAGE)

    localization_data[tf.LANGUAGE_ID] = language_id
    validation_result = validate_track_localization(
        track_response.message, localization_data, product_meta_language)

    if validation_result:
        msg = 'Invalid localization'
        for key in ['language', tf.TRACK_NAME, tf.VERSION, tf.ARTISTS]:
            if key in validation_result:
                msg = validation_result[key]['message']
                break
        return response.create_error_response(
            code=error_consts.VALIDATION_ERROR_CODE, message=msg)

    return ows_product.update_track_localization(
        tuid, language_id, localization_data[tf.TRACK_NAME],
        localization_data[tf.VERSION], localization_data[tf.ARTISTS])


@logic_util.verify_product_ownership
def delete(tuid, language_id, account_type, account_id):
    """Delete track localization via ows-product service.

    Args:
        tuid (str): track unique id
        language_id (str): language identifier
        account_type (str): vendor or subaccount
        account_id (int): orchard account ID

    Returns:
        response.Response
    """
    return ows_product.delete_track_localization(tuid, language_id)