"""Persistence logic for languages."""

from oto import response
import sqlalchemy

from product_digital.connectors import mysql
from product_digital.models import release
from product_digital.models import track


class Language(mysql.BaseModel):
    """Language quasi-model class for DB access."""

    __tablename__ = 'language'

    language_code = sqlalchemy.Column(
        sqlalchemy.String, primary_key=True, nullable=False)
    language = sqlalchemy.Column(sqlalchemy.String)
    iso_639_1_code = sqlalchemy.Column(sqlalchemy.String(2))
    # note: there is a typo in the db column name
    iso_639_3_code = sqlalchemy.Column(
        'iso_code_639_3_code', sqlalchemy.String(3))
    apple_compatible = sqlalchemy.Column(sqlalchemy.Boolean, default=True)

    def to_dict(self):
        """Format the properties of this language object as a dict."""
        iso_639_1_code = self.iso_639_1_code if self.iso_639_1_code else ''
        iso_639_3_code = self.iso_639_3_code if self.iso_639_3_code else ''

        return {
            'code': self.language_code,
            'name': self.language,
            'apple_compatible': self.apple_compatible,
            'iso_639_1_code': iso_639_1_code,
            'iso_639_3_code': iso_639_3_code,
            'iso_code': iso_639_1_code,  # deprecated: use iso_639_1_code
        }


def instrumental_language():
    """Instrumental language."""
    return Language(language_code='N/A', language='Instrumental', apple_compatible=False)


def get_languages(product_id=None, include_instrumental=False):
    """Fetch a list of language dictionaries.

    Returns:
        response.Response: list of language dictionaries
    """
    with mysql.db_session() as session:
        languages = session.query(Language).filter_by(apple_compatible=True).all()
        if include_instrumental:
            languages.append(instrumental_language())
        if product_id:
            product_lang_code = session.query(release.Release).get(product_id).meta_language
            track_lang_codes = session.query(track.Track.meta_language).filter_by(release_id=product_id).all()
            lang_codes = [track_lang_code for (track_lang_code,) in track_lang_codes]
            lang_codes.append(product_lang_code)
            product_and_track_langs = session.query(Language).filter(Language.language_code.in_(lang_codes))
            product_and_track_langs = set(product_and_track_langs)
            languages = [language.to_dict() for language in product_and_track_langs.union(languages)]
        else:
            languages = [language.to_dict() for language in languages]
        payload = {'items': sorted(languages, key=lambda x: x['name'].lower())}

        return response.Response(message=payload)