"""Script to Bulk upload Pricing data for Physical Releases."""
import json
import os
import requests
import sys
from boto3.session import Session
import dotenv
import logging
import physical_pricing_bulk_utils as ppbu
from raven.handlers.logging import SentryHandler
from raven.conf import setup_logging

handler = SentryHandler(os.environ.get('SENTRY_DSN'))
setup_logging(handler)
logger = logging.getLogger(__name__)
logger.setLevel(logging.ERROR)

# TODO: Use SES for email

dotenv.load_dotenv('../.env')

ENVIRONMENT = os.environ.get('Environment', 'dev')
if ENVIRONMENT == 'prod':
    OWS_PRICING_URL = 'https://ows-pricing.theorchard.io'
else:
    OWS_PRICING_URL = 'https://qa-ows-pricing.theorchard.io'

S3_BUCKET = os.environ.get('S3_BUCKET', 'dev-cucumbers')
INGEST_FOLDER = os.environ.get('INGEST_FOLDER', 'bulk-physical-pricing-ingest')
ARCHIVE_FOLDER = os.environ.get(
    'ARCHIVE_FOLDER', 'bulk-physical-pricing-ingest-archive')


def getS3connection():
    access_key = os.environ.get('AWS_ACCESS_KEY_ID')
    secret_key = os.environ.get('AWS_SECRET_ACCESS_KEY')

    sessionconn = Session(aws_access_key_id=access_key,
                      aws_secret_access_key=secret_key)
    session_res = sessionconn.resource("s3")

    return session_res


def get_pricing_data(batch_file):
    return json.loads(batch_file.get()['Body'].read().decode('utf-8'))


def rename_ingest_batch(bucket, session_res, old_name, new_name):
    bucket_name = bucket.name
    copy_source = {'Bucket': bucket_name, 'Key': old_name}
    session_res.meta.client.copy(copy_source, bucket_name, new_name)
    session_res.Object(bucket_name, old_name).delete()


def archive_batch(bucket, session_res, batch_filename):
    new_name = batch_filename.replace(INGEST_FOLDER, ARCHIVE_FOLDER)   
    print("Archiving ", batch_filename,' to ',new_name)
    rename_ingest_batch(bucket, session_res, batch_filename, new_name)   


def get_oldest_batch_to_ingest(bucket):
    allfiles = bucket.objects.filter(Prefix='{}/ready'.format(INGEST_FOLDER))
    allreadyfiles = [f for f in allfiles]
    if not allreadyfiles:
        return 0
    return min(allreadyfiles, key=lambda k: k.last_modified)


def ingest_pricing_row(pricing_row):

    product_id = pricing_row['release_id']
    orchard_pricing_tier_name = pricing_row['orchard_price_tier']['name']

    print('About to ingest pricing_row for product ID {0}'.format(product_id))
    print('Orchard Pricing Tier: {0}'.format(orchard_pricing_tier_name))

    print('Going to look for tier with name: ' + orchard_pricing_tier_name)
    pricing_tier = pricing_row['orchard_price_tier']['id']

    delete_url = '{0}/legacy/product/{1}/unmigrate'.format(OWS_PRICING_URL, product_id)
    print('Going to delete pricing information using URL: ' + delete_url)

    try:
        delete_response = requests.delete(delete_url)

    except Exception as e:
        logger.error('ows-pricing to delete pricing failed: {}'.format(str(e)))
        print("Error calling ows-pricing to delete pricing for product ID: {0}, error: {1}".format(product_id, str(e)))

    print('response from delete pricing: ')
    print(delete_response)

    set_tier_url = '{0}/product/{1}/pricing-family/4/orchard_pricing_tier'.format(OWS_PRICING_URL, product_id)
    print('Going to set orchard tier on URL: ' + set_tier_url)

    data = {'orchard_pricing_tier_id': pricing_tier}

    print('about to send data:')
    print(data)

    try:
        set_tier_response = requests.put(set_tier_url, json = data)
    except Exception as e:
        logger.error('ows-pricing to set orchard pricing tier failed: {}'.format(str(e)))
        print("Error calling ows-pricing to set orchard pricing tier error:", str(e))

    print('response from set tier: ')
    print(set_tier_response)

    sort_order = 1
    overrides_to_create = []

    for store_id, store_pricing in pricing_row['store_pricing'].items():
            print('going to set up an override for store_id {0} to have price_code: {1}'.format(store_id, store_pricing))
            override = {
                'sort_order': sort_order,
                'price_code': store_pricing,
                'product_id': product_id,
                'applies_worldwide': True,
                'activated': True,
                'stores': [store_id],
                'pricing_family_id': 4
            }
            sort_order = sort_order + 1
            overrides_to_create.append(override)

    if overrides_to_create:
        create_override_url = '{0}/product/{1}/override/bulk'.format(OWS_PRICING_URL, product_id)
        
        data = {
            'items': overrides_to_create
        }
        try:
            print("Making call to do bulk override as above URL:",create_override_url)
            create_override_response = requests.post(create_override_url, json = data)
        except Exception as e:
            logger.error('ows-pricing to post pricing overrides failed: {}'.format(str(e)))
            print("Error calling ows-pricing to create product pricing override, error:", str(e))
        print('response from create override: ')
        print(create_override_response)
        return create_override_response.status_code


if __name__ == '__main__':
    mail_body = """
Hi There!<br/>
<br/>
The physical pricing batch upload has completed for the release id's listed below.<br/>
<br/>
""" 
    try:
        session_res = getS3connection()
        bucket = session_res.Bucket(S3_BUCKET)

        ingest_batch = get_oldest_batch_to_ingest(bucket)
        if not ingest_batch:
            print('No batches to ingest')
            sys.exit()
        print('Getting oldest batch to ingest.')
        ingest_ready_filename = ingest_batch.key
        print(ingest_ready_filename)

        print('About to read pricing data from {0}'.format(ingest_ready_filename))
        ingest_batch_data = get_pricing_data(ingest_batch)
        number_of_releases = len(ingest_batch_data['override_data'])
        print('Fetched {0} rows of pricing data to migrate'.format(number_of_releases))

        filename_running = ingest_ready_filename.replace('ready','running')
        print("Renaming ",ingest_ready_filename," to ",filename_running)
        rename_ingest_batch(bucket, session_res, ingest_ready_filename, filename_running)

        successfull_overrides = []
        failed_overrides = []
        for ingest_batch_row in ingest_batch_data['override_data']:
            override_status = ingest_pricing_row(ingest_batch_row)
            if override_status == 200:
                successfull_overrides.append(ingest_batch_row['release_id'])
            else:
                failed_overrides.append(ingest_batch_row['release_id'])

        print('Done ingesting {0} pricing rows'.format(number_of_releases))

        filename_complete = filename_running.replace('running','complete')
        print("Renaming ",filename_running," to ",filename_complete)
        rename_ingest_batch(bucket, session_res, filename_running , filename_complete)

        archive_batch(bucket, session_res, filename_complete)
            
        subject = "Physical Pricing Batch Upload Completed"
        if successfull_overrides:
            mail_body += '<b>Successfully ingested :</b><br/><ul>'
            mail_body += ''.join(
                ['<li> Release ID ' + release + '</li>'
                    for release in successfull_overrides])
            mail_body += '</ul>'
            release_ids = successfull_overrides
        
        if failed_overrides:
            mail_body += '<br/><b>Failed :</b><br/><ul>'
            mail_body += ''.join(
                ['<li> Release ID ' + release + '</li>'
                    for release in failed_overrides])
            mail_body += '</ul>'
            release_ids = failed_overrides

        ppbu.send_email(
            subject,
            mail_body,
            [ingest_batch_data['oa_user']['email']],
            release_ids,
            logger
        )

        sys.exit()
    except Exception as e:
        logger.error('PPBU ingestion failed due to {}'.format(str(e)))
        sys.exit(e)