#!/usr/bin/env python

import sys

from plot import decode
from os.path  import splitext, basename

from glob import glob
from collections import defaultdict
import optparse

from util import load_csv_file, write_csv_file

o = optparse.make_option

opts = [
#    o('-r', '--result-type', action='store', dest='',
#      type='choice', choices=['hard', 'soft', 'tardiness', 'rel-tardiness'],
#      help='what data should be emitted?'),
    ]

defaults = {
    }

options = None

#G-EDF/testpoint_ucap=13.75_wss=1792_dist=exp-10-10-100_deadlines=implicit_host=ludwig_scheduler=G-EDF.csv

IDX_WSS  = 4
IDX_UCAP = 5

IDX_HARD_IDLE =  6
IDX_HARD_LOAD =  7

IDX_SOFT_IDLE =  8
IDX_SOFT_LOAD = 17

IDX_TARD_MAX_IDLE =  9
IDX_TARD_AVG_IDLE = 10
IDX_TARD_STD_IDLE = 12

IDX_TARD_MAX_LOAD = 18
IDX_TARD_AVG_LOAD = 19
IDX_TARD_STD_LOAD = 21

IDX_RTARD_MAX_IDLE = 13
IDX_RTARD_AVG_IDLE = 14
IDX_RTARD_STD_IDLE = 16

IDX_RTARD_MAX_LOAD = 22
IDX_RTARD_AVG_LOAD = 23
IDX_RTARD_STD_LOAD = 25


def key(fname):
    name, ext = splitext(basename(fname))
    conf = decode(name)

    sched = conf['scheduler']

    if 'quanta' in conf and conf['quanta'] == 'staggered':
        sched = 'S-' + sched

    d  = 'dist=%s'  % conf['dist']
    dl = 'deadlines=%s' % conf['deadlines']
    h  = 'host=%s'  % conf['host']

    return ('_'.join([d, dl, h]), sched, fname)

def get_row(i, key_col,  arrays, cols):
    row  = []
    data = arrays[0]
    keys = [data[i,x] for x in key_col]
    for idx, data in enumerate(arrays):
        # make sure we are not combining apples and oranges...
        d_keys = [data[i,x] for x in key_col]
        if not d_keys == keys:
            print 'Bad: missing data sched=%d row=%d %s!=%s' % (idx + 1, i+1, d_keys, keys)
            assert False
        row += [data[i,x] for x in cols]
    return keys + row

def get_table(arrays, key_col, data_col):
    data = arrays[0]
    return [get_row(i, key_col, arrays, data_col) for i in xrange(len(data))]

def write_sched(name, components, hard=True):
    header = ['WSS', 'ucap']
    arrays = []
    for (sched, data) in components:
#        print sched
        header += ["%s (load)" % sched , "%s (idle)" % sched]
        arrays.append(data)
    if hard:
        data_col = [IDX_HARD_LOAD, IDX_HARD_IDLE]
    else:
        data_col = [IDX_SOFT_LOAD, IDX_SOFT_IDLE]
    result = get_table(arrays, [IDX_WSS, IDX_UCAP], data_col)
    # sort by WSS, then by ucap
    result.sort(key=lambda row: (row[0], row[1]))
    fname = '%s_%s.csv' % ('hard' if hard else 'soft',
                           name)
    write_csv_file(fname, result, header=header, width=20)

def write_tardiness(name, components, relative=True):
    header = ['WSS', 'ucap']
    arrays = []
    for (sched, data) in components:
        header += ["%s (max, load)" % sched,
                   "%s (avg, load)" % sched,
                   "%s (std, load)" % sched,
                   "%s (max, idle)" % sched,
                   "%s (avg, idle)" % sched,
                   "%s (std, idle)" % sched]
        arrays.append(data)

    if relative:
        data_col = [IDX_RTARD_MAX_LOAD, IDX_RTARD_AVG_LOAD, IDX_RTARD_STD_LOAD,
                    IDX_RTARD_MAX_IDLE, IDX_RTARD_AVG_IDLE, IDX_RTARD_STD_IDLE]
    else:
        data_col = [IDX_TARD_MAX_LOAD, IDX_TARD_AVG_LOAD, IDX_TARD_STD_LOAD,
                    IDX_TARD_MAX_IDLE, IDX_TARD_AVG_IDLE, IDX_TARD_STD_IDLE]

    result = get_table(arrays, [IDX_WSS, IDX_UCAP], data_col)
    # sort by WSS, then by ucap
    result.sort(key=lambda row: (row[0], row[1]))
    fname = '%s_%s.csv' % ('rel-tard' if relative else 'abs-tard',
                           name)
    write_csv_file(fname, result, header=header, width=35)


def assemble_results(dir):
    files = glob(dir + '/*.csv')

    parts = defaultdict(list)

    print 'Organizing %d files...' % len(files)
    for f in files:
        k, sched, fname = key(f)
        parts[k].append((sched, fname))

    for k in parts:
        # sort by scheduler name
        parts[k].sort()

    for i, k in enumerate(parts):
        comment = 1
        print '[%d/%d] Processing %s' % (i+ 1, len(parts), k)
        print 'Loading files.'
        components = [(sched, load_csv_file(fname)) for (sched, fname) in parts[k]]

        print 'Generating output.'
        write_sched(k, components, hard=True)
        write_sched(k, components, hard=False)
        write_tardiness(k, components, relative=True)
        write_tardiness(k, components, relative=False)

if __name__ == '__main__':
    parser = optparse.OptionParser(option_list=opts)
    parser.set_defaults(**defaults)
    (options, dirs) = parser.parse_args()

    for d in dirs:
        assemble_results(d)