#! /usr/bin/env python -B
# -*- coding: utf-8 -*-

import sys, requests, json, argparse, unittest, hmac, base64, urllib, urlparse, hashlib


def cli_options():
    parser = argparse.ArgumentParser(description='Demo for REST API')
    parser.add_argument('-u','--url', default='http://localhost:8080/', help='Web service base URL')
    parser.add_argument('-i','--bkuid', default='', help='BlueKai UID')
    parser.add_argument('-k','--bksecretkey', default='', help='BlueKai Secret key')
    parser.add_argument('-v','--verbose', default=0, action='count', help='Prints additional information')
    return parser.parse_args()

args = cli_options()

URL = args.url.strip()
BKUID = args.bkuid
BKSECRETKEY = args.bksecretkey
VERBOSITY = args.verbose
USER_AGENT = {'User-Agent':'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.8; rv:22.0) Gecko/20100101 Firefox/22.0'}
JSON_HEADERS = {'Content-Type': 'application/json', 'Accept':'application/json'}
COMMON_HEADERS = dict(USER_AGENT.items() + JSON_HEADERS.items())

class ClassificationCategory():
    
    res = False

    def info(self, message, verbosityLevel = 1):
        if VERBOSITY >= verbosityLevel:
            if not isinstance(message, basestring):
                print json.dumps(message, indent=4)
            else:
                print message
    
    def prepare_headers(self, headers = None):
        if headers is None:
            return COMMON_HEADERS.copy()
        else:
            return dict(COMMON_HEADERS.items() + headers.items())

    def parse_query_params(self, query):
        parameterList = query.split('&')
        params = {}
        if len(parameterList) > 0:
            for entry in parameterList:
                kvPair = entry.split('=')
                params[kvPair[0]] = kvPair[1] if len(kvPair) > 1 else '';
        return params

    def prepare_request(self, endpoint, method = 'GET', params = None, data = None, headers = None, files = None, sign=True):
        if files is not None:
            headers.pop('Content-Type', None)

        req = requests.Request(method, URL + endpoint, data = data, headers = headers, files = files)
        prepared = req.prepare()

        if sign:
            if params is None:
                params = {}

            parsedUrl = urlparse.urlparse(URL)
            parsedEndpoint = urlparse.urlparse(endpoint)
            servletPath = "" if parsedEndpoint.path.strip().startswith("/") else "Services/WS/"
            urlPath = parsedUrl.path.strip('/')
            if urlPath:
                urlPath = urlPath + '/'
            fullPath = '/'+ urlPath + servletPath + parsedEndpoint.path.strip('/')
            stringToSign = method + fullPath

            params = dict(params.items() + self.parse_query_params(parsedUrl.query).items() + self.parse_query_params(parsedEndpoint.query).items())
            queryParameterStr = '';
            for key in params.keys():
                if len(key) > 0:
                    if isinstance(params[key], list):
                        for listItem in params[key]:
                            value = urllib.quote(str(listItem))
                            stringToSign += value
                            queryParameterStr += urllib.quote(key) + '=' + value + '&'
                    else:
                        value = urllib.quote(str(params[key]))
                        stringToSign += value
                        queryParameterStr += urllib.quote(key) + '=' + value + '&'

            if prepared.body is not None:
                stringToSign += prepared.body
            h = hmac.new(BKSECRETKEY, stringToSign.strip(), hashlib.sha256)
            s = base64.standard_b64encode(h.digest())
            signature = urllib.quote_plus(s)

            finalURL = parsedUrl.scheme + '://' + parsedUrl.netloc + fullPath + '?' + queryParameterStr + 'bkuid=' + BKUID + '&bksig=' + signature
        else:
            finalURL = URL + endpoint

        self.info('Sending %s request to: %s' %(method, finalURL))
        prepared.url = finalURL
        if VERBOSITY >=4:
            print "Request object:"
            for key, value in prepared.headers.iteritems():
                print "%s: %s" % (key, value)
            if prepared.body is not None and len(prepared.body)>0:
                print ""
                print prepared.body
        return prepared

    def post(self, endpoint, payload = None, params = None, headers = None, files = None):
        if payload is not None:
            data = payload if isinstance(payload, basestring) else json.dumps(payload)
        else:
            data = None
        self.res = requests.Session().send(self.prepare_request(endpoint, method = 'POST', params = params, data = data, files = files, headers = self.prepare_headers(headers)), verify = False)
        return self

    def test_bulk_self_class_create(self):
        files = {'categoryFile': open('self-classification-categories2.tsv', 'rb')}
        created_categories = self.post('classificationCategories', files = files, params={}).res.json()
        self.info(created_categories, 2)



instance=ClassificationCategory()
instance.test_bulk_self_class_create()