import base64
import logging
import sys
import traceback

import gevent
import simplejson as json
import xlrd
from gg_restclient import RestClient
from helpers import retrieve_value
from webapp.models import SpreadsheetUploadResult

log = logging.getLogger('order.processor')
rest_client = RestClient()


def validate_field_lengths(order):
    err_msg = "Error due to field {field!s} length exceeded maximum value"
    validation_failures = []
    if len(order['xref']) > 18:
        validation_failures.append(err_msg.format(field='xref'))
    if len(order['ship_to']['name_line1']) > 35:
        validation_failures.append(err_msg.format(field='name_line1'))
    if len(order['ship_to']['name_line2']) > 35:
        validation_failures.append(err_msg.format(field='name_line2'))
    if len(order['ship_to']['addr_line1']) > 35:
        validation_failures.append(err_msg.format(field='addr_line1'))
    if len(order['ship_to']['addr_line2']) > 35:
        validation_failures.append(err_msg.format(field='addr_line2'))
    if len(order['ship_to']['city']) > 35:
        validation_failures.append(err_msg.format(field='city'))
    if len(order['ship_to']['state']) > 3:
        validation_failures.append(err_msg.format(field='state'))
    if len(order['ship_to']['zip']) > 10:
        validation_failures.append(err_msg.format(field='zip'))
    if len(order['ship_to']['country']) > 13:
        validation_failures.append(err_msg.format(field='country'))
    if len(order['ship_to']['phone']) > 25:
        validation_failures.append(err_msg.format(field='phone'))
    if len(order['ship_to']['email']) > 250:
        validation_failures.append(err_msg.format(field='email'))
    if len(order['ship_method']) > 15:
        validation_failures.append(err_msg.format(field='ship_method'))
    if len(order['options']['third_party_account']) > 16:
        validation_failures.append(err_msg.format(field='third_party_account'))
    if len(order['notes']) > 40:
        validation_failures.append(err_msg.format(field='notes'))
    if len(order['group_name']) > 10:
        validation_failures.append(err_msg.format(field='handle'))

    for item in order['items']:
        if not item['sku']:
            validation_failures.append(
                "Error due to order containing an empty SKU")
        else:
            if len(item['sku']) > 16:
                validation_failures.append(err_msg.format(field='sku'))
            if 'division' in item and len(item['division']) > 6:
                validation_failures.append(err_msg.format(field='division'))

    if validation_failures:
        return '; '.join(validation_failures)
    return None


def process_order_upload(to_exec):
    failed_rows = []
    misc_failures = []
    try:
        workbook = xlrd.open_workbook(
            file_contents=base64.b64decode(to_exec.file_data))

        orders = {}

        sh = workbook.sheet_by_index(0)

        log.info('number of rows in this spreadsheet is: %d', sh.nrows)

        for i in range(1, sh.nrows):
            try:
                gevent.sleep(0)
                log.debug('processing row %d', i)
                client_order_id = retrieve_value(sh, i, 0)
                ship_via = retrieve_value(sh, i, 1)
                name_line1 = retrieve_value(sh, i, 2)
                name_line2 = retrieve_value(sh, i, 3)
                addr_line1 = retrieve_value(sh, i, 4)
                addr_line2 = retrieve_value(sh, i, 5)
                city = retrieve_value(sh, i, 6)
                state = retrieve_value(sh, i, 7)
                zip = retrieve_value(sh, i, 8)
                email = retrieve_value(sh, i, 9)
                phone = retrieve_value(sh, i, 10)
                sku = retrieve_value(sh, i, 11).strip()
                qty = retrieve_value(sh, i, 12)
                country = retrieve_value(sh, i, 13)
                ship_short = retrieve_value(sh, i, 14)
                third_party_account = retrieve_value(sh, i, 15)
                notes = retrieve_value(sh, i, 16)
                division = retrieve_value(sh, i, 17).upper().strip()
                ship_options = retrieve_value(sh, i, 18).upper().replace(
                    ' ', '').split(',')
                handle = retrieve_value(sh, i, 19)

                if client_order_id not in orders:
                    log.info('%s not found, creating new order from row',
                             client_order_id)
                    orders[client_order_id] = {
                        'ship_via': ship_via,
                        'name_line1': name_line1,
                        'name_line2': name_line2,
                        'addr_line1': addr_line1,
                        'addr_line2': addr_line2,
                        'city': city,
                        'state': state,
                        'zip': zip,
                        'email': email,
                        'phone': phone,
                        'country': country,
                        'items': [],
                        'ship_short': ship_short,
                        'third_party_account': third_party_account,
                        'delivery_confirmation': 'D' in ship_options,
                        'insurance': 'I' in ship_options,
                        'saturday_delivery': 'S' in ship_options,
                        'signature_required': 'R' in ship_options,
                        'notes': notes,
                        'handle': handle
                    }

                def lookup_item(client_order_id, sku, division):
                    for item in orders[client_order_id]['items']:
                        if item['sku'] == sku:
                            if (not division) and ('division' not in item):
                                return item
                            elif item['division'] == division:
                                return item
                    return None

                item = lookup_item(client_order_id, sku, division)

                if not item:
                    item = {'sku': sku, 'qty': int(qty)}
                    if division:
                        item['division'] = division
                    orders[client_order_id]['items'].append(item)
                else:
                    item['qty'] += int(qty)

                log.debug('current order is: %s', str(orders[client_order_id]))
            except Exception as e:
                traceback.print_exc(e)
                failed_rows.append(i)
                log.warning('failure processing row %d',
                            i,
                            exc_info=sys.exc_info())

        #okay, orders is fully populated, now generate the proper order svc json for each
        json_orders = []

        def generate_item_dict(item):
            item_dict = {
                'sku': item['sku'].encode('utf-8'),
                'qty': item['qty']
            }
            if 'division' in item:
                item_dict['division'] = item['division'].encode('utf-8')
            return item_dict

        for k, v in orders.iteritems():
            gevent.sleep(0)
            try:
                jorder = {
                    'xref': k.encode('utf-8'),
                    'items': [generate_item_dict(item) for item in v['items']],
                    'ship_to': {
                        'name_line1': v['name_line1'].encode('utf-8'),
                        'name_line2': v['name_line2'].encode('utf-8'),
                        'addr_line1': v['addr_line1'].encode('utf-8'),
                        'addr_line2': v['addr_line2'].encode('utf-8'),
                        'city': v['city'].encode('utf-8'),
                        'state': v['state'].encode('utf-8'),
                        'zip': v['zip'].encode('utf-8'),
                        'country': v['country'].encode('utf-8'),
                        'phone': v['phone'].encode('utf-8'),
                        'email': v['email'].encode('utf-8')
                    },
                    'bill_to': {
                        'name_line1': v['name_line1'].encode('utf-8'),
                        'name_line2': v['name_line2'].encode('utf-8'),
                        'addr_line1': v['addr_line1'].encode('utf-8'),
                        'addr_line2': v['addr_line2'].encode('utf-8'),
                        'city': v['city'].encode('utf-8'),
                        'state': v['state'].encode('utf-8'),
                        'zip': v['zip'].encode('utf-8'),
                        'country': v['country'].encode('utf-8'),
                        'phone': v['phone'].encode('utf-8'),
                        'email': v['email'].encode('utf-8')
                    },
                    'ship_method': v['ship_via'].encode('utf-8'),
                    'client': to_exec.client_id.encode('utf-8'),
                    'origin': 'Spreadsheet Upload',
                    'notes': v['notes'].encode('utf-8'),
                    'options': {
                        'ship_complete': False
                        if v['ship_short'] == 'Y' else True,
                        'third_party_account': v['third_party_account'],
                        'delivery_confirmation': v['delivery_confirmation'],
                        'insurance': v['insurance'],
                        'saturday_delivery': v['saturday_delivery'],
                        'signature_required': v['signature_required']
                    },
                    'group_name': v['handle']
                }
                json_orders.append(jorder)
            except Exception as e:
                traceback.print_exc(e)
                try:
                    misc_failures.append(
                        'Failure constructing order for order with xref ' +
                        str(k))
                    log.warning('Failure constructing order with xref %s',
                                str(k),
                                exc_info=sys.exc_info())
                except:
                    pass

        for jorder in json_orders:
            gevent.sleep(0)
            try:
                validation_msg = validate_field_lengths(jorder)
                if validation_msg:
                    misc_failures.append('Order ' + jorder['xref'] + ': ' +
                                         validation_msg)
                    continue

                resp = rest_client.create_order(json.dumps(jorder))
                to_exec.results.append(
                    SpreadsheetUploadResult(numen_id=resp['id'],
                                            xref=jorder['xref'],
                                            success=True))

            except Exception as e:
                traceback.print_exc()
                to_exec.results.append(SpreadsheetUploadResult(xref=jorder[
                    'xref'], success=False,
                                                               msg=e.message))
                log.critical('Error response back from Order Creation',
                             exc_info=sys.exc_info())
    except Exception as e:
        traceback.print_exc()
        log.critical('General error in processing', exc_info=sys.exc_info())
    return (failed_rows, misc_failures)