"""Table {env}-release_phonetic_translations model."""

from datetime import datetime

from oto import response
from sqlalchemy import Boolean
from sqlalchemy import Column
from sqlalchemy import DateTime
from sqlalchemy import false
from sqlalchemy import Integer
from sqlalchemy import String
from sqlalchemy.orm.attributes import InstrumentedAttribute

from product.connectors import mysql
from product.constants import error


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

    __tablename__ = 'release_phonetic_translations'

    release_phonetic_translations_id = Column(
        'id', Integer, primary_key=True, autoincrement=True, nullable=False)
    release_id = Column(Integer, nullable=False)
    language_id = Column(Integer, nullable=False)
    field_name = Column(String(128), nullable=False)
    phonetic_translation = Column(String(128), nullable=False)
    created_timestamp = Column(DateTime, default=datetime.now)
    updated_timestamp = Column(
        DateTime, default=datetime.now, onupdate=datetime.now)
    created_by = Column(Integer)
    updated_by = Column(Integer)
    is_deleted = Column(Boolean, default=False)

    def to_dict(self):
        """Return a dictionary of a PhoneticTranslations properties."""
        response_dict = {
            'release_phonetic_translations_id':
                self.release_phonetic_translations_id,
            'release_id': self.release_id,
            'language_id': self.language_id,
            'field_name': self.field_name,
            'phonetic_translation': self.phonetic_translation
        }

        return response_dict


def get(release_id, language_id=None):
    """Get phonetic translations.

    Args:
        release_id (int): id of product.

    Returns:
        response.Response: a list of PhoneticTranslations
    """
    if not release_id:
        return response.create_error_response(
            error.ERROR_CODE_INVALID_DATA,
            ('No release_id sent for get phonetic translations.'))

    with mysql.db_session() as session:
        phonetic_translations = (
            session.query(PhoneticTranslations)
            .filter(PhoneticTranslations.release_id == release_id)
            .filter(PhoneticTranslations.is_deleted == false()))

        if language_id:
            phonetic_translations = (
                session.query(PhoneticTranslations)
                .filter(PhoneticTranslations.release_id == release_id)
                .filter(PhoneticTranslations.is_deleted == false())
                .filter(PhoneticTranslations.language_id == language_id))

        phonetic_translations = phonetic_translations.all()

        phonetic_translations = [
            phonetic_translation.to_dict()
            for phonetic_translation in phonetic_translations]
        phonetic_translations_list = {'items': phonetic_translations}

        return response.Response(message=phonetic_translations_list)


def create_single_phonetic_translation(data):
    """Create a phonetic translation.

    Args:
        data (dict): values to insert

    Returns:
        phonetic_translation (dict): the created or existing row
    """
    invalid_data_response = create_missing_fields_response(data)
    if invalid_data_response is not None:
        return invalid_data_response.errors['message']

    with mysql.db_session() as session:
        existing_phonetic_translation = (
            session.query(PhoneticTranslations)
            .filter(PhoneticTranslations.release_id == data['release_id'])
            .filter(PhoneticTranslations.field_name == data['field_name'])
            .filter(PhoneticTranslations.language_id == data['language_id'])
            .filter(PhoneticTranslations.is_deleted == false())
            .first())

        if existing_phonetic_translation:
            return existing_phonetic_translation.to_dict()

        phonetic_translation = PhoneticTranslations(**data)
        session.add(phonetic_translation)
        session.flush()

        return phonetic_translation.to_dict()


def create(data):
    """Bulk create phonetic_translations.

    Args:
        data (list): items to insert

    Returns:
        response.Response: object containing the
            phonetic translations created.
    """
    phonetic_translations = [
        create_single_phonetic_translation(item) for
        item in data
    ]

    return response.Response(message={'items': phonetic_translations})


def update_single_phonetic_translation(data):
    """Overwrite phonetic translations data for the given id.

    Args:
        data (dict): item to update

    Returns:
        phonetic_translation (dict): the updated row
    """
    release_phonetic_translations_id = data.get(
        'release_phonetic_translations_id')

    if not release_phonetic_translations_id:
        return

    del data['release_phonetic_translations_id']

    invalid_data_response = create_missing_fields_response(data)
    if invalid_data_response is not None:
        return invalid_data_response

    with mysql.db_session() as session:
        session.query(PhoneticTranslations) \
            .filter(
                PhoneticTranslations.release_phonetic_translations_id
                == release_phonetic_translations_id) \
            .update(data)

        return data


def update(data):
    """Bulk update phonetic_translations.

    Args:
        data (list): items to update.

    Returns:
        response.Response: object containing the
            phonetic translations updated.
    """
    phonetic_translations_results = [
        update_single_phonetic_translation(item) for
        item in data
    ]

    phonetic_translations = [
        item for item in phonetic_translations_results
        if item is not None
    ]

    return response.Response(message={'items': phonetic_translations})


def delete_single_phonetic_translation(release_phonetic_translations_id):
    """Delete phonetic translations by release_phonetic_translations_id.

    Args:
        release_phonetic_translations_id (int):
            phonetic translations id.

    Returns:
        None: if no row was deleted or no id was provided.
        True: if a row was deleted.
    """
    if not release_phonetic_translations_id:
        return

    with mysql.db_session() as session:
        records_deleted = session.query(PhoneticTranslations)\
            .filter(
                PhoneticTranslations.release_phonetic_translations_id
                == release_phonetic_translations_id)\
            .update({PhoneticTranslations.is_deleted: True})

        if not records_deleted:
            return None

        return True


def delete(release_phonetic_translation_ids):
    """Delete phonetic translations for given ids.

    Args:
        release_phonetic_translation_ids (list):
            phonetic transltions ids.

    Returns:
        response.Response: The response object with
            number of rows deleted.
    """
    if (release_phonetic_translation_ids is None
            or not isinstance(release_phonetic_translation_ids, list)):
        return response.create_error_response(
            error.ERROR_CODE_INVALID_DATA,
            message=('Please provide a list of '
                     'release_phonetic_translation_ids.'))

    deletion_results = [
        delete_single_phonetic_translation(p_id) for
        p_id in release_phonetic_translation_ids
    ]

    records_deleted = len(list(filter(None, deletion_results)))

    return response.Response(
        message='{} phonetic translations deleted.'
        .format(records_deleted))


def delete_by_product_id(product_id):
    """Delete phonetic translations for product id.

    Args:
        product_id (int): the product id for which
            to delete phonetic translations

    Returns:
        response.Response: The response object with
            number of rows deleted.
    """
    with mysql.db_session() as session:
        records_deleted = session.query(PhoneticTranslations)\
            .filter(
                PhoneticTranslations.release_id == product_id)\
            .filter(
                PhoneticTranslations.is_deleted == false())\
            .update({PhoneticTranslations.is_deleted: True})

        return response.Response(
            message='{} phonetic translations deleted.'
            .format(records_deleted))


def create_missing_fields_response(data):
    """Check if data contain all required_fields.

    Args:
        data (dict): the data to be checked for validity

    Returns:
        None: if the data is valid
        response.Response:
            containing a message detailing the
            missing fields
    """
    if not data:
        return response.create_error_response(
            error.ERROR_CODE_INVALID_DATA,
            'No data provided')

    required_fields = []

    fields = [
        i for i in dir(PhoneticTranslations)
        if isinstance(
            getattr(PhoneticTranslations, i), InstrumentedAttribute)
    ]

    for field in fields:
        is_primary_key = getattr(
            PhoneticTranslations, field).primary_key
        has_default = getattr(PhoneticTranslations, field).default
        is_nullable = getattr(PhoneticTranslations, field).nullable

        if not is_nullable and not has_default and not is_primary_key:
            required_fields.append(field)

    missing_fields = [field for field in required_fields if field not in data]

    if len(missing_fields) == 0:
        return None

    return response.create_error_response(
        error.ERROR_CODE_INVALID_DATA,
        'The following fields are required: {}'.format(missing_fields))