"""Release Artist Localized Metadata Model."""
from oto import response
from sqlalchemy import Column
from sqlalchemy import ForeignKey
from sqlalchemy import Integer
from sqlalchemy import String
from sqlalchemy.orm import relationship

from product.connectors import mysql
from product.constants import error
from product.models import release_artist
from product.models.release_artist import ReleaseArtist


class ReleaseArtistLocalizedMetadata(mysql.BaseModel):
    """Release Artist Localized Metadata Model class."""

    __tablename__ = 'release_artist_localized_metadata'

    metadata_id = Column('id', Integer, primary_key=True)
    release_artist_id = Column(
        ForeignKey('release_artist.release_artist_id', ondelete='CASCADE'))
    language_id = Column(Integer)
    artist_name = Column(String(255))
    release_artist = relationship(ReleaseArtist)

    def to_dict(self):
        """Return a dictionary of a ReleaseArtist's Localized properties."""
        response_obj = {
            'language_id': self.language_id,
            'release_artist_id': self.release_artist_id,
            'artist_name': self.artist_name,
        }
        if self.release_artist:
            response_obj['role'] = self.release_artist.get_formatted_role()
        return response_obj


def get_artist_metadata_by_product(product_id):
    """Get release artist's localized metadata by product_id.

    Args:
        product_id (int): unique identifier for Product.
    Returns:
        response.Response: list of ReleaseArtistLocalizedMetadata obj or error.
    """
    with mysql.db_session() as session:
        metadata = session.query(ReleaseArtistLocalizedMetadata) \
            .join(ReleaseArtistLocalizedMetadata.release_artist, aliased=True)\
            .filter(ReleaseArtist.release_id == product_id)\
            .all()

        if not metadata:
            return response.Response(message={})

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


def _format_artist_results(artist_metadata):
    """Format GET response data for legacy call with artist translations.

    This groups all artist metadata based on roles.

    Args:
        artist_metadata (list): release artist metadata list.

    Returns:
        Response: dict {language : { role: {artist id :  trans name, ...}] }}
        e.g: {
          "1": {
            "remixer": {
              "3105892": "one translated artist"
            }
          },
          "40": {
            "featuring": {
              "3105890": "ttranslate for 3105890",
              "3105891": "aasas"
            },
            "remixer": {
              "3105892": "ada adr wdsd"
            }
          }
        }
    """
    result = {}
    for each_artist in artist_metadata:
        artist_data = {
            each_artist['release_artist_id']: each_artist['artist_name']}
        if each_artist['language_id'] not in result:
            result[each_artist['language_id']] = \
                {each_artist['role']: artist_data}

        elif each_artist['role'] in result[each_artist['language_id']]:
            result[each_artist['language_id']][each_artist['role']].update(
                artist_data)

        else:
            result[each_artist['language_id']][each_artist['role']] = \
                artist_data

    return result


def insert_metadata(language_id, data):
    """Add new artist localized metadata for the given release & language.

    Args:
        language_id (int): id of language.
        data (dict): dict containing artist localized data.
        e.g; [{artist_id : artist_name}]

    Returns:
        response.Response: response object containing status and payload.
    """
    if not data or not isinstance(data, dict):
        return response.create_error_response(
            error.ERROR_CODE_INVALID_DATA,
            'Invalid data sent for save release artist localization. data={}'.
            format(data))

    # validate that all artist ids sent are valid.
    validate_response = release_artist.validate_artist_ids(list(data.keys()))
    if not validate_response:
        return validate_response

    with mysql.db_session() as session:
        for artist_id, artist_name in data.items():
            existing_release_artist = session.query(
                ReleaseArtistLocalizedMetadata
            ).filter_by(
                release_artist_id=artist_id,
                language_id=language_id
            ).one_or_none()

            # update if existing release artist found else insert new.
            if not existing_release_artist:
                new_release_artist = ReleaseArtistLocalizedMetadata(
                    release_artist_id=artist_id,
                    language_id=language_id,
                    artist_name=artist_name)
                session.add(new_release_artist)
            else:
                existing_release_artist.artist_name = artist_name
                session.merge(existing_release_artist)

            session.commit()
        return response.Response(message=data)


def delete_all_metadata(release_artist_ids, language_id):
    """Delete all artist localized metadata for the given artists & language.

    Args:
        release_artist_ids (list): List of artist ids
        language_id (int): id of language.

    Returns:
        response.Response: response object.
    """
    if not release_artist_ids or len(release_artist_ids) < 1:
        return response.create_error_response(
            error.ERROR_CODE_INVALID_DATA,
            'No artist ids sent for delete release artist localization.')

    with mysql.db_session() as session:
        records_deleted = session.query(ReleaseArtistLocalizedMetadata) \
            .filter(ReleaseArtistLocalizedMetadata.language_id == language_id)\
            .filter(ReleaseArtistLocalizedMetadata.release_artist_id.in_(
                release_artist_ids))\
            .delete(synchronize_session='fetch')

        if records_deleted < 1:
            return response.create_not_found_response(
                'No localizations deleted for artists.')

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