"""Model representing a mkt priority."""
from datetime import datetime

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

from product_digital.connectors import mysql
from product_digital.connectors.sentry import send_to_sentry
from product_digital.constants import error
from product_digital.models import release


class MktPriority(mysql.BaseModel):
    """Mkt Priority model."""

    __tablename__ = 'mkt_priority'

    mkt_id = Column('id', Integer, autoincrement=True, primary_key=True)
    upc = Column(Integer, nullable=False)
    priority = Column(Enum(*('a', 'b')), nullable=False)
    country_id = Column(Integer, nullable=False)
    release_id = Column(Integer, nullable=True)

    created_by = Column(Integer, nullable=True)
    updated_by = Column(Integer, nullable=True)
    created_on = Column(DateTime, nullable=True)
    updated_on = Column(DateTime, nullable=True)

    def to_dict(self):
        """Return dictionary of mkt priorities data.

        Returns:
            dict: mkt priority metadata.
        """
        return {
            'id': self.mkt_id,
            'upc': self.upc,
            'priority': self.priority,
            'country_id': self.country_id,
            'release_id': self.release_id
        }


def get_mkt_priority_by_release_id(release_id):
    """Get all of the mkt priorities for the given release.

    Args:
        release_id (int): release_id of the release.

    Returns:
        response.Response: response containing mkt priorities of release.
    """
    mkt_priority_dicts = []
    with mysql.db_session() as session:
        try:
            mkt_priorities = session.query(MktPriority).filter_by(
                release_id=release_id)
            for mkt_priority in mkt_priorities:
                mkt_priority_dicts.append(mkt_priority.to_dict())
            return response.Response(message=mkt_priority_dicts)
        except SQLAlchemyError as sql_error:
            send_to_sentry(sql_error, {}, 500, error.ERROR_MESSAGE_MYSQL_CONNECTION_FAILED)
            return response.create_error_response(
                code=error.INTERNAL_ERROR,
                message='could not connect to mysql',
                status=500)


def get_bulk_mkt_priority_by_release_ids(release_ids):
    """Get bulk mkt priorities for the given release ids.

    Args:
        release_id (list): release_id of the release.

    Returns:
        response.Response: response containing mkt priorities of release.
    """
    mkt_priority_dicts = []
    with mysql.db_session() as session:
        try:
            mkt_priorities = session.query(MktPriority).filter(
                MktPriority.release_id.in_(release_ids)).all()

            mkt_priority_dicts = [
                mkt_priority.to_dict() for mkt_priority in mkt_priorities
            ]
            return response.Response(message=mkt_priority_dicts)

        except SQLAlchemyError as sql_error:
            send_to_sentry(sql_error, {}, 500, error.ERROR_MESSAGE_MYSQL_CONNECTION_FAILED)
            return response.create_error_response(
                code=error.INTERNAL_ERROR,
                message='could not connect to mysql',
                status=500)


def set_mkt_priority_by_release_id(release_id, country_id, priority, user_id):
    """Set market priority."""
    usr_id = user_id if user_id else None
    with mysql.db_session() as session:
        mkt_priority = session.query(MktPriority).filter_by(
            release_id=release_id,
            country_id=country_id,
        ).first()

        if (mkt_priority):
            return update_mkt_priority(session, mkt_priority, priority, usr_id)
        else:
            return create_mkt_priority(session, release_id, country_id, priority, usr_id)


def update_mkt_priority(session, priority_obj, priority, user_id):
    """Update market priority."""
    priority_obj.priority = priority
    priority_obj.updated_on = datetime.utcnow()
    priority_obj.updated_by = user_id
    session.add(priority_obj)
    return response.Response(message=priority_obj.to_dict())


def create_mkt_priority(session, release_id, country_id, priority, user_id):
    """Create market priority."""
    release_obj = release.get_release_instance(release_id, session)
    if not release_obj:
        return response.create_error_response(
            code=error.ERROR_CODE_NOT_FOUND,
            message='no release id',
            status=500
        )

    upc = release_obj.upc
    now = datetime.utcnow()
    priority_obj = MktPriority(
        upc=upc,
        priority=priority,
        country_id=country_id,
        release_id=release_id,
        created_by=user_id,
        updated_by=user_id,
        created_on=now,
        updated_on=now,
    )
    session.add(priority_obj)
    return response.Response(message=priority_obj.to_dict())


def delete_mkt_priority_by_release_id(release_id, country_id):
    """Delete market priority."""
    with mysql.db_session() as session:
        mkt_priority = session.query(MktPriority).filter(
            MktPriority.release_id == release_id,
            MktPriority.country_id == country_id,
        ).first()
        if not mkt_priority:
            return response.create_not_found_response()

        session.delete(mkt_priority)
        return response.Response()


def delete_mkt_priority_for_product(product_id):
    """Delete market priority of a product."""
    with mysql.db_session() as session:
        return bulk_delete_mkt_priority_by_release_id(product_id, session)


def bulk_delete_mkt_priority_by_release_id(product_id, session):
    """Bulk delete market priority."""
    session.query(MktPriority) \
        .filter(MktPriority.release_id == product_id) \
        .delete()
    return response.Response()