"""Track Localized Metadata Model."""
from oto import response
from sqlalchemy import Column
from sqlalchemy import desc
from sqlalchemy import Integer
from sqlalchemy import String

from product.connectors import mysql
from product.constants import error
from product.models import track_artist
from product.models import track_artist_localized_metadata


class TrackLocalizedMetadata(mysql.BaseModel):
    """TrackLocalizedMetadata Model class."""

    __tablename__ = 'track_localized_metadata'

    metadata_id = Column('id', Integer, primary_key=True, autoincrement=True)
    tuid = Column('track_id', Integer)
    language_id = Column(Integer)
    track_name = Column(String(255))
    version = Column(String(255))

    def to_dict(self):
        """Return a dictionary of a TrackLocalizedMetadata's properties."""
        return {
            'tuid': self.tuid,
            'language_id': self.language_id,
            'track_name': self.track_name,
            'version': self.version,
        }


def get_tracks_localizations(tuids, session):
    """Get track's localized metadata by tuids that are passed in.

    Args:
        tuids (list): List of unique identifier for track.
    Returns:
        response.Response: with a list of TrackLocalizedMetadata obj or error.
    """
    metadata = session.query(TrackLocalizedMetadata.tuid,
                             TrackLocalizedMetadata.language_id,
                             TrackLocalizedMetadata.track_name,
                             TrackLocalizedMetadata.version)\
        .filter(TrackLocalizedMetadata.tuid.in_(tuids))\
        .all()

    return _format_track_results(metadata)


def _format_track_results(track_metadata):
    """Format GET response data for track translations.

    This groups all metadata based on language_id and tuid.

    Args:
        track_metadata (list): track metadata list.

    Returns:
        Response: dict {language1 : {
                    tuid1 : {track_name : trans name, },
                    tuid2 : {track_name: trans name, version: trans version}}}

    """
    result = {}
    for each_track in track_metadata:

        language_id = each_track.language_id
        tuid = each_track.tuid
        if language_id not in result:
            result[language_id] = {}

        if tuid not in result[language_id]:
            result[language_id][tuid] = {}

        result[language_id][tuid].update({
            'track_name': each_track.track_name,
            'version': each_track.version, 'language_id': language_id,
            'tuid': tuid})

    return response.Response(message=result)


def get_track_localization_by_id(tuid):
    """Get track's localized metadata for a tuid.

    Args:
        tuid (int): unique identifier for track.
    Returns:
        response.Response: with a list of TrackLocalizedMetadata obj or error.
    """
    with mysql.db_session() as session:
        metadata = session.query(TrackLocalizedMetadata)\
            .filter(TrackLocalizedMetadata.tuid == tuid)\
            .all()

        response_data = [each.to_dict() for each in metadata]
        return response.Response(message=response_data)


@mysql.db_session_wrap
def update_metadata(tuid, language_id, data, session):
    """Overwrite localized metadata for the given tuid & language.

    Args:
        tuid (int): id of the track.
        language_id (int): id of language.
        data (dict): dict containing release localized data.
        session(Object): DB session instance. If you want this fn to be in
        transaction with already open session.

    Returns:
        response.Response: object containing new track's localized metadata.
    """
    if data is None or 'track_name' not in data or 'version' not in data:
        return response.create_error_response(
            error.ERROR_CODE_INVALID_DATA,
            'Invalid data sent for save track localization')

    track_metadata = session.query(TrackLocalizedMetadata)\
        .filter_by(tuid=tuid, language_id=language_id)\
        .order_by(desc(TrackLocalizedMetadata.metadata_id))\
        .first()

    if not track_metadata:
        track_metadata = TrackLocalizedMetadata(
            tuid=tuid, language_id=language_id)

    track_metadata.track_name = \
        data.get('track_name') if data.get('track_name') else ''
    track_metadata.version = data.get('version') if data.get('version') else ''
    session.merge(track_metadata)
    return_data = track_metadata.to_dict()

    # save track artist level localizations
    # if we don't send 'artists' key that means no change to artist.
    if 'artists' in data:
        validate_response = track_artist.validate_artists_belong_to_tuid(
            tuid, list(data['artists'].keys()))
        if not validate_response:
            session.rollback()
            return validate_response

        artist_response = \
            track_artist_localized_metadata.synchronize_artist_localizations(
                language_id=language_id, tuids=[tuid], data=data['artists'],
                session=session)
        if not artist_response:
            return artist_response

        return_data.update({'artists': artist_response.message})

    return response.Response(message=return_data)


def delete_track_metadata(tuids, language_id=None):
    """Delete localized metadata for the given tracks & language.

    Args:
        tuids (list): List of track ids
        language_id (int): id of language.

    Returns:
        response.Response: response object.
    """
    if not tuids:
        return response.create_error_response(
            error.ERROR_CODE_INVALID_DATA,
            'No track ids sent for delete track localization.')

    with mysql.db_session() as session:
        delete_query = session.query(TrackLocalizedMetadata) \
            .filter(TrackLocalizedMetadata.tuid.in_(tuids))\

        if language_id:
            delete_query = delete_query.filter(
                TrackLocalizedMetadata.language_id == language_id)
        records_deleted = delete_query.delete(synchronize_session=False)

        # delete all artist data by passing empty data to synchronize
        artist_delete_response = track_artist_localized_metadata\
            .synchronize_artist_localizations(
                language_id=language_id, tuids=tuids, data={}, session=session)
        if not artist_delete_response:
            session.rollback()
            return artist_delete_response

        return response.Response(
            message='{} track localizations deleted.'.format(records_deleted))