""" roi matrix 
"""

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_roi.csv"
    tick_list = [ ]
    roi_list = [ ]
    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, buy_tick) in enumerate(tick_list[0::300]):
            print buy_tick.time
            for sell_tick in tick_list[0::300]:
                if (buy_tick > sell_tick):
                    continue
                pnl = ( sell_tick.last - buy_tick.last ) * 25.0 - 11.80
                # print buy_tick.last, sell_tick.last, pnl  
                roi_list.append(Roi(buy_tick.time, sell_tick.time, pnl))
        for roi in roi_list:
            print >> ofh, str(roi)
    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))