"""Promo Player Track Model.

This model represents a Promo Player Track
"""

import datetime

from oto import response
from oto import status
import sqlalchemy

from promo_player.connectors import mysql
from promo_player.constants import error
from promo_player.constants import promo_player_track as \
    promo_player_track_constants


class PromoPlayerTrack(mysql.BaseModel):
    """Promo Player Track model."""

    __tablename__ = 'promo_player_track'

    promo_player_id = sqlalchemy.Column(sqlalchemy.BIGINT, primary_key=True)
    track_id = sqlalchemy.Column(sqlalchemy.BIGINT, primary_key=True)
    sequence_number = sqlalchemy.Column(sqlalchemy.INT)
    created_time = sqlalchemy.Column(sqlalchemy.DateTime)
    updated_time = sqlalchemy.Column(sqlalchemy.DateTime)
    created_by = sqlalchemy.Column(sqlalchemy.VARCHAR(255))
    updated_by = sqlalchemy.Column(sqlalchemy.VARCHAR(255))

    def to_dict(self):
        """Convert Promo Player Track to dict."""
        return {
            'promo_player_id': self.promo_player_id,
            'track_id': self.track_id,
            'sequence_number': self.sequence_number
        }


@mysql.autosession()
def create(data, session):
    """Create a new promo player track.

    Args:
        data (dict): the data from which to create the promo player track.
        session (Session): the mysql session.

    Returns:
        response.Response: containing the created promo player track dict.
    """
    if not all(key in data for key in
               promo_player_track_constants.CREATE_REQUIRED_FIELDS):
        return response.create_error_response(
            code=error.ERROR_CODE_BAD_REQUEST,
            message=error.ERROR_MESSAGE_MISSING_PARAMETERS,
            status=status.BAD_REQUEST)

    data['created_time'] = datetime.datetime.now()

    promo_player_track = PromoPlayerTrack(**data)

    session.add(promo_player_track)
    session.commit()

    return response.Response(promo_player_track.to_dict())


@mysql.autosession()
def update(data, session):
    """Update a promo player track.

    Args:
        data (dict): the data from which to update the promo player track.
        session (Session): the mysql session.

    Returns:
        response.Response: containing the updated promo player track dict.
    """
    if not all(key in data for key in
               promo_player_track_constants.UPDATE_REQUIRED_FIELDS):
        return response.create_error_response(
            code=error.ERROR_CODE_BAD_REQUEST,
            message=error.ERROR_MESSAGE_MISSING_PARAMETERS,
            status=status.BAD_REQUEST)

    promo_player_id = data['promo_player_id']
    track_id = data['track_id']

    promo_player_track = session.query(PromoPlayerTrack).filter_by(
        promo_player_id=promo_player_id, track_id=track_id).one_or_none()

    if not promo_player_track:
        return response.create_not_found_response()

    for key, value in data.items():
        if key in promo_player_track_constants.UPDATE_ALLOWED_FIELDS:
            setattr(promo_player_track, key, value)

    promo_player_track.updated_time = datetime.datetime.now()

    session.commit()

    return response.Response(promo_player_track.to_dict())


@mysql.autosession()
def delete(promo_player_id, track_id, session):
    """Delete a promo player track.

    Args:
        promo_player_id (int): the promo player ID.
        track_id (int): the track ID.
        session (Session): the mysql session.

    Returns:
        response.Response: containing a dict with the deleted item.
    """
    if not promo_player_id or not track_id:
        return response.create_error_response(
            code=error.ERROR_CODE_BAD_REQUEST,
            message=error.ERROR_MESSAGE_MISSING_PARAMETERS,
            status=status.BAD_REQUEST)

    query = session.query(PromoPlayerTrack).filter_by(
        promo_player_id=promo_player_id, track_id=track_id)
    item = query.one_or_none()

    if not item:
        return response.create_not_found_response()

    item = item.to_dict()
    query.delete(synchronize_session=False)
    session.commit()

    return response.Response(item)


@mysql.autosession()
def get_by_promo_player_id(promo_player_id, session):
    """Get all the promo player tracks for the specified promo player.

    Args:
        promo_player_id (int): the promo player ID.
        session (Session): the mysql session.

    Returns:
        response.Response: containing a dict with promo player tracks.
    """
    if not promo_player_id:
        return response.create_error_response(
            code=error.ERROR_CODE_BAD_REQUEST,
            message=error.ERROR_MESSAGE_MISSING_PARAMETERS,
            status=status.BAD_REQUEST)

    promo_player_tracks = session.query(PromoPlayerTrack).filter_by(
        promo_player_id=promo_player_id).all()

    return response.Response({
        'items': [item.to_dict() for item in promo_player_tracks]
    })