#! /usr/bin/python
#
# Author: Rodney Dawes <rodney.dawes@canonical.com>
#
# Copyright 2009 Canonical Ltd.
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU General Public License version 3, as published
# by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranties of
# MERCHANTABILITY, SATISFACTORY QUALITY, 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, see <http://www.gnu.org/licenses/>.

from __future__ import with_statement
import re
import subprocess
from threading import Thread

import pygtk
pygtk.require('2.0')
import gobject
import gtk

from lptools import config

VOTES = { "Approve" : "#00ff00",
          "Needs Fixing" : "#993300",
          "Disapprove" : "#ff0000",
          "Resubmit" : "#ff0000",
          "Pending" : "#ff6600",
          "Abstain" : "#909090",
          "Needs Information" : "#909090",
          }

class Window(gtk.Window):

      def __init__(self):
            gtk.Window.__init__(self)
            self.set_title("Pending Reviews")
            self.set_default_size(320, 400)
            self.connect("destroy", lambda w: gtk.main_quit())
            self.connect("delete_event", lambda w,x: gtk.main_quit())

            vbox = gtk.VBox()
            self.add(vbox)
            vbox.show()

            toolbar = gtk.Toolbar()
            vbox.pack_start(toolbar, expand=False, fill=False)
            toolbar.show()

            button = gtk.ToolButton(gtk.STOCK_REFRESH)
            button.connect("clicked", self.__refresh)
            toolbar.insert(button, -1);
            button.show()

            scrollwin = gtk.ScrolledWindow()
            scrollwin.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
            vbox.pack_start(scrollwin, expand=True, fill=True)
            scrollwin.show()

            self.store = gtk.ListStore(str, str)

            view = gtk.TreeView(self.store)
            view.connect("row-activated", self.__open_link)
            scrollwin.add(view)
            view.show()

            cell = gtk.CellRendererText()
            col = gtk.TreeViewColumn("Branch", cell, markup=0)
            view.append_column(col)

            self.launchpad = None
            self.me = None

            self.thread = None
            self.id = 0
            Thread(target=self.__lp_login).start()

      def __lp_login(self):
            self.launchpad = config.get_launchpad("review-list")

            self.me = self.launchpad.me

            print "Allo, %s" % self.me.name
            gtk.gdk.threads_enter()
            self.__refresh(None)
            gtk.gdk.threads_leave()
            return False

      def __refresh(self, button, data=None):
            if self.id != 0:
                  gobject.source_remove(self.id)
                  self.id = 0
            self.__timeout()
            self.id = gobject.timeout_add_seconds(5 * 60, self.__timeout)
            return False

      def __open_link(self, view, path, column, data=None):
            row = self.store.get_iter(path)
            url, = self.store.get(row, 1)
            if url == "":
                  return
            ret = subprocess.call(["xdg-open", url])
            if ret != 0:
                  dialog = gtk.MessageDialog(self, 0, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, "Failed to run 'xdg-open %s'\n" % url)
                  dialog.run()
                  dialog.destroy()

      def __load_merges(self):
            merges = []
            mine = self.me.getRequestedReviews(status=[u'Needs review'])
            for merge in mine:
                  merges.append(merge)

            for team in self.me.super_teams:
                  for merge in team.getRequestedReviews(status=[u'Needs review']):
                        if merge not in merges:
                              merges.append(merge)

            for merge in merges:
                  votes = {}
                  for key in VOTES.keys():
                        votes[key] = 0

                  for vote in merge.votes:
                        if not vote.comment:
                              continue
                        else:
                              votes[vote.comment.vote] += 1

                  for key in votes.keys():
                        if votes[key] == 0:
                              votes.pop(key, None)

                  vstr = ", ".join(
                        ["<span color='%s'>%s</span>: %d" \
                               % (VOTES[key], key, votes[key]) \
                               for key in votes.keys()]
                        )
                  if vstr == "":
                        vstr = "No Reviews"
                  status = "%s\n%s" % (merge.source_branch.display_name,
                                       vstr)
                  urlp = re.compile(
                        'http[s]?://api\.(.*)launchpad\.net/[^/]+/')
                  merge_url = urlp.sub(
                        'http://launchpad.net/', merge.self_link)

                  gtk.gdk.threads_enter()
                  self.store.append((status, merge_url))
                  gtk.gdk.threads_leave()
            
      def __timeout(self):
            self.store.clear()
            if self.thread and self.thread.isAlive():
                  return True

            if self.thread is None:
                  thread = Thread(target=self.__load_merges)

            thread.start()
            return True

if __name__ == "__main__":
      gobject.threads_init()
      gtk.gdk.threads_init()
      try:
            win = Window()
            win.show()
            gtk.gdk.threads_enter()
            gtk.main()
            gtk.gdk.threads_leave()
      except KeyboardInterrupt:
            gtk.main_quit()