class plugin_RSS:
	def __init__(self, path, deluge_core, deluge_interface):
		#set up system thingies
		import gtk, gtk.glade, os, ConfigParser, feedparser
		import deluge.common, deluge.dgtk, deluge.pref
		from time import asctime
		self.path = path
		self.core = deluge_core
		self.interface = deluge_interface
		#set up feeds file
		self.feeds_config = ConfigParser.ConfigParser()
		self.feeds_file = deluge.common.CONFIG_DIR + "/feeds.conf"
		if not os.path.isfile(self.feeds_file):
			f = open(self.feeds_file, mode='w')
			f.flush()
			f.close()
		self.feeds_config.read(self.feeds_file)
		#set up filters file
		self.filters_config = ConfigParser.ConfigParser()
		self.filters_file = deluge.common.CONFIG_DIR + "/filters.conf"
		if not os.path.isfile(self.filters_file):
			f = open(self.filters_file, mode='w')
			f.flush()
			f.close()
		self.filters_config.read(self.filters_file)
		#set up the preferences dialog
		glade = gtk.glade.XML(path + "/rss.glade")
		self.dlg = glade.get_widget("dialog")
		self.dlg.set_icon_from_file(self.path + "/rss.png")
		#set up the feeds list viewer
		self.feeds_view = glade.get_widget("feeds_view")
		model = gtk.ListStore(str, str, str)
		self.feeds_view.set_model(model)
		deluge.dgtk.add_text_column(self.feeds_view, _("Name"), 0)
		deluge.dgtk.add_text_column(self.feeds_view, _("URL"), 1)
		deluge.dgtk.add_text_column(self.feeds_view, _("Last Entry Date"), 2)
		#set up the torrents list viewer
		self.torrents_view = glade.get_widget("torrents_view")
		model = gtk.ListStore(str, str, str, str)
		self.torrents_view.set_model(model)
		deluge.dgtk.add_text_column(self.torrents_view, _("Feed"), 0)
		deluge.dgtk.add_text_column(self.torrents_view, _("Name"), 1)
		deluge.dgtk.add_text_column(self.torrents_view, _("URL"), 2)
		deluge.dgtk.add_text_column(self.torrents_view, _("Date"), 3)
		# Setup the filters list viewer
		self.filters_view = glade.get_widget("filters_view")
		model = gtk.ListStore(str)
		self.filters_view.set_model(model)
		deluge.dgtk.add_text_column(self.filters_view, _("Name"), 0)
		# set up the feed choice combobox
		self.feedchoice_combo = glade.get_widget("feedchoice_combo")
		model = gtk.ListStore(str)
		self.feedchoice_combo.set_model(model)
		cell = gtk.CellRendererText()
		self.feedchoice_combo.pack_start(cell, True)
		self.feedchoice_combo.add_attribute(cell, 'text', 0) 
		# set up the torrents feed choice combobox
		self.torrents_fcc = glade.get_widget("torrents_fcc")
		model = gtk.ListStore(str)
		self.torrents_fcc.set_model(model)
		cell = gtk.CellRendererText()
		self.torrents_fcc.pack_start(cell, True)
		self.torrents_fcc.add_attribute(cell, 'text', 0) 
		#set up the rest of the GUI elements
		self.name_entry = glade.get_widget("name_entry")		
		self.url_entry = glade.get_widget("url_entry")
		self.button_addfeed = glade.get_widget("button_addfeed")
		self.button_delfeed = glade.get_widget("button_delfeed")
		self.chkfeeds = glade.get_widget("chkfeeds")
		self.filtername_entry = glade.get_widget("filtername_entry")
		self.filterexp_entry = glade.get_widget("filterexp_entry")
		self.button_delfilter = glade.get_widget("button_delfilter")
		self.checkonstart_button = glade.get_widget("checkonstart_button")
		self.update_entry = glade.get_widget("update_entry")
		#Connect event signals
		self.filters_view.connect("cursor-changed", self.filter_row_clicked)
		dic = {	"addfeed_clicked" : self.addfeed_clicked,
				"delfeed_clicked" : self.delfeed_clicked,
				"addfilter_clicked" : self.addfilter_clicked,
				"delfilter_clicked" : self.delfilter_clicked,
				"row_clicked" : self.row_clicked,
				"feedtext_changed" : self.feedtext_changed,
				"filtername_lostfocus" : self.filtername_lostfocus,
				"filterexp_lostfocus" : self.filterexp_lostfocus,
				"feedchoice_combo_changed" : self.feedchoice_combo_changed,
				"torrents_fcc_changed" : self.torrents_fcc_changed,
				"torrents_view_row_activated" : self.torrents_view_row_activated,
				"chkfeeds_clicked" : self.chkfeeds_clicked }
		glade.signal_autoconnect(dic)
		self.feeds_view.get_selection().set_select_function(self.row_clicked)
		self.timer = 0
		self.torrents_list = []
		#self.checkfeeds()
		# Access the interface's toolbar
		self.toolbar = self.interface.toolbar
		# Make a toolbar button
		icon = gtk.Image()
		icon.set_from_file(self.path + "/rss.png") # Toolbar items should be 22x22 pixel images
		self.button = gtk.ToolButton(icon_widget=icon, label=_("RSS"))
		self.button.connect("clicked", self.rss_clicked) # Connect the signal handler for the button
		self.toolbar.add(self.button) # Add button to toolbar
		self.button.show_all() # Show the button
		self.checkonstart = False
		#load options
		if self.feeds_config.has_option("DEFAULT", "interval"):
			self.interval = self.feeds_config.getint("DEFAULT", "interval")
			self.update_entry.set_text(self.feeds_config.get("DEFAULT", "interval"))
		else:
			self.interval = 900
			self.feeds_config.set("DEFAULT", "interval", 900)
		if self.feeds_config.has_option("DEFAULT", "checkonstart"):
			self.checkonstart = self.feeds_config.getboolean("DEFAULT", "checkonstart")
			self.checkonstart_button.set_active(self.checkonstart)
		else:
			self.checkonstart = False
			self.feeds_config.set("DEFAULT", "checkonstart", False)
		if self.checkonstart_button.get_active():
			self.timer = self.interval - 5

	def rss_clicked(self, button):
		self.configure(self)
	
	def unload(self):
		self.toolbar.remove(self.button) # Remove the button from the toolbar
		f = open(self.feeds_file, "w")
		self.feeds_config.write(f)
		f.close()
	
	def feedtext_changed(self, args):
		a = (self.name_entry.get_text() != "")
		b = (self.url_entry.get_text() != "")
		if(a and b):
			self.button_addfeed.set_sensitive(1)
		else:
			self.button_addfeed.set_sensitive(0)

	def addfeed_clicked(self, args):
		self.feeds_view.get_model().append([self.name_entry.get_text(),
					self.url_entry.get_text(), ""])
		self.feedchoice_combo.append_text(self.name_entry.get_text())
		self.torrents_fcc.append_text(self.name_entry.get_text())
		self.feeds_config.add_section(self.name_entry.get_text())
		self.feeds_config.set(self.name_entry.get_text(), "url", self.url_entry.get_text())
		self.feeds_config.set(self.name_entry.get_text(), "lastchecked", "")
		self.name_entry.set_text("")
		self.url_entry.set_text("")

	def delfeed_clicked(self, args):
		(model, selection) = self.feeds_view.get_selection().get_selected()
		text = self.feeds_view.get_model().get_value(selection, 0)
		model2 = self.feedchoice_combo.get_model()
		model3 = self.torrents_fcc.get_model()
		the_iter = model2.get_iter_first()
		print text
		while the_iter is not None:
			print model2.get_value(the_iter, 0)
			if (model2.get_value(the_iter, 0) == text):
				remove_iter = the_iter
			the_iter = model2.iter_next(the_iter)
		model2.remove(remove_iter)
		the_iter = model3.get_iter_first()
		while the_iter is not None:
			print model3.get_value(the_iter, 0)
			if (model3.get_value(the_iter, 0) == text):
				remove_iter = the_iter
			the_iter = model3.iter_next(the_iter)
		model3.remove(remove_iter)
		model.remove(selection)
		for filt in self.filters_config.sections():
			if self.filters_config.get(filt, "feed") == text:
				self.filters_config.set(filt, "feed", "All")
		self.feeds_config.remove_section(text)
		self.button_delfeed.set_sensitive(0)
		
	def row_clicked(self, args):
		self.button_delfeed.set_sensitive(1)
		return True

	def addfilter_clicked(self, args):
		unique = True
		for filt in self.filters_config.sections():
			if filt == _("New Filter"):
				unique = False

		if unique:
			self.current_filter = _("New Filter")
			self.filters_config.add_section(_("New Filter"))
			new_iter = self.filters_view.get_model().append([_("New Filter")])
			self.filters_view.get_selection().select_iter(new_iter)
			self.filters_config.set(_("New Filter"), "filterexp", "")
			self.filters_config.set(_("New Filter"), "feed", "All")
			self.filtername_entry.set_text(_("New Filter"))
			self.feedchoice_combo.set_active(0)

			self.filtername_entry.set_sensitive(1)
			self.filterexp_entry.set_sensitive(1)
			self.feedchoice_combo.set_sensitive(1)
			self.filterexp_entry.set_text("")
			self.filtername_entry.grab_focus()
			self.button_delfilter.set_sensitive(1)

	def delfilter_clicked(self, args):
		model, selection = self.filters_view.get_selection().get_selected()
		self.filters_config.remove_section(self.current_filter)
		model.remove(selection)
		self.current_filter = None

		self.filtername_entry.set_text("")
		self.filterexp_entry.set_text("")
		self.feedchoice_combo.set_active(-1)
		self.filtername_entry.set_sensitive(0)
		self.filterexp_entry.set_sensitive(0)
		self.feedchoice_combo.set_sensitive(0)
		self.button_delfilter.set_sensitive(0)

	def filter_row_clicked(self, widget):
		selection = self.filters_view.get_selection()
		model, selection_iter = selection.get_selected()
		print model
		print selection_iter
		self.current_filter = self.filters_view.get_model().get_value(selection_iter, 0)
		self.filtername_entry.set_text(self.current_filter)
		self.filterexp_entry.set_text(self.filters_config.get(self.current_filter, "filterexp"))
		feed = self.filters_config.get(self.current_filter, "feed")
		model2 = self.feedchoice_combo.get_model()
		the_iter = model2.get_iter_first()
		while the_iter is not None:
			#print model2.get_value(the_iter, 0)
			if (model2.get_value(the_iter, 0) == feed):
				set_iter = the_iter
			the_iter = model2.iter_next(the_iter)
		self.feedchoice_combo.set_active_iter(set_iter)

		self.filtername_entry.set_sensitive(1)
		self.filterexp_entry.set_sensitive(1)
		self.feedchoice_combo.set_sensitive(1)
		self.button_delfilter.set_sensitive(1)

	def filtername_lostfocus(self, args, spare):
		(model, selection) = self.filters_view.get_selection().get_selected()
		old_filtername = self.filters_view.get_model().get_value(selection, 0)
		self.filters_config.remove_section(old_filtername)
		model.remove(selection)

		self.current_filter = self.filtername_entry.get_text()
		new_iter = self.filters_view.get_model().append([self.current_filter])
		self.filters_view.get_selection().select_iter(new_iter)
		self.filters_config.add_section(self.current_filter)
		self.filters_config.set(self.current_filter, "filterexp", self.filterexp_entry.get_text())
		self.filters_config.set(self.current_filter, "feed", self.feedchoice_combo.get_active_text())

	def filterexp_lostfocus(self, args, spare):
		self.filters_config.set(self.current_filter, "filterexp", self.filterexp_entry.get_text())

	def feedchoice_combo_changed(self, args):
		self.filters_config.set(self.current_filter, "feed", self.feedchoice_combo.get_active_text())

	def torrents_fcc_changed(self, args):
		model = self.torrents_view.get_model()
		model.clear()
		if self.torrents_fcc.get_active_text() == _("All"):
			for (date, feed, title, link) in self.torrents_list:
				self.torrents_view.get_model().append((feed, title, link, date))
		else:
			for (date, feed, title, link) in self.torrents_list:
				if feed == self.torrents_fcc.get_active_text():
					self.torrents_view.get_model().append((feed, title, link, date))

	def torrents_view_row_activated(self, widget, spare1, spare2):
		selection = widget.get_selection()
		model, selection_iter = selection.get_selected()
		self.interface.interactive_add_torrent_url(widget.get_model().get_value(selection_iter, 2))
		

	def chkfeeds_clicked(self, args):
		self.checkfeeds()

	def checkfeeds(self):
		import feedparser, datetime
		from time import asctime, strptime

		avail = {}
		sorted = {}
		self.torrents_list = []
		for name in self.feeds_config.sections():
			print "Attempting to parse " + name
			tmp = feedparser.parse(self.feeds_config.get(name, "url"))
			try:
				print "Parsed " + tmp['feed']['title']
				avail[name] = True
			except:
				print "Failed to download/parse " + name
				avail[name] = False
			if avail[name]:
				entries = []
				entries.extend( tmp[ "items" ] )
				decorated = [(entry["date_parsed"], entry) for entry in entries]
				tmplist = [(entry["date_parsed"], name, entry["title"], entry.enclosures[0].href) for entry in entries]
				decorated.sort()
				self.torrents_list.extend(tmplist)
				#decorated.reverse() # for most recent entries first
				sorted[name] = [entry for (date,entry) in decorated]

		model = self.torrents_view.get_model()
		model.clear()
		self.torrents_list.sort()
		self.torrents_list.reverse()
		#self.torrents_view.get_model().append([entry for entry in self.torrents_list])
		for (date,feed,title,link) in self.torrents_list:
			self.torrents_view.get_model().append((feed, title, link, date))
		#for key in sorted.keys():
		#	print "listing entries in " + key
		#	
		#	for entry in sorted[key]:
		#		print entry.title
		#		for enclosure in entry.enclosures:
		#			self.torrents_view.get_model().append( (key, entry.title, enclosure.href, entry.date_parsed) )

		checked = {}
		for name in self.filters_config.sections():
			checkfiltername = name
			checkfilterexp = self.filters_config.get(name, "filterexp")
			checkfilterfeed = self.filters_config.get(name, "feed")
			print "filter: " + checkfiltername
			print "search: " + checkfilterexp
			print "feed: " + checkfilterfeed
			if checkfilterfeed == "All":
				#print "made it to 'All'"
				for feedname in sorted.keys():
					if avail[feedname]:
						print feedname + " last checked: " + self.feeds_config.get(feedname, "lastchecked")
						if self.feeds_config.get(feedname, "lastchecked") != "":
							lastchecked = strptime(self.feeds_config.get(feedname, "lastchecked"))
						else:
							lastchecked = strptime(asctime(sorted[feedname][0].date_parsed))
						#print "searching feed: " + feedname
						for entry in sorted[feedname]:
							#print entry.title + ": " + asctime(entry.date_parsed)
							if (strptime(asctime(entry.date_parsed)) > lastchecked):
								#print entry.date_parsed
								#print " > "
								#print lastchecked
								if entry.title.find(checkfilterexp) != -1:
									#print "contains" + checkfilterexp
									for enclosure in entry.enclosures:
										print enclosure.href
										self.interface.interactive_add_torrent_url(enclosure.href)
										#self.feeds_config.set(feedname, "lastchecked", asctime(entry.date_parsed))
			else:
				if avail[checkfilterfeed]:
					print "searching feed: " + checkfilterfeed
					if self.feeds_config.get(checkfilterfeed, "lastchecked") != "":
						lastchecked = strptime(self.feeds_config.get(checkfilterfeed, "lastchecked"))
					else:
						#print sorted[checkfilterfeed][1].date_parsed
						lastchecked = strptime(asctime(sorted[checkfilterfeed][0].date_parsed))
					print "lastchecked: " + asctime(lastchecked)
					for entry in sorted[checkfilterfeed]:
						#print entry.title + ": " + asctime(entry.date_parsed)
						if (strptime(asctime(entry.date_parsed)) > lastchecked):
							#print entry.date_parsed
							#print " > "
							#print lastchecked
							if (entry.title.find(checkfilterexp) != -1):
								#print "contains" + checkfilterexp
								for enclosure in entry.enclosures:
									print enclosure.href
									self.interface.interactive_add_torrent_url(enclosure.href)
									#self.feeds_config.set(checkfilterfeed, "lastchecked", asctime(entry.date_parsed))

		for name in avail.keys():
			if avail[name]:
				self.feeds_config.set(name, "lastchecked", asctime(sorted[name][len(sorted[name])-1].date_parsed))

		self.timer = 0




	def configure(self, widget=None):
		import gtk, gtk.glade
		from deluge import common
		self.dlg.show_all()
		model = self.feeds_view.get_model()
		model.clear()
		model2 = self.feedchoice_combo.get_model()
		model2.clear()
		model3 = self.filters_view.get_model()
		model3.clear()
		model4 = self.torrents_fcc.get_model()
		model4.clear()
		self.filtername_entry.set_text("")
		self.filterexp_entry.set_text("")
		self.name_entry.set_text("")
		self.url_entry.set_text("")
		self.feedchoice_combo.append_text(_("All"))
		self.torrents_fcc.append_text(_("All"))
		self.torrents_fcc.set_active(0)
		for name in self.feeds_config.sections():
			self.feeds_view.get_model().append( (name, self.feeds_config.get(name, "url"), self.feeds_config.get(name, "lastchecked") ) )
			self.feedchoice_combo.append_text(name)
			self.torrents_fcc.append_text(name)
		for filters in self.filters_config.sections():
			self.filters_view.get_model().append( ([filters]) )
		#self.checkfeeds()
		self.button_addfeed.set_sensitive(0)
		self.button_delfeed.set_sensitive(0)
		self.filtername_entry.set_sensitive(0)
		self.filterexp_entry.set_sensitive(0)
		self.feedchoice_combo.set_sensitive(0)
		self.button_delfilter.set_sensitive(0)
		self.update_entry.set_text(str(self.interval))
		self.checkonstart_button.set_active(self.checkonstart)
		result = self.dlg.run()
		self.dlg.hide_all()
		if result == 1:
			self.interval = int(self.update_entry.get_text())
			self.feeds_config.set("DEFAULT", "interval", self.update_entry.get_text())
			self.feeds_config.set("DEFAULT", "checkonstart", self.checkonstart_button.get_active())
			f = open(self.filters_file, "w")
			self.filters_config.write(f)
			f.close()
			f = open(self.feeds_file, "w")
			self.feeds_config.write(f)
			f.close()
			

	def update(self):
		print "tick: " + str(self.timer)
		print "interval: " + str(self.interval)
		self.timer += 1
		if self.timer >= self.interval:
			print "BONG!"
			self.checkfeeds()
			self.timer = 0