#!/usr/bin/env python

## -*- Mode: python; py-indent-offset: 4; indent-tabs-mode: nil; coding: utf-8; -*-

import cairo

import sys

import re

import gtk

class DataRange:

    def __init__(self, start = 0, end = 0, value = ''):

        self.start = start

        self.end = end

        self.value = value

class EventString:

    def __init__(self, at = 0, value = ''):

        self.at = at

        self.value = value

class EventFloat:

    def __init__(self, at = 0, value = 0.0):

        self.at = at

        self.value = value

class EventInt:

    def __init__(self, at = 0, value = 0.0):

        self.at = at

        self.value = value

def ranges_cmp(a, b):

    diff = a.start - b.start

    if diff < 0:

        return -1

    elif diff > 0:

        return +1

    else:

        return 0

def events_cmp(a, b):

    diff = a.at - b.at

    if diff < 0:

        return -1

    elif diff > 0:

        return +1

    else:

        return 0

class TimelineDataRange:

    def __init__(self, name = ''):

        self.name = name

        self.ranges = []

        return

    def __search(self, key):

        l = 0

        u = len(self.ranges)-1

        while l <= u:

            i = int((l + u) / 2)

            if key >= self.ranges[i].start and key <= self.ranges[i].end:

                return i

            elif key < self.ranges[i].start:

                u = i - 1

            else:

                # key > self.ranges[i].end

                l = i + 1

        return - 1

    def add_range(self, range):

        self.ranges.append(range)

    def get_all(self):

        return self.ranges

    def get_ranges(self, start, end):

        s = self.__search(start)

        e = self.__search(end)

        if s == -1 and e == -1:

            return []

        elif s == -1:

            return self.ranges[0:e + 1]

        elif e == -1:

            return self.ranges[s:len(self.ranges)]

        else:

            return self.ranges[s:e + 1]

    def get_ranges_bounds(self, start, end):

        s = self.__search(start)

        e = self.__search(end)

        if s == -1 and e == -1:

            return(0, 0)

        elif s == -1:

            return(0, e + 1)

        elif e == -1:

            return(s, len(self.ranges))

        else:

            return(s, e + 1)

    def sort(self):

        self.ranges.sort(ranges_cmp)

    def get_bounds(self):

        if len(self.ranges) > 0:

            lo = self.ranges[0].start

            hi = self.ranges[len(self.ranges)-1].end

            return(lo, hi)

        else:

            return(0, 0)

class TimelineEvent:

    def __init__(self, name = ''):

        self.name = name

        self.events = []

    def __search(self, key):

        l = 0

        u = len(self.events)-1

        while l <= u:

            i = int((l + u) / 2)

            if key == self.events[i].at:

                return i

            elif key < self.events[i].at:

                u = i - 1

            else:

                # key > self.events[i].at

                l = i + 1

        return l

    def add_event(self, event):

        self.events.append(event)

    def get_events(self, start, end):

        s = self.__search(start)

        e = self.__search(end)

        return self.events[s:e + 1]

    def get_events_bounds(self, start, end):

        s = self.__search(start)

        e = self.__search(end)

        return(s, e + 1)

    def sort(self):

        self.events.sort(events_cmp)

    def get_bounds(self):

        if len(self.events) > 0:

            lo = self.events[0].at

            hi = self.events[-1].at

            return(lo, hi)

        else:

            return(0, 0)

class Timeline:

    def __init__(self, name = ''):

        self.ranges = []

        self.event_str = []

        self.event_int = []

        self.name = name

    def get_range(self, name):

        for range in self.ranges:

            if range.name == name:

                return range

        timeline = TimelineDataRange(name)

        self.ranges.append(timeline)

        return timeline

    def get_event_str(self, name):

        for event_str in self.event_str:

            if event_str.name == name:

                return event_str

        timeline = TimelineEvent(name)

        self.event_str.append(timeline)

        return timeline

    def get_event_int(self, name):

        for event_int in self.event_int:

            if event_int.name == name:

                return event_int

        timeline = TimelineEvent(name)

        self.event_int.append(timeline)

        return timeline

    def get_ranges(self):

        return self.ranges

    def get_events_str(self):

        return self.event_str

    def get_events_int(self):

        return self.event_int

    def sort(self):

        for range in self.ranges:

            range.sort()

        for event in self.event_int:

            event.sort()

        for event in self.event_str:

            event.sort()

    def get_bounds(self):

        lo = 0

        hi = 0

        for range in self.ranges:

            (range_lo, range_hi) = range.get_bounds()

            if range_lo < lo:

                lo = range_lo

            if range_hi > hi:

                hi = range_hi

        for event_str in self.event_str:

            (ev_lo, ev_hi) = event_str.get_bounds()

            if ev_lo < lo:

                lo = ev_lo

            if ev_hi > hi:

                hi = ev_hi

        for event_int in self.event_int:

            (ev_lo, ev_hi) = event_int.get_bounds()

            if ev_lo < lo:

                lo = ev_lo

            if ev_hi > hi:

                hi = ev_hi

        return(lo, hi)

class Timelines:

    def __init__(self):

        self.timelines = []

    def get(self, name):

        for timeline in self.timelines:

            if timeline.name == name:

                return timeline

        timeline = Timeline(name)

        self.timelines.append(timeline)

        return timeline

    def get_all(self):

        return self.timelines

    def sort(self):

        for timeline in self.timelines:

            timeline.sort()

    def get_bounds(self):

        lo = 0

        hi = 0

        for timeline in self.timelines:

            (t_lo, t_hi) = timeline.get_bounds()

            if t_lo < lo:

                lo = t_lo

            if t_hi > hi:

                hi = t_hi

        return(lo, hi)

    def get_all_range_values(self):

        range_values = {}

        for timeline in self.timelines:

            for ranges in timeline.get_ranges():

                for ran in ranges.get_all():

                    range_values[ran.value] = 1

        return range_values.keys()

class Color:

    def __init__(self, r = 0.0, g = 0.0, b = 0.0):

        self.r = r

        self.g = g

        self.b = b

    def set(self, r, g, b):

        self.r = r

        self.g = g

        self.b = b

class Colors:

    # XXX add more

    default_colors = [Color(1, 0, 0), Color(0, 1, 0), Color(0, 0, 1), Color(1, 1, 0), Color(1, 0, 1), Color(0, 1, 1)]

    def __init__(self):

        self.__colors = {}

    def add(self, name, color):

        self.__colors[name] = color

    def lookup(self, name):

        if not self.__colors.has_key(name):

            self.add(name, self.default_colors.pop())

        return self.__colors.get(name)

class TopLegendRenderer:

    def __init__(self):

        self.__padding = 10

    def set_padding(self, padding):

        self.__padding = padding

    def set_legends(self, legends, colors):

        self.__legends = legends

        self.__colors = colors

    def layout(self, width):

        self.__width = width

        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 1, 1)

        ctx = cairo.Context(surface)

        line_height = 0

        total_height = self.__padding

        line_used = self.__padding

        for legend in self.__legends:

            (t_width, t_height) = ctx.text_extents(legend)[2:4]

            item_width = self.__padding + self.__padding + t_width + self.__padding

            item_height = t_height + self.__padding

            if item_height > line_height:

                line_height = item_height

            if line_used + item_width > self.__width:

                line_used = self.__padding + item_width

                total_height += line_height

            else:

                line_used += item_width

            x = line_used - item_width

        total_height += line_height

        self.__height = total_height

    def get_height(self):

        return self.__height

    def draw(self, ctx):

        i = 0

        line_height = 0

        total_height = self.__padding

        line_used = self.__padding

        for legend in self.__legends:

            (t_width, t_height) = ctx.text_extents(legend)[2:4]

            item_width = self.__padding + self.__padding + t_width + self.__padding

            item_height = t_height + self.__padding

            if item_height > line_height:

                line_height = item_height

            if line_used + item_width > self.__width:

                line_used = self.__padding + item_width

                total_height += line_height

            else:

                line_used += item_width

            x = line_used - item_width

            ctx.rectangle(x, total_height, self.__padding, self.__padding)

            ctx.set_source_rgb(0, 0, 0)

            ctx.set_line_width(2)

            ctx.stroke_preserve()

            ctx.set_source_rgb(self.__colors[i].r, 

                               self.__colors[i].g, 

                               self.__colors[i].b)

            ctx.fill()

            ctx.move_to(x + self.__padding*2, total_height + t_height)

            ctx.set_source_rgb(0, 0, 0)

            ctx.show_text(legend)

            i += 1

        return

class TimelinesRenderer:

    def __init__(self):

        self.padding = 10

        return

    def get_height(self):

        return self.height

    def set_timelines(self, timelines, colors):

        self.timelines = timelines

        self.colors = colors

    def set_render_range(self, start, end):

        self.start = start

        self.end = end

    def get_data_x_start(self):

        return self.padding / 2 + self.left_width + self.padding + self.right_width + self.padding / 2

    def layout(self, width):

        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 1, 1)

        ctx = cairo.Context(surface)

        max_text_height = ctx.text_extents("ABCDEFGHIJKLMNOPQRSTUVWXYZabcedefghijklmnopqrstuvwxyz0123456789")[3]

        left_width = 0

        right_width = 0

        left_n_lines = 0

        range_n = 0

        eventint_n = 0

        eventstr_n = 0

        for timeline in self.timelines.get_all():

            left_n_lines += 1

            t_width = ctx.text_extents(timeline.name)[2]

            left_width = max(left_width, t_width)

            for rang in timeline.get_ranges():

                t_width = ctx.text_extents(rang.name)[2]

                right_width = max(right_width, t_width)

                range_n += 1

            for events_int in timeline.get_events_int():

                t_width = ctx.text_extents(events_int.name)[2]

                right_width = max(right_width, t_width)

                eventint_n += 1

            for events_str in timeline.get_events_str():

                t_width = ctx.text_extents(events_str.name)[2]

                right_width = max(right_width, t_width)

                eventstr_n += 1

        left_height = left_n_lines * max_text_height + (left_n_lines - 1) * self.padding

        right_n_lines = range_n + eventint_n + eventstr_n

        right_height = (right_n_lines - 1) * self.padding + right_n_lines * max_text_height

        right_data_height = (eventint_n + eventstr_n) * (max_text_height + 5) + range_n * 10

        right_data_height += (right_n_lines - 1) * self.padding

        height = max(left_height, right_height)

        height = max(height, right_data_height)

        self.left_width = left_width

        self.right_width = right_width

        self.max_text_height = max_text_height

        self.width = width

        self.height = height + self.padding

    def draw_line(self, ctx, x, y, width, height):

        ctx.move_to(x, y)

        ctx.rel_line_to(width, height)

        ctx.close_path()

        ctx.set_operator(cairo.OPERATOR_SOURCE)

        ctx.set_line_width(1.0)

        ctx.set_source_rgb(0, 0, 0)

        ctx.stroke()

    def draw_events(self, ctx, events, x, y, width, height):

        if (self.grey_background % 2) == 0:

            ctx.rectangle(x, y - self.padding / 2, 

                          width, height + self.padding)

            ctx.set_source_rgb(0.9, 0.9, 0.9)

            ctx.fill()

        last_x_drawn = int(x)

        (lo, hi) = events.get_events_bounds(self.start, self.end)

        for event in events.events[lo:hi]:

            real_x = int(x + (event.at - self.start) * width / (self.end - self.start))

            if real_x > last_x_drawn + 2:

                ctx.rectangle(real_x, y, 1, 1)

                ctx.set_source_rgb(1, 0, 0)

                ctx.stroke()

                ctx.move_to(real_x, y + self.max_text_height)

                ctx.set_source_rgb(0, 0, 0)

                ctx.show_text(str(event.value))

                last_x_drawn = real_x

        self.grey_background += 1

    def draw_ranges(self, ctx, ranges, x, y, width, height):

        if (self.grey_background % 2) == 0:

            ctx.rectangle(x, y - self.padding / 2, 

                          width, height + self.padding)

            ctx.set_source_rgb(0.9, 0.9, 0.9)

            ctx.fill()

        last_x_drawn = int(x - 1)

        (lo, hi) = ranges.get_ranges_bounds(self.start, self.end)

        for data_range in ranges.ranges[lo:hi]:

            s = max(data_range.start, self.start)

            e = min(data_range.end, self.end)

            x_start = int(x + (s - self.start) * width / (self.end - self.start))

            x_end = int(x + (e - self.start) * width / (self.end - self.start))

            if x_end > last_x_drawn:

                ctx.rectangle(x_start, y, x_end - x_start, 10)

                ctx.set_source_rgb(0, 0, 0)

                ctx.stroke_preserve()

                color = self.colors.lookup(data_range.value)

                ctx.set_source_rgb(color.r, color.g, color.b)

                ctx.fill()

                last_x_drawn = x_end

        self.grey_background += 1

    def draw(self, ctx):

        timeline_top = 0

        top_y = self.padding / 2

        left_x_start = self.padding / 2

        left_x_end = left_x_start + self.left_width

        right_x_start = left_x_end + self.padding

        right_x_end = right_x_start + self.right_width

        data_x_start = right_x_end + self.padding / 2

        data_x_end = self.width

        data_width = data_x_end - data_x_start

        cur_y = top_y

        self.draw_line(ctx, 0, 0, self.width, 0)

        self.grey_background = 1

        for timeline in self.timelines.get_all():

            (y_bearing, t_width, t_height) = ctx.text_extents(timeline.name)[1:4]

            ctx.move_to(left_x_start, cur_y + self.max_text_height - (t_height + y_bearing))

            ctx.show_text(timeline.name);

            for events_int in timeline.get_events_int():

                (y_bearing, t_width, t_height) = ctx.text_extents(events_int.name)[1:4]

                ctx.move_to(right_x_start, cur_y + self.max_text_height - (t_height + y_bearing))

                ctx.show_text(events_int.name)

                self.draw_events(ctx, events_int, data_x_start, cur_y, data_width, self.max_text_height + 5)

                cur_y += self.max_text_height + 5 + self.padding

                self.draw_line(ctx, right_x_start - self.padding / 2, cur_y - self.padding / 2, 

                               self.right_width + self.padding, 0)

            for events_str in timeline.get_events_str():

                (y_bearing, t_width, t_height) = ctx.text_extents(events_str.name)[1:4]

                ctx.move_to(right_x_start, cur_y + self.max_text_height - (t_height + y_bearing))

                ctx.show_text(events_str.name)

                self.draw_events(ctx, events_str, data_x_start, cur_y, data_width, self.max_text_height + 5)

                cur_y += self.max_text_height + 5 + self.padding

                self.draw_line(ctx, right_x_start - self.padding / 2, cur_y - self.padding / 2, 

                               self.right_width + self.padding, 0)

            for ranges in timeline.get_ranges():

                (y_bearing, t_width, t_height) = ctx.text_extents(ranges.name)[1:4]

                ctx.move_to(right_x_start, cur_y + self.max_text_height - (t_height + y_bearing))

                ctx.show_text(ranges.name)

                self.draw_ranges(ctx, ranges, data_x_start, cur_y, data_width, 10)

                cur_y += self.max_text_height + self.padding

                self.draw_line(ctx, right_x_start - self.padding / 2, cur_y - self.padding / 2, 

                               self.right_width + self.padding, 0)

            self.draw_line(ctx, 0, cur_y - self.padding / 2, 

                           self.width, 0)

        bot_y = cur_y - self.padding / 2

        self.draw_line(ctx, left_x_end + self.padding / 2, 0, 

                       0, bot_y)

        self.draw_line(ctx, right_x_end + self.padding / 2, 0, 

                       0, bot_y)

        return

class ScaleRenderer:

    def __init__(self):

        self.__top = 0

        return

    def set_bounds(self, lo, hi):

        self.__lo = lo

        self.__hi = hi

    def get_position(self, x):

        real_x = (x - self.__lo ) * self.__width / (self.__hi - self.__lo)

        return real_x

    def set_top(self):

        self.__top = 1

    def set_bot(self):

        self.__top = 0

    def layout(self, width):

        surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, 1, 1)

        ctx = cairo.Context(surface)

        # calculate scale delta

        data_delta = self.__hi - self.__lo

        closest = 1

        while (closest*10) < data_delta:

            closest *= 10

        if (data_delta / closest) == 0:

            delta = closest

        elif(data_delta / closest) == 1:

            delta = closest / 10