"""Model for Report Presets."""

import json
from datetime import datetime

from oto.response import Response
from sqlalchemy import Boolean, Column, DateTime, Enum, Integer, String

from reporting.connectors import mysql
from reporting.utils.error_handling import wrap_db_errors


def _build_report_preset_dict(
    report_preset_id,
    name,
    report_id,
    params,
    datetime_created,
    is_orchard_preset=False,
):
    """Build a report preset dict."""
    return {
        'id': report_preset_id,
        'name': name,
        'report_id': report_id,
        'params': params,
        'datetime_created': datetime_created.strftime('%Y-%m-%dT%H:%M:%SZ'),
        'is_orchard_preset': is_orchard_preset,
    }


class ReportPreset(mysql.BaseModel):
    """Report preset model."""

    __tablename__ = 'report_preset'

    report_preset_id = Column(
        'id', Integer, primary_key=True, autoincrement=True, nullable=False
    )
    name = Column(String, nullable=False)
    report_id = Column(String, nullable=False)
    params = Column(String, nullable=False)
    account_type = Column(Enum('vendor', 'subaccount'), nullable=False)
    account_id = Column(Integer, nullable=False)
    user_id = Column(String, nullable=False)
    datetime_created = Column(
        DateTime, nullable=False, default=datetime.utcnow()
    )
    is_deleted = Column(Boolean, nullable=False, default=False)

    def to_dict(self):
        """Return dict representation of a ReportPreset row."""
        return _build_report_preset_dict(
            report_preset_id=self.report_preset_id,
            name=self.name,
            report_id=self.report_id,
            params=json.loads(self.params),
            datetime_created=self.datetime_created,
        )


@wrap_db_errors
def get_report_presets(account_type, account_id):
    """Return a list of report presets.

    Args:
        account_type (string): Orchard account type.
        account_id (int): Orchard account id.

    Returns:
        Response: Response containing the preset list.
    """
    with mysql.db_session() as session:
        results = (
            session.query(ReportPreset)
            .filter(ReportPreset.account_type == account_type)
            .filter(ReportPreset.account_id == account_id)
            .filter(ReportPreset.is_deleted == 0)
            .all()
        )
        return Response(
            message=[result.to_dict() for result in results], status=200
        )


def get_orchard_report_presets():
    """Get Orchard defined presets applicable to all vendors/subaccounts.

    Returns:
        Response: Response containing the preset list.
    """
    return Response(message=[])


@wrap_db_errors
def delete_report_preset(preset_id, account_type, account_id):
    """Delete a preset.

    Args:
        preset_id (int): Preset id
        account_type (string): Orchard account type.
        account_id (int): Orchard account id.

    Returns:
        Response: Response object.
    """
    with mysql.db_session() as session:
        result = (
            session.query(ReportPreset)
            .filter(ReportPreset.report_preset_id == preset_id)
            .filter(ReportPreset.account_type == account_type)
            .filter(ReportPreset.account_id == account_id)
            .one()
        )
        result.is_deleted = True

        return Response(message='success', status=200)


@wrap_db_errors
def create_report_preset(preset_dict, account_type, account_id, user_id):
    """Create a preset.

    Args:
        preset (dict): Preset dict
        account_type (string): Orchard account type.
        account_id (int): Orchard account id.
        user_id (int): Orchard user id.

    Returns:
        Response: Response object.
    """
    with mysql.db_session() as session:
        preset_dict.pop('account_type', None)
        preset_dict.pop('account_id', None)
        preset_dict.pop('user_id', None)
        params = json.dumps(preset_dict.pop('params'))
        preset = ReportPreset(
            account_type=account_type,
            account_id=account_id,
            user_id=user_id,
            params=params,
            **preset_dict,
        )
        session.add(preset)
        session.flush()
        return Response(message=preset.to_dict(), status=200)