#!/usr/bin/python

################################################################################
# Description
################################################################################
# Control script for unit-trace

################################################################################
# Setup
################################################################################

# Import the modules we need. You should not need to know about
# their internals.
import unit_trace
from unit_trace import trace_reader
from unit_trace import sanitizer
from unit_trace import gedf_test
from unit_trace import stats
from unit_trace import stdout_printer
from unit_trace import viz
from unit_trace import progress
from unit_trace import skipper
from unit_trace import maxer
from unit_trace import earliest
from unit_trace import latest

# Get trace files from command line arguments
from optparse import OptionParser
usage = "usage: %prog [options] <one or more trace files>"
parser = OptionParser(usage=usage)
parser.add_option("-s", "--skip", dest="skipnum", default=0, type=int,
    help="Skip over a fixed number of records")
parser.add_option("-m", "--max", dest="maxnum", default=0, type=int,
    help="Maximum number of records to parse")
parser.add_option("-p", "--progress", action="store_true", dest="progress",
    default=False, help="Show parsing progress")
parser.add_option("-g", "--gedf", action="store_true", dest="gedf",
    default=False, help="Run G-EDF test")
parser.add_option("-i", "--info", action="store_true", dest="info",
    default=False, help="Show statistical info")
parser.add_option("-o", "--stdout", action="store_true", dest="stdout",
    default=False, help="Use stdout_printer")
parser.add_option("-v", "--visual", action="store_true", dest="visualize",
    default=False, help="Use visualizer")
parser.add_option("-c", "--clean", action="store_true", dest="clean",
    default=False, help="Use sanitizer to clean garbage records")
parser.add_option("-e", "--earliest", default=0, type=int, dest="earliest",
    help="Earliest timestamp of interst")
parser.add_option("-l", "--latest", default=0, type=int, dest="latest",
    help="Latest timestamp of interst")
(options, traces) = parser.parse_args()
traces = list(traces)
if len(traces) < 1:
    parser.print_help()
    exit()

################################################################################
# Pipeline
################################################################################

# Read events from traces
stream = trace_reader.trace_reader(traces)

# Skip over records
if options.skipnum > 0:
    stream = skipper.skipper(stream, options.skipnum)

# Enforce max number of records to parse
if options.maxnum > 0:
    stream = maxer.maxer(stream, options.maxnum)

# Enfore earliest timestamp
if options.earliest > 0:
    stream = earliest.earliest(stream,options.earliest)

# Enfore latest timestamp
if options.latest > 0:
    stream = latest.latest(stream,options.latest)

# Filter out garbage events
if options.clean is True:
    stream = sanitizer.sanitizer(stream)

# Display progress information using stderr
# e.g. # records completed so far, total time, etc.
if options.progress is True:
    stream = progress.progress(stream)

# Produce G-EDF error records
if options.gedf is True:
    stream = gedf_test.gedf_test(stream)

# Produce a statistics record
if options.info is True:
    stream = stats.stats(stream)

# Filter some records out
#def my_filter(record):
#    if record.record_type == 'error' and record.type_name == 'inversion_end':
#        if record.job.inversion_end - record.job.inversion_start < 4000000:
#            return False
#    return True
#stream = filter(my_filter, stream)

# Output
if options.stdout is True and options.visualize is True:
    import itertools
    stream1, stream2 = itertools.tee(stream,2)
    stdout_printer.stdout_printer(stream1)
    viz.visualizer.visualizer(stream2) 
elif options.stdout is True:
    stdout_printer.stdout_printer(stream)
elif options.visualize is True:
    viz.visualizer.visualizer(stream)