"""
AssetUpload Model.

This AssetUpload model uses sqlalchemy. It's used to store about newly
uploaded assets.
"""

from oto import response
from sqlalchemy import Boolean
from sqlalchemy import Column
from sqlalchemy import func
from sqlalchemy import Integer
from sqlalchemy import LargeBinary
from sqlalchemy import String
from sqlalchemy import TIMESTAMP
from sqlalchemy import text
from sqlalchemy import UniqueConstraint


from connectors import mysql
from constants import api


ORDER_ASC = 'ASC'
ORDER_DESC = 'DESC'


class AssetUpload(mysql.AuModel):
    """Table definition for asset_upload table."""

    __tablename__ = 'asset_upload'

    asset_upload_id = Column(
        'id', Integer, primary_key=True, autoincrement=True)
    user_id = Column(String(127), nullable=False)
    asset_type = Column(String(16))
    token = Column(LargeBinary, nullable=False)
    filename = Column(String(64), nullable=False)
    api_version = Column(Integer, default=1)
    product_id = Column(Integer, default=0)
    upc = Column(String(50), default=None, nullable=True)
    track_unique_id = Column(Integer, default=0)
    original_filename = Column(String(255), nullable=True)
    deleted = Column(Boolean, default=False)
    is_correction = Column(Boolean, default=False)
    created_timestamp = Column(
        TIMESTAMP, nullable=False, server_default=text('CURRENT_TIMESTAMP'))
    updated_timestamp = Column(
        TIMESTAMP, nullable=False, server_default=text('CURRENT_TIMESTAMP'))
    __table_args__ = (
        UniqueConstraint('filename', 'api_version', name='filename_idx'),)

    def as_dict(self):
        """Return object as dict.

        Returns:
            dict: Dictionary representation of object
        """
        asset_upload_dict = {
            'id': self.asset_upload_id,
            'user_id': self.user_id,
            'asset_type': self.asset_type,
            'token': self.token.decode(),
            'filename': self.filename,
            'api_version': self.api_version,
            'product_id': self.product_id,
            'upc': self.upc,
            'track_unique_id': self.track_unique_id,
            'original_filename': self.original_filename,
            'deleted': self.deleted,
            'is_correction': self.is_correction
        }
        return asset_upload_dict


def create_asset_upload(
        user_id, filename, token, session, api_version=api.API_VERSION_V2):
    """Put new raw asset item into asset_upload table.

    Args:
        user_id (str): user id
        filename (str): unique filename
        token (str): sts token
        session (object): database session
        api_version (int): Workflow API version
    Returns:
        response.Response: AssetUpload.as_dict() in message attribute or error
            response.
    """
    asset_upload = AssetUpload(
        user_id=user_id, filename=filename, token=token.encode(),
        api_version=api_version)

    session.add(asset_upload)
    asset_upload_dict = asset_upload.as_dict()
    return asset_upload_dict


def get_asset_uploads_by_product_id(
        product_id, session, api_version=api.API_VERSION_V2):
    """Return asset_upload records by product_id.

    Args:
        product_id (int): Product id.
        session (object): database session.
        api_version (int): Workflow API version.
    Returns:
        response.Response: Asset list in message or error response.
    """

    sub_query = session.query(
        AssetUpload.product_id,
        AssetUpload.api_version,
        AssetUpload.track_unique_id,
        func.max(AssetUpload.updated_timestamp).label('latest_update'),
    ).group_by(
        AssetUpload.product_id, AssetUpload.track_unique_id,
        AssetUpload.api_version
    ).subquery('sub_query')

    return session.query(AssetUpload).filter(
        AssetUpload.product_id == product_id,
        AssetUpload.api_version == api_version,
        AssetUpload.deleted == 0,
        AssetUpload.track_unique_id == sub_query.c.track_unique_id,
        AssetUpload.updated_timestamp == sub_query.c.latest_update,
    ).all()


def get_broken_uploads(session, date):
    """Get asset uploads that haven't been picked up by the state machine."""
    return session.query(AssetUpload).filter(
        AssetUpload.api_version == api.API_VERSION_V2,
        AssetUpload.product_id == 0,
        AssetUpload.deleted == 0,
        AssetUpload.created_timestamp >= date
    ).all()


def _get_order_by(column, order):
    """Get SQLALchemy order_by value based on the given column and order."""
    if order == ORDER_DESC:
        return column.desc()
    if order == ORDER_ASC:
        return column.asc()

    return column


def get_unprocessed_assets(session, timestamp):
    return session.query(AssetUpload).filter(
        AssetUpload.api_version == 2,
        AssetUpload.deleted == 0,
        AssetUpload.product_id == 0,
        AssetUpload.created_timestamp >= timestamp
    ).all()