"""Model for history table in salessheets database."""
from datetime import datetime

from oto import response
from sqlalchemy import and_
from sqlalchemy import Column
from sqlalchemy import DateTime
from sqlalchemy import Enum
from sqlalchemy import Integer
from sqlalchemy import String

from salessheets.connectors import mysql
from salessheets.constants import error
from salessheets.constants import field_const
from salessheets.constants import salessheets


class Job(mysql.BaseModel):
    """Class representing the salessheets history's job."""

    __tablename__ = 'sales_sheets_history'
    job_id = Column('id', Integer, primary_key=True, autoincrement=True)
    user_id = Column(String(127))
    context = Column(String(1000))
    context_type = Column(Enum(*salessheets.ALLOWED_CONTEXT_TYPES))
    output_format = Column(Enum(*salessheets.ALLOWED_GENERATION_METHODS))
    status = Column(
        Enum(*salessheets.GENERATION_STATUSES),
        default=salessheets.REQUESTED)
    timestamp = Column(DateTime, default=datetime.utcnow)

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

        Returns:
            dict: Dictionary representation of object
        """
        job_dict = {
            'id': self.job_id,
            'user_id': self.user_id,
            'context': self.context,
            'context_type': self.context_type,
            'output_format': self.output_format,
            'status': self.status,
            'timestamp': self.timestamp.isoformat(),
        }
        return job_dict


@mysql.wrap_db_errors
def create_job(
        *, user_id, context, output_format, context_type,
        status=salessheets.REQUESTED, timestamp=None):
    """Put new job item into task_status table.

    Args:
        user_id (str): user id
        context (list): list of integers or strings (up to 30 values)
        context_type (str): possible values- 'upc', 'display_upc'
         or 'release_id'.
        output_format (str): format in which pdf will be rendered
        status (str): job status, optional parameter
        timestamp (datetime): time, optional parameter
    Returns:
        response.Response: Id of created job or error in Response object
    """
    formatted_context = ','.join([str(c) for c in context])
    if not timestamp:
        timestamp = datetime.utcnow()
    job = Job(
        user_id=user_id, context=formatted_context, status=status,
        context_type=context_type, output_format=output_format,
        timestamp=timestamp)
    with mysql.ss_db_session() as session:
        session.add(job)
    return response.Response(job.job_id)


@mysql.wrap_db_errors
def get_job_by_id(job_id):
    """Get job data from db by job_id.

    Args:
        job_id (int): id of job in db.

    Returns:
        response.Response: Data of job or error in Response object.
    """
    with mysql.ss_db_session() as session:
        job = session.query(Job).filter_by(job_id=job_id).first()
        if not job:
            return response.create_not_found_response(
                error.JOB_DOES_NOT_EXIST)
        return response.Response(job)


@mysql.wrap_db_errors
def get_all_jobs_by_user_id(
        user_id, sort_by=None,
        sort_order=field_const.DESC,
        page_limit=field_const.DEFAULT_PAGE_LIMIT,
        page_offset=field_const.DEFAULT_PAGE_OFFSET):
    """Get all jobs for provided user_id.

    Args:
        user_id (str): id of user in db.
        sort_by (str): Name of field for sorting by.
        sort_order (str): Order of sorting: asc or desc.
        page_limit (int): Count of records to fetch.
        page_offset (int): count of records to skip.

    Returns:
        response.Response: List of jobs or error in Response object.
    """
    if sort_by == field_const.OUTPUT_FORMAT:
        sort_by = Job.output_format
    else:
        sort_by = Job.timestamp
    if sort_order == field_const.ASC:
        sort_by = sort_by.asc()
    else:
        sort_by = sort_by.desc()

    with mysql.ss_db_session() as session:
        jobs = session.query(
            Job).filter_by(
            user_id=user_id).order_by(sort_by).offset(
            page_offset).limit(page_limit).all()
        if not jobs:
            return response.create_not_found_response(
                error.JOB_DOES_NOT_EXIST)
        return response.Response(jobs)


@mysql.wrap_db_errors
def get_jobs_count(user_id):
    """Function that returns total count of jobs for user.

    Args:
        user_id (str): id of user in db.

    Returns:
        response.Response: response with count of jobs for user.
    """
    with mysql.ss_db_session() as session:
        jobs_count = session.query(Job).filter_by(user_id=user_id).count()
    return response.Response(jobs_count)


@mysql.wrap_db_errors
def get_job_by_upc(upc):
    """Get job data from db by upc.

    Args:
        upc (int): upc of job in db.

    Returns:
        response.Response: Data of job or error in Response object.
    """
    with mysql.ss_db_session() as session:
        formatted_upc = '{upc}'.format(upc=upc)
        filters = and_(
            Job.context == formatted_upc,
            Job.status == salessheets.COMPLETED)
        job = session.query(Job).filter(
            filters).order_by(Job.timestamp.desc()).first()
        if not job:
            return response.create_not_found_response(
                error.JOB_DOES_NOT_EXIST)
        return response.Response(job)


@mysql.wrap_db_errors
def get_job_by_release_id(release_id):
    """Get job data from history by release_id.

    Args:
        release_id (int): release_id (context) of job;
         equal to art_relations.releases.release_id.

    Returns:
        response.Response: Data of job or error in Response object.
    """
    with mysql.ss_db_session() as session:
        formatted_release_id = '{release_id}'.format(
            release_id=release_id)
        filters = and_(
            Job.context == formatted_release_id)
        job = session.query(Job).filter(
            filters).order_by(Job.timestamp.desc()).first()
        if not job:
            return response.create_not_found_response(
                error.JOB_DOES_NOT_EXIST)
        return response.Response(job)