#
# Copyright (C) International Business Machines  Corp., 2009
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
# 2009-Dec-31:	Initial version by Darren Hart <dvhltc@us.ibm.com>
#

import gobject #delete me ?
import time
import sys
import gtk
from tracecmd import *
from ctracecmdgui import *

"""
Python interface for tracecmd GTK widgets

Python tracecmd applications should be written to this interface. It will be
updated as the tracecmd gui C API changes and try to minimze the impact to
python applications. The ctracecmdgui Python module is automatically generated
using SWIG and it is recommended applications not use it directly.
"""

# In a "real" app these width should be determined at runtime testing max length
# strings in the current font.
TS_COL_W    = 150
CPU_COL_W   = 35
EVENT_COL_W = 150
PID_COL_W   = 75
COMM_COL_W  = 250


def timing(func):
  def wrapper(*arg):
      start = time.time()
      ret = func(*arg)
      end = time.time()
      print('@%s took %0.3f s' % (func.func_name, (end-start)))
      return ret
  return wrapper


class EventStore(gtk.GenericTreeModel):
    # FIXME: get these from the C code: trace_view_store->column_types ...
    @timing
    def __init__(self, trace):
        gtk.GenericTreeModel.__init__(self)
        self.trace = trace
        self.cstore = trace_view_store_new(trace.handle)
        self.gtk_cstore = trace_view_store_as_gtk_tree_model(self.cstore)
        num_rows = trace_view_store_num_rows_get(self.cstore)
        print("Loaded %d events from trace" % (num_rows))

    def on_get_flags(self):
        return trace_view_store_get_flags(self.gtk_cstore)

    def on_get_n_columns(self):
        return trace_view_store_get_n_columns(self.gtk_cstore)

    def on_get_column_type(self, col):
        # I couldn't figure out how to convert the C GType into the python
        # GType. The current typemap converts the C GType into the python type,
        # which is what this function is supposed to return anyway.
        pytype = trace_view_store_get_column_type(self.gtk_cstore, col)
        return pytype

    def on_get_iter(self, path):
        if len(path) > 1 and path[1] != 1:
            return None
        n = path[0]
        rec = trace_view_store_get_row(self.cstore, n)
        return rec

    def on_get_path(self, rec):
        if not rec:
            return None
        start_row = trace_view_store_start_row_get(self.cstore)
        return (trace_view_record_pos_get(rec) - start_row,)

    def on_get_value(self, rec, col):
        # FIXME: write SWIG wrapper to marshal the Gvalue and wrap the rec in an
        # Iter
        pass
        #return trace_view_store_get_value_py(self.cstore, rec, col)

    def on_iter_next(self, rec):
        pos = trace_view_record_pos_get(rec)
        start_row = trace_view_store_start_row_get(self.cstore)
        return trace_view_store_get_row(self.cstore, pos - start_row + 1)

    def on_iter_children(self, rec):
        if rec:
            return None
        return trace_view_store_get_row(self.cstore, 0)

    def on_iter_has_child(self, rec):
        return False

    def on_iter_n_children(self, rec):
        if rec:
            return 0
        return trace_view_store_num_rows_get(self.cstore)

    def on_iter_nth_child(self, rec, n):
        if rec:
            return None
        return trace_view_store_get_row(self.cstore, n)

    def on_iter_parent(self, child):
        return None

    def get_event(self, iter):
        path = self.get_path(iter)
        if not path:
            return None
        rec = trace_view_store_get_row(self.cstore, path[0])
        if not rec:
            return None
        ev = self.trace.read_event_at(trace_view_record_offset_get(rec))
        return ev


class EventView(gtk.TreeView):
    def __init__(self, model):
        gtk.TreeView.__init__(self, model)
        self.set_fixed_height_mode(True)

        ts_col = gtk.TreeViewColumn("Time (s)")
        ts_col.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
        ts_col.set_fixed_width(TS_COL_W)
        ts_cell = gtk.CellRendererText()
        ts_col.pack_start(ts_cell, False)
        ts_col.set_cell_data_func(ts_cell, self.data_func, "ts")
        self.append_column(ts_col)

        cpu_col = gtk.TreeViewColumn("CPU")
        cpu_col.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
        cpu_col.set_fixed_width(CPU_COL_W)
        cpu_cell = gtk.CellRendererText()
        cpu_col.pack_start(cpu_cell, False)
        cpu_col.set_cell_data_func(cpu_cell, self.data_func, "cpu")
        self.append_column(cpu_col)

        event_col = gtk.TreeViewColumn("Event")
        event_col.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
        event_col.set_fixed_width(EVENT_COL_W)
        event_cell = gtk.CellRendererText()
        event_col.pack_start(event_cell, False)
        event_col.set_cell_data_func(event_cell, self.data_func, "event")
        self.append_column(event_col)

        pid_col = gtk.TreeViewColumn("PID")
        pid_col.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
        pid_col.set_fixed_width(PID_COL_W)
        pid_cell = gtk.CellRendererText()
        pid_col.pack_start(pid_cell, False)
        pid_col.set_cell_data_func(pid_cell, self.data_func, "pid")
        self.append_column(pid_col)

        comm_col = gtk.TreeViewColumn("Comm")
        comm_col.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
        comm_col.set_fixed_width(COMM_COL_W)
        comm_cell = gtk.CellRendererText()
        comm_col.pack_start(comm_cell, False)
        comm_col.set_cell_data_func(comm_cell, self.data_func, "comm")
        self.append_column(comm_col)

    def data_func(self, col, cell, model, iter, data):
        ev = model.get_event(iter)
        #ev = model.get_value(iter, 0)
        if not ev:
            return False

        if data == "ts":
            cell.set_property("markup", "%d.%d" % (ev.ts/1000000000,
                                                   ev.ts%1000000000))
        elif data == "cpu":
            cell.set_property("markup", ev.cpu)
        elif data == "event":
            cell.set_property("markup", ev.name)
        elif data == "pid":
            cell.set_property("markup", ev.pid)
        elif data == "comm":
            cell.set_property("markup", ev.comm)
        else:
            print("Unknown Column:", data)
            return False

        return True


class EventViewerApp(gtk.Window):
    def __init__(self, trace):
        gtk.Window.__init__(self)

        self.set_size_request(650, 400)
        self.set_position(gtk.WIN_POS_CENTER)

        self.connect("destroy", gtk.main_quit)
        self.set_title("Event Viewer")

        store = EventStore(trace)
        view = EventView(store)

        sw = gtk.ScrolledWindow()
        sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
        sw.add(view)

        # track how often the treeview data_func is called
        self.add(sw)
        self.show_all()


# Basic builtin test, execute module directly
if __name__ == "__main__":
    if len(sys.argv) >=2:
        filename = sys.argv[1]
    else:
        filename = "trace.dat"

    print("Initializing trace...")
    trace = Trace(filename)
    print("Initializing app...")
    app = EventViewerApp(trace)
    print("Go!")
    gtk.main()