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

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


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

    __tablename__ = 'release_localized_metadata'

    metadata_id = Column('id', Integer, primary_key=True)
    release_id = Column(Integer)
    language_id = Column(Integer)
    release_name = Column(String(255))
    delivered_version = Column(String(255))

    def to_dict(self):
        """Return a dictionary of a ReleaseLocalizedMetadata's properties."""
        return {
            'language_id': self.language_id,
            'product_name': self.release_name,
            'delivered_version': self.delivered_version,
        }


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

    Args:
        product_id (int): unique identifier for Product.
    Returns:
        response.Response: a list of ReleaseLocalizedMetadata obj or error.
    """
    with mysql.db_session() as session:
        metadata = session.query(ReleaseLocalizedMetadata).filter(
            ReleaseLocalizedMetadata.release_id == product_id).all()

        if not metadata:
            return response.create_not_found_response('No localized metadata.')

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


def insert_metadata(product_id, language_id, data):
    """Overwrite localized metadata for the given release & language.

    Args:
        product_id (int): id of the product.
        language_id (int): id of language.
        data (dict): dict containing release localized data.
        (only product_name is saved in this legacy table)

    Returns:
        response.Response: response object containing status and payload.
    """
    if data is None or 'product_name' not in data:
        return response.create_error_response(
            error.ERROR_CODE_INVALID_DATA,
            'Invalid data sent for save release localization')

    with mysql.db_session() as session:
        session.query(ReleaseLocalizedMetadata)\
            .filter_by(release_id=product_id, language_id=language_id)\
            .delete(synchronize_session=False)

        new_localized_metadata = ReleaseLocalizedMetadata(
            release_id=product_id,
            language_id=language_id,
            release_name=data.get('product_name'),
            delivered_version=data.get('delivered_version')
        )
        session.add(new_localized_metadata)

        return response.Response(message=new_localized_metadata.to_dict())


def delete_metadata(product_id, language_id):
    """Delete localized metadata for the given product & language.

    Args:
        product_id (int): id of product
        language_id (int): id of language.

    Returns:
        response.Response: response object.
    """
    with mysql.db_session() as session:
        records_deleted = session.query(ReleaseLocalizedMetadata) \
            .filter(
                ReleaseLocalizedMetadata.language_id == language_id,
                ReleaseLocalizedMetadata.release_id == product_id)\
            .delete(synchronize_session='fetch')

        if records_deleted < 1:
            return response.create_not_found_response(
                'No release localization data deleted.')

        return response.Response(message='{} Release localization deleted.'
                                 .format(records_deleted))