import time

# starting time
st = time.time()

# ------------------------------- import
import csv
import json
import sys
import logging
import operator
import urllib2
import os.path
import string
import re
import cgi


# ------------------------------- vars
PARMS = {
    "furl":["url","str"],
    "sidx":["iSortCol_0","int"],
    "start":["iDisplayStart","int"],
    "rows":["iDisplayLength","int"],
    "sord":["sSortDir_0","str"],
    "echo":["sEcho","int"],
    "rexp":["sSearch","str"],
    }

# The 27 columns csv file types
CTYPES = (int,str,float,float,float,float,int,int,int,int,int,int,int,int,int,int,int,int,float,int,float,str,str,int,float,int,str)


# ------------------------------- config
LOG_FILENAME = '/tmp/csv2json.log' # The log file
logging.basicConfig( filename=LOG_FILENAME, level=logging.DEBUG )


# ------------------------------- starts
logging.info( ":"*50+" %s" % time.strftime("%c") )
logging.info( "Job started" )


# ------------------------------- core
def cast(values, types=CTYPES):
    """
    Cast list data according to predefined types

    Note that values and types should have the same length!

    @param values: values to cast
    @param types : types for values
    @return: casted values
    """
    return [t(v) for t, v in zip(types, values)]

def format(values, types=CTYPES):
    """
    Float values are converted to strings with two decimals.

    ADVISORY: only use this function for final data to jsonify since
    data type is lost

    @param values: values to cast
    @param types : types for values
    @return: formated values
    """
    return ["%.2f"%v if t == float else v for t,v in zip(types, values)]

def search(values, rexp):
    """
    Float values are converted to strings with two decimals.

    ADVISORY: only use this function for final data to jsonify since
    data type is lost

    @param values: values to cast
    @param types : types for values
    @return: formated values
    """
    for v in values:
        if re.search(rexp,str(v)):
            logging.debug( "REGEXP (%s) Match for %s" % (rexp,str(v)) )
            return True
    return False

def csv2json( furl, sidx, start=1, rows=50, sord="asc", echo=0, rexp=None, pfn=None ):
    """

    csv2json

    * Parse www csv file
    * Sort data according to the input key
    * Extract a subset of data
    * Encode the subset in JSON
    * Print the data

    @param furl : csv file url (can be a local path)
    @param sidx : column used to sort data
    @param start: data chunck/page number (default: 1)
    @param rows : how many values do we display (default: 50)
    @param sord : sort order, set to desc for reversed (default: True)
    @param echo : simple internal iterator used by datatables for rendering
    @param pfn  : pickle file name -- only used if PICKLE = True (default: None)

    @return:None
    """

    logging.info( "Input file is: %s"%furl )

    # read csv data
    t = time.time()
    c = csv.reader( urllib2.urlopen(furl), delimiter=';' )
    logging.info( "Data loaded in %8.3f s" % (time.time() - t) )

    # First raw corresponds to parameters names
    k = c.next()
    logging.info( "Input csv keys are " + str(k)  )

    # filter data (search case)
    if rexp != "None": # rexp is casted to str
        t = time.time()
        c = filter(lambda x: search(x,rexp), list(c))
        logging.info( "Data filtred in %8.3f s" % (time.time() - t) )

    # cast data -- note that we need to sort the whole list for
    # sorting consistency
    t = time.time()
    c = map(lambda x: cast(x,types=CTYPES), list(c))
    logging.info( "Data casted in %8.3f s" % (time.time() - t) )

    # sort data according to the item rank
    t = time.time()
    r = True if sord == "desc" else False
    s = sorted( c, key=operator.itemgetter( sidx ), reverse=r )
    logging.info( "Data sorted in %8.3f s" % (time.time() - t) )

    # select data range
    t = time.time()
    max = len(s)
    ff = start if start else 0
    tt = ff+rows if ff+rows < max else max
    logging.info( "Data range is: %d-%d" % (ff,tt) )
    logging.info( "Data selected in %8.3f s" % (time.time() - t) )

    # format floats to avoid X decimal
    t = time.time()
    f = map(lambda x: format(x, types=CTYPES), s[ff:tt])
    logging.info( "Floats formated in %8.3f s" % (time.time() - t) )

    # format data
    j = {
        "sEcho":echo,
        "iTotalRecords":str(len(s)),
        "iTotalDisplayRecords":str(len(s)),
        "sColumns":string.join(k,","),
        "aaData":f
        }

    # json data
    t = time.time()

    # This first line header allows to execute XMLHttpRequest from
    # anywhere, it inactivates web browsers CORS (Cross-Origin
    # Resource Sharing) -- It has been commented for security
    # considerations
    # print "Access-Control-Allow-Origin: *"
    # print "Content-type: application/json\n"
    print json.dumps(j)
    logging.info( "Data encoded (json) in %8.3f s" % (time.time() - t) )
    logging.debug( "Data encoded (json) content %s" % str(json.dumps(j)) )

    # ------------------------------- ends
    logging.info( "Elapsed time %8.3f s" % (time.time() - st) )

    return


# -- Form --
def formErr( msg, debugMsg = "", debug = False ):
    """
    Print an error message (stdout/HTML) and exit

    @param msg: the error message
    """

    print "Content-type: text/html\n\n"
    print "<b>An error occured while processing your request: %s!</b>" % str(msg)

    if debug:
        print "<p>"
        print debugMsg
        print "</p>"

    sys.exit(1)

def checkForm( theForm, parms ):
    """
    Check each form parms and fill the dict ligand

    @param theForm: input form
    @param parms: input form parameters keys
    """

    for aParm in parms:
        try:
            if theForm.has_key( PARMS[aParm][0] ) and theForm[ PARMS[aParm][0] ].value:
                val = str(theForm[ PARMS[aParm][0] ].value)
            else:
                val = None
            logging.debug("checkForm: aParm (%s) val (%s)" % (aParm,val) )
            # Set var according to dict keys and cast values
            exec "%s=%s('%s')" % ( aParm, PARMS[aParm][1], val)
        except:
            formErr( "wrong value for parameter %s" % aParm )

    return furl,sidx,start,rows,sord,echo,rexp

# -- Main --
if __name__=='__main__':

    # Parse the input request
    form = cgi.FieldStorage()

    # Check submitted parms
    furl, sidx, start, rows, sord, echo, rexp = checkForm( form, PARMS.keys() )

    # Process
    try:
        csv2json( furl, sidx, start=start, rows=rows, sord=sord, echo=echo, rexp=rexp )
    except:
        formErr( "contact an administrator" )