"""Blacklist Reasons Model."""
import datetime

from owsresponse import response
from sentry_sdk import capture_exception
from sqlalchemy import Column
from sqlalchemy import DateTime
from sqlalchemy import ForeignKey
from sqlalchemy import Integer
from sqlalchemy import Text
from sqlalchemy import VARCHAR
from sqlalchemy.exc import SQLAlchemyError

from blacklist_manager.connectors import mysql
from blacklist_manager.constants import error
from blacklist_manager.models import orchadmin_users  # noqa: F401


class BlacklistReasons(mysql.BaseModel):
    """Blacklist Reasons model."""

    __tablename__ = 'blacklist_reasons'

    blacklist_reason_id = Column(
        'id', Integer, primary_key=True, autoincrement=True, nullable=False)
    reason = Column(VARCHAR(256), nullable=True)
    added_by = Column(
        Integer, ForeignKey('orchadmin_users.id'), nullable=False)
    alert = Column(Text, nullable=True)
    contact = Column(VARCHAR(256), nullable=True)
    date_added = Column(DateTime, nullable=False)
    date_updated = Column(DateTime, nullable=False)

    def to_dict(self):
        """Representation of a BlacklistReasons row."""
        return {
            'id': self.blacklist_reason_id,
            'reason': self.reason,
            'added_by': self.added_by,
            'alert': self.alert,
            'contact': self.contact,
            'date_added': self.date_added and self.date_added.strftime('%Y-%m-%d'),
            'date_updated': self.date_updated and self.date_updated.strftime('%Y-%m-%d')
        }


def get_blacklist_reasons():
    """Get all the records of blacklist reasons.

    Returns:
        Response: A response object with existing data.
    """
    with mysql.ar_db_session() as session:
        try:
            result = session.query(BlacklistReasons).all()
            reasons = {
                'items': [item.to_dict() for item in result]}
            return response.Response(message=reasons, status=200)
        except SQLAlchemyError:
            capture_exception()
            return response.create_fatal_response()


def get_blacklist_reasons_by_id(reason_ids, session):
    """Get the list of reasons with given IDs.

    Used when checking text for blacklisting.

    Args:
        reason_ids (list): Reason IDs to fetch data for.
    Returns:
        Response: A response object with existing data.
    """
    try:
        result = session.query(BlacklistReasons.blacklist_reason_id,
                               BlacklistReasons.reason,
                               BlacklistReasons.alert,
                               BlacklistReasons.contact
                               ).filter(BlacklistReasons.
                                        blacklist_reason_id.
                                        in_(reason_ids)).all()
        data = {items[0]: {
            'reason': items[1],
            'alert': items[2],
            'contact': items[3]
        } for items in result}

        return response.Response(message=data, status=200)
    except SQLAlchemyError:
        capture_exception()
        return response.create_fatal_response()


def create_blacklist_reason(blacklist_reason_data):
    """Persist a new blacklist reason to the database.

    Args:
        blacklist_reason_data (dict): properties to assign to the new
        blacklist reason.
    Returns:
        response.Response: object with dictionary of blacklist id created.
    """
    try:
        with mysql.ar_db_session() as session:
            blacklist_reason_data['date_added'] = datetime.datetime.now()
            blacklist_reason_data['date_updated'] = blacklist_reason_data['date_added']
            new_blacklist_reason = BlacklistReasons(**blacklist_reason_data)
            session.add(new_blacklist_reason)
            session.flush()
            return response.Response(
                message={'id': new_blacklist_reason.blacklist_reason_id},
                status=201)
    except SQLAlchemyError as e:
        capture_exception(e)
        return response.create_fatal_response(e.args)


def update_blacklist_reason(blacklist_reason_id, blacklist_reason_data):
    """Update a blacklist reason.

    Args:
        blacklist_reason_id (int): unique identifier of blacklist_reasons.
        blacklist_reason_data (dict): properties to update of the existing
        blacklist reason.
    Returns:
        Response: A response object with updated blacklist reason id.
    """
    try:
        with mysql.ar_db_session() as session:
            blacklist_reason_data['date_updated'] = datetime.datetime.now()
            result = session.query(BlacklistReasons).\
                filter(
                BlacklistReasons.blacklist_reason_id == blacklist_reason_id).\
                update(blacklist_reason_data)
            if not result:
                return response.create_not_found_response(
                    error.BLACKLIST_REASON_NOT_FOUND.format(
                        blacklist_reason_id))
            return response.Response(
                message={'id': blacklist_reason_id}, status=200)

    except SQLAlchemyError as e:
        capture_exception(e)
        return response.create_fatal_response(e.args)