"""
Track Media Access model.

This track media access model uses sqlalchemy.
It's used to store track media access info in AR database.
"""
from datetime import datetime
from oto import response
from sqlalchemy import Column
from sqlalchemy import Integer
from sqlalchemy import Enum
from sqlalchemy import String
from sqlalchemy import DateTime
from sqlalchemy.exc import SQLAlchemyError

from assets.connectors import mysql
from assets.connectors import sentry
from assets.constants import field_const
from assets.constants import error


class TrackdownMediaAccess(mysql.ArModel):
    """Table definition for trackdown media access table."""

    __tablename__ = 'trackdown_media_access'

    trackdown_media_access_id = Column(
        'id', Integer, primary_key=True, autoincrement=True)
    user_id = Column('trackdown_user_id', Integer)
    user_type = Column(Enum(*field_const.USER_TYPES))
    token = Column(String(30))
    token_type = Column(Enum(*field_const.TOKEN_TYPES))
    last_accessed = Column(DateTime)

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

        Returns:
            dict: Dictionary representation of the object
        """
        trackdown_media_access_dict = {
            'id': self.trackdown_media_access_id,
            'trackdown_user_id': self.user_id,
            'user_type': self.user_type,
            'token': self.token,
            'token_type': self.token_type,
            'last_accessed': self.last_accessed
        }
        return trackdown_media_access_dict


def get_trackdown_media_access(
        user_id, user_type, token_type=field_const.TOKEN_TYPE_STREAM):
    """Get a single trackdown media access item.

    Args:
        user_id (int): Clean user id.
        user_type (str): Type of user. (e.g. "oa", "alw")
        token_type (str): Type of token. (e.g. "stream")

    Returns:
        response.Response: A dictionary representation of the item if found
                           or error.
    """
    try:
        with mysql.ar_db_session() as session:
            track_media_access = session.query(TrackdownMediaAccess).filter(
                TrackdownMediaAccess.user_id == user_id,
                TrackdownMediaAccess.user_type == user_type,
                TrackdownMediaAccess.token_type == token_type
            ).first()
            if track_media_access:
                return response.Response(track_media_access.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_by_id(trackdown_media_access_id, session):
    """Get a  trackdown media access item by trackdown_media_access_id.

    Args:
        trackdown_media_access_id (int): Id of trackdown media access entry.
        session (object): SQLAlchemy database session
    Returns:
        sqlalchemy.orm.query.Query:  Query object corresponding to session.
    """
    trackdown_media_access_query = session.query(TrackdownMediaAccess).filter(
        (TrackdownMediaAccess.trackdown_media_access_id ==
         trackdown_media_access_id)
    )
    return trackdown_media_access_query


def create_track_media_access(user_id, user_type, token, token_type):
    """Create new track media access record.

    Args:
        user_id (int): Clean user id.
        user_type (str): Type of user. (e.g. "oa", "alw")
        token (str): Unique character sequence.
        token_type (str): Type of token. (e.g. "stream")

    Returns:
        response.Response: Inserted record info or error
    """
    try:
        if user_type not in field_const.USER_TYPES:
            return response.create_error_response(
                code=error.ERROR_CODE_WRONG_VALUE,
                message=error.ERROR_WRONG_USER_TYPE)
        if token_type not in field_const.TOKEN_TYPES:
            return response.create_error_response(
                code=error.ERROR_CODE_WRONG_VALUE,
                message=error.ERROR_WRONG_TOKEN_TYPE)
        initial_last_accessed = datetime.utcnow()
        track_media_access = TrackdownMediaAccess(
            user_id=user_id, user_type=user_type, token=token,
            token_type=token_type, last_accessed=initial_last_accessed)
        with mysql.ar_db_session() as session:
            session.add(track_media_access)
            session.flush()
            import_asset_detail_data = track_media_access.as_dict()
        return response.Response(import_asset_detail_data)
    except SQLAlchemyError as e:
        if sentry.sentry_client:
            sentry.sentry_client.captureException()
        return response.create_fatal_response(e.args)


def update_last_accessed_datetime(trackdown_media_access_id, last_accessed):
    """Update last_accessed for TrackdownMediaAccess by track_media_access_id.

    Args:
        trackdown_media_access_id (int): track_media_access_id id.
        last_accessed (datetime): new last_accessed value.

    Returns:
        response.Response: TrackdownMediaAccess.as_dict() in message attribute
            or error response.
    """
    try:
        with mysql.ar_db_session() as session:
            updated_items = _get_by_id(
                trackdown_media_access_id, session).update(
                {'last_accessed': last_accessed}
            )
            if updated_items != 1:
                return response.create_fatal_response(
                    'No trackdown_media_access record was updated')
            session.commit()
            trackdown_media_access_dict = _get_by_id(
                trackdown_media_access_id, session).first().as_dict()
        return response.Response(trackdown_media_access_dict)
    except SQLAlchemyError as e:
        if sentry.sentry_client:
            sentry.sentry_client.captureException()
        return response.create_fatal_response(e.args)