"""
AssetType Model.

This AssetType model uses sqlalchemy and represents a table
in the direct_delivery database.
This table is used to track possible asset types.
"""

from oto import response
from sqlalchemy import Column
from sqlalchemy import Enum
from sqlalchemy import Integer
from sqlalchemy import String
from sqlalchemy.exc import SQLAlchemyError

from assets.connectors import mysql
from assets.connectors import sentry

from assets.constants import asset_types


class AssetType(mysql.DdModel):
    """Table definition for asset_type table."""

    __tablename__ = 'asset_type'

    asset_type_id = Column(
        'asset_type_id', Integer, primary_key=True, autoincrement=True)
    asset = Column(String(50), nullable=False)
    file_type = Column(Enum(*asset_types.PATH_STRUCTURE_TYPES),
                       nullable=False)
    extension = Column(String(80))
    initial_folder = Column(String(80))
    folder_structure = Column(String(255), nullable=False)
    parent_asset_type_id = Column(Integer)

    def as_dict(self):
        """Get dictionary representation.

        Returns:
            dict: Representation of asset received queue.
        """
        return {
            'id': self.asset_type_id,
            'asset': self.asset,
            'file_type': self.file_type,
            'extension': self.extension,
            'initial_folder': self.initial_folder,
            'folder_structure': self.folder_structure,
            'parent_asset_type_id': self.parent_asset_type_id
        }


def get_asset_type_by_name(asset_name):
    """Get a single asset type item by name.

    Args:
        asset_name (str): Asset name.

    Returns:
        response.Response: A dictionary representation of the item if found
                           or error.
    """
    try:
        with mysql.dd_db_session() as session:
            row = session.query(AssetType).filter(
                AssetType.asset == asset_name).one_or_none()
            if row:
                return response.Response(row.as_dict())
        return response.create_not_found_response()
    except SQLAlchemyError as e:
        if sentry.sentry_client:
            sentry.sentry_client.captureException()
        return response.create_fatal_response(e.args)


def get_asset_type_by_id(asset_type_id):
    """Get a single asset type item by asset type id.

    Args:
        asset_type_id (int): Asset type id.

    Returns:
        response.Response: A dictionary representation of the item if found
                           or error.
    """
    try:
        with mysql.dd_db_session() as session:
            row = session.query(AssetType).filter(
                AssetType.asset_type_id == asset_type_id).one_or_none()
            if row:
                return response.Response(row.as_dict())
        return response.create_not_found_response()
    except SQLAlchemyError as e:
        if sentry.sentry_client:
            sentry.sentry_client.captureException()
        return response.create_fatal_response(e.args)