""" walk histogram
"""

import sys
import re
import datetime

mol = re.compile("\S+\s(\S+?)\|.{5}(.{6}).\|(.*)\|(.*)")

def main(argv = None):
    if argv == None:
        argv = sys.argv
    ifn = "e:/livefeed/20070829/GDAXI.csv"
    ofn = "e:/eclipse/workspace/filter/var/GDAXI_histogram.csv"
    tick_list = [ ]
    histogram = { }
    print "Converting [%s] to [%s]" % (ifn, ofn)
    try:
        ifh = open(ifn, "r")
        ofh = open(ofn, "w")
    except IOError:
        print "open [%s] failed" % ifn
        return 2
    try:
        for line in ifh:
            tick_list.append(parseCsv(line))
        for i in xrange(1, len(tick_list)):
            diff = tick_list[i].last - tick_list[i-1].last
            key = int( diff * 100 )
            if key not in histogram:
                histogram[key] = 1
            else:
                histogram[key] += 1
        # for key in sorted(histogram.keys()):
        for i in xrange(-1000, 1000):
            if i in histogram:
                print >> ofh, float(i)/100, ",", histogram[i]
            else:
                print >> ofh, float(i)/100, ",0"
    finally:
        ifh.close()
        ofh.close()
    print "Done."

time_pattern = re.compile("(..):(..):(..).(\d+)")

def parseCsv(line):
    flds = line.split(',')
    mot = re.match(time_pattern, flds[0])
    (hh, mm, ss, ms) = mot.group(1, 2, 3, 4)
    time = datetime.time(int(hh), int(mm), int(ss), int(ms)*1000)
    # pid = flds[1]
    bid = flds[2]
    ask = flds[3]
    last = flds[4]
    return Tick(time, float(bid), float(ask), float(last))

class Tick:
    """ VDO helper class """
    def __init__(self, ti, bid, ask, last):
        self.time = ti
        self.bid = bid
        self.ask = ask
        self.last= last
        
    def __cmp__(self, other):
        return cmp(self.time, other.time)

class Roi:
    """ VDO helper class """
    def __init__(self, buy_time, sell_time, pnl):
        self.buy_time = buy_time
        self.sell_time = sell_time
        self.pnl = pnl
        
    def pnl_per_minute(self):
        dt = time_in_minutes(self.sell_time) - time_in_minutes(self.buy_time)
        try:
            ppm = self.pnl / dt
        except ZeroDivisionError:
            return self.pnl
        return ppm

    def __cmp__(self, other):
        return cmp(self.pnl_per_minute(), other.pnl_per_minute())
    
    def __repr__(self):
        return "%s,%s,%.2f,%.2f" % (self.buy_time, self.sell_time, 
                                    self.pnl, self.pnl_per_minute())


def time_in_minutes(ti):
    return ti.hour * 60 + ti.minute + float(ti.second) / 60  
        

if __name__ == '__main__':
    sys.exit(main(sys.argv))