"""
Job CRUD operations
"""

from sqlalchemy import update
from bulkperformancerights import config
from bulkperformancerights.models.job_status import JobStatus
from bulkperformancerights.connectors import mysql
from bulkperformancerights.logic import user
from bulkperformancerights.templates import email


HTML_EMAIL_CONTENT = '''
        Hey there,<br/><br/>

        Your Master Rights information has been updated successfully!
        Please check the <a href="{manage_rights_url}">
        Master Rights Management</a> page in the Workstation for any errors
        in the spreadsheet you last uploaded, and repeat the process as needed
        for new and corrected tracks. Don't forget to check out our
        <a href="{user_guide_url}">Product Guide</a>
        in the Help Center for a detailed step-by-step and
        pro tips.<br/><br/>

        Your Team at The Orchard
        '''
TEXT_EMAIL_BODY = '''
        Hey there,

        Your Master Rights information has been updated successfully!
        Please check the Master Rights Management {manage_rights_url}
        page in the Workstation for any errors in the spreadsheet you last
        uploaded, and repeat the process as needed for new and corrected
        tracks. Don't forget to check out our Product Guide {user_guide_url}
        in the Help Center for a detailed step-by-step and
        pro tips.

        Your Team at The Orchard
        '''
EMAIL_SUBJECT = 'Your rights data has been updated successfully'
user_guide_url = '{}/helpcenter/guides#masterrightsmgmt'.format(
    config.WORKSTATION_BASE_URL)
manage_rights_url = '{}/managerights'.format(config.WORKSTATION_BASE_URL)


def get_job_status(user_type, user_id, job_id):
    """Get job status

    Args:
        user_type (str): 'vendor' or 'subaccount', see logic/user.py
        user_id (int):   indentifier of user for which to get job status
        job_id (int):    optional, job id to get

    Return:
        (dict): either a single JobStatus or multiple
    """

    session = mysql.session()
    if job_id is None:
        job_statuses = session.query(JobStatus).filter_by(user_type=user_type,
                                                          user_id=user_id)
        status_response = [decorate_job(stat.dict()) for stat in job_statuses]
    else:
        # using first() because there should only ever be one
        job_status = session.query(JobStatus).filter_by(user_type=user_type,
                                                        user_id=user_id,
                                                        job_id=job_id).first()
        assert job_status is not None, 'no job found with that id'
        status_response = decorate_job(job_status.dict())
    session.close()
    return status_response


def make_job(input_file_path, user_type, user_id):
    """Make a job
    Initial state of a job is 'uploaded'


    Args:
        input_file_path (str): path to input file
        user_type (str): type of user
        user_id (int): id of user

    Return:
        (JobStatus): JobStatus model

    """

    job = JobStatus(
        input_file_path=input_file_path, job_status='uploaded',
        user_type=user_type, user_id=user_id)
    Session = mysql.session()
    Session.add(job)
    Session.commit()
    Session.close()
    return job


def update_job(job, **kwargs):
    """Update a job

    Args:
        job (JobStatus): Job to be updated
        **kwargs: Possible allowed values are any fields available on JobStatus

    Return:
        (ResultProxy): result of the update operation
    """

    Session = mysql.session()
    update_stmt = update(JobStatus).where(JobStatus.job_id == job.job_id).\
        values(**kwargs)
    result = Session.execute(update_stmt)
    Session.commit()
    Session.close()
    return result


def send_complete_mail(ses_conn, user_id, user_email, user_type='vendor'):
    """Email user that job is complete

    Args:
        ses_conn (boto.ses.Ses): SES connection
        user_id (int):
        user_email (str): email address to where an email is sent

    """

    user_info = user.user_info(user_id, user_type)

    vendor_logo_path = user_info.get('vendor_logo_path')
    vendor_contact_email = user_info.get('vendor_contact_email')

    return ses_conn.send_email(
        source=config.EMAIL_FROM_ADDRESS,
        subject=EMAIL_SUBJECT,
        body=TEXT_EMAIL_BODY.format(
            user_guide_url=user_guide_url,
            manage_rights_url=manage_rights_url),
        html_body=email.generate_body(
            vendor_logo_path,
            vendor_contact_email,
            'Bulk Performance Rights',
            HTML_EMAIL_CONTENT.format(
                user_guide_url=user_guide_url,
                manage_rights_url=manage_rights_url)),
        to_addresses=[user_email])


def decorate_job(job):
    """Decorates a job: constructs the location on s3
    This is meant for outward facing representations of jobs

    Args:
        job (JobStatus): job to be decorated

    Todo:
        OrCharles: fix 'None' being returned from job_status
    Return:
        (JobStatus): decorated job status object
    """
    user_dict = {'type': job.get('user_type'), 'id': job.get('user_id')}
    job['input_file_path'] = s3_path_for_user_from_file(
        job.get('input_file_path'), user_dict)
    if job.get('error_file_path') == 'None':
        job['error_file_path'] = None
    else:
        job['error_file_path'] = s3_path_for_user_from_file(
            job.get('error_file_path'), user_dict)
    return job


def s3_path_for_user_from_file(filename, user_dict):
    """Concatenate bucket, bucket prefix and file

    Args:
        filename (string): filename

    Return:
        string: s3 bucket/key prefixed with user information

    """

    user_prefix = user.prefix_for_user(user_dict)
    return '{}{}{}{}'.format(
        config.bucket_name, config.prefix, user_prefix, filename)