#!/bin/python

#TODO: This needs to be resilient so when one subclass returns an error, the

# whole thing doesn't crash.

#TODO: what about http:// vs. http://www ... must be careful

#TODO: time is time committed, not time the feed was grabbed...

#TODO: put database table names in a variable or something

#TODO: need to get rid of latin-1 encoding for SQL queries

#TODO: don't check feeds that haven't been updated since we last checked them 

# -- can only do this on feeds whose contents won't change 

# (LastFM, Microblogs), but... what about deleted content??

#TODO: tags and categories, whitelist through subclasses for services that support it

#TODO: I'm ignoring the published and published_parsed dates entirely

#TODO: make sure the user defined classes and wonky feeds don't BREAK the whole script!

import feedparser

import entry

import time

import re

"""An object representing an RSS/Atom feed in a unified, simplified standard

format. This object is the universal mold for which feeds from various services

can be understood. It can be subclassed in order to handle the nuances or

quirks of any particular web service.

"""

class Feed:

  entryClass = entry.Entry

  """Initialize the object."""

  def __init__(self, url):

    self.href = url

    self.feed = feedparser.parse(self.href)

  #TODO: what happens on failure? 

  """Parse the feed and store the desired data."""

  def parse(self):

    if not self.feed:

      return

    # Collect data from the feed object's direct attributes

    attrs = ['version', 'encoding', 'title', 'subtitle']

    for attr in attrs:

      setattr(self, attr, getattr(self.feed, attr, "") )

    # Other attributes burried deeper

    attrs = ['title', 'subtitle', 'link']

    for attr in attrs:

      setattr(self, attr, getattr(self.feed.feed, attr, "") )

    # Strip HTML from subtitle

    self.subtitle = re.sub(r'<[^>]*?>', '', self.subtitle)

    # Timestamp for last update

    self.updated_ts = self.get_timestamp()

    # Parse entries

    self.entries = []

    for e in self.feed.entries:

      self.entries += [self.entryClass(e)]

    return True

  """Retrieve the 'updated' timestamp."""

  def get_timestamp(self):

    if hasattr(self.feed, 'updated'):

      return int(time.mktime(self.feed.updated))

    else:

      return int(time.time())

  """Output the feed to xml using a DOM object.

  doc - DOM object

  Returns a populated DOM object.

  """

  def toXML(self, doc):

    xml = doc.createElement('feed')

    attrs = ['version', 'encoding', 'href', 'link', 'updated']

    for attr in attrs:

      if getattr(self, attr):

        xml.setAttribute(attr, getattr(self, attr))

    elements = ['title', 'subtitle']

    for element in elements:

      if getattr(self, element):

        e = doc.createElement(element)

        e.appendChild( doc.createTextNode( getattr(self, element) ) )

        xml.appendChild( e )

    for entry in self.entries:

      xml.appendChild( entry.toXML(doc) )

    return xml

  """Ensure this feed and its contents are in the database and up-to-date. If

  force is true, update all entries regardless of whether or not an update

  seems to be necessary."""

  def db_check(self, cursor, verbose=False, force=False):

    # Check the feed

    if self.db_has(cursor):

      self.db_update(cursor, verbose, force)

    else:

      self.db_insert(cursor, verbose) 

  """Return the ID of this feed in the database.

  pre-condition: feed must exist in the database

  """

  def db_get_feed_id(self, cursor):

    cursor.execute("SELECT `id` FROM `feeds` WHERE `href` = %s", self.href)

    return cursor.fetchone()[0]

  """Check to see if this feed exists in the database."""

  def db_has(self, cursor):

    cursor.execute("SELECT * FROM feeds WHERE href= %s", self.href)

    return cursor.rowcount > 0

  """Insert feed information into the database.

  pre-condition: db_has must be called before to avoid duplicate entries

  """

  def db_insert(self, cursor, verbose=False, force=False):

    cursor.execute(

      """INSERT INTO feeds (href, title, subtitle, link, encoding, 

        version, rec_created, rec_updated, type)

      VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)""",

      (self.href, self.title, self.subtitle, self.link, self.encoding, 

        self.version, int(time.time()), self.updated_ts, 

        self.__class__.__name__))

    if verbose:

      print "\tFeed inserted: %s" % self.title

    #TODO: raise error upon failure

    # Check entries (even new entries could be duplicates if href changes)

    for entry in self.entries:

      entry.db_check(cursor, self.db_get_feed_id(cursor), force)  

  """Returns turn if the feed timestampe is more recent than the timestamp in

  the database (i.e. the database is out of date); false otherwise.

  """

  def db_needs_update(self,cursor):

    cursor.execute(

      """SELECT COUNT(*) FROM feeds

        WHERE href=%s AND rec_updated < %s""",

      (self.href, self.updated_ts))

    return cursor.fetchone()[0] == 1

  """Update feed information in the database. If force is true, do the update

  regardless, otherwise check db_needs_update() to see if it's necessary.

  pre-condition: db_has must be called first to avoid errors """

  def db_update(self, cursor, verbose=False, force=False):

    if force or self.db_needs_update(cursor):

      cursor.execute(

        """UPDATE feeds SET title=%s, subtitle=%s, link=%s, encoding=%s,

        version=%s, rec_updated=%s, type=%s WHERE href=%s""",

        (self.title, self.subtitle, self.link, self.encoding, 

          self.version, self.updated_ts, self.__class__.__name__,

          self.href))

      if verbose:

        print "\tFeed updated: %s" % self.title

      # Check entries (some might be new, some might be old)

      for entry in self.entries:

        entry.db_check(cursor,self.db_get_feed_id(cursor),verbose,force)

    elif verbose:

      print "\tNo update necessary: %s" % self.title

"""These are essentially abstract classes."""

class Blog(Feed):

  entryClass = entry.BlogEntry

  def get_timestamp(self):

    if hasattr(self.feed, 'updated'):

      return int(time.mktime(self.feed.updated))

    elif hasattr(self.feed.feed, 'lastbuilddate'):

      return int(time.mktime(time.strptime(self.feed.feed.lastbuilddate, '%a, %d %b %Y %H:%M:%S %Z')))

    elif hasattr(self.feed.feed, 'updated_parsed'):

      return int(time.mktime(self.feed.feed.updated_parsed))

    else:

      return int(time.time())

class Comments(Feed):

  entryClass = entry.Comment

class MicroBlog(Feed):

  entryClass = entry.MicroBlogEntry

class SharedItems(Feed):

  entryClass = entry.SharedItem 

class Favorites(SharedItems):

  entryClass = entry.Favorite

class Multimedia(SharedItems):

  entryClass = entry.MultimediaContent

class StatusUpdates(Feed):

  entryClass = entry.StatusUpdate

"""These classes should be used directly."""

class BackType(Comments):

  entryClass = entry.BackTypeComment

class BlipFM(MicroBlog):

  entryClass = entry.BlipFMUpdate

class Delicious(SharedItems):

  entryClass = entry.DeliciousBookmark

class Digg(SharedItems):

  entryClass = entry.DuggItem

class FacebookPostedItems(SharedItems):

  entryClass = entry.FacebookPostedItem

class FacebookStatusUpdates(StatusUpdates):

  entryClass = entry.FacebookStatusUpdate

class Flickr(Multimedia):

  entryClass = entry.FlickrPhoto

  """Flickr's feed title isn't very descriptive."""

  def parse(self):

    success = Multimedia.parse(self)

    self.title = 'Flickr ' + self.title

    return success

class Gitorious(Feed):

  entryClass = entry.GitoriousUpdate

class GoogleReaderSharedItems(SharedItems):

  entryClass = entry.GoogleReaderSharedItem

  def get_timestamp(self):

    return int(time.mktime(self.feed.feed.updated_parsed)) #TODO: what's the pattern?

class Identica(MicroBlog):

  entryClass = entry.IdenticaUpdate

  """Identica's feed title isn't very descriptive."""

  def parse(self):

    success = MicroBlog.parse(self)

    self.title = 'Identi.ca - ' + self.title

    return success

class IdenticaFavorites(Favorites):

  entryClass = entry.IdenticaFavorite

class LastFM(SharedItems):

  entryClass = entry.LastFMPlay

class LibreFM(SharedItems):

  entryClass = entry.LibreFMPlay

  """Libre.fm is doing some RDF things that are different."""

  def parse(self):

    success = SharedItems.parse(self)

    self.link = self.feed.feed.links[0]['rdf:resource']

    return success

class MySpaceBlog(Blog):

  entryClass = entry.MySpaceBlogEntry

class TTRSSPublishedItems(SharedItems):

  entryClass = entry.TTRSSPublishedItem

class Twitter(MicroBlog):

  entryClass = entry.TwitterUpdate

class TwitterFavorites(Favorites):

  entryClass = entry.TwitterFavorite

class TwitterSearch(Twitter):

  entryClass = entry.TwitterSearchResult

class WordPress(Blog):

  entryClass = entry.WordPressEntry

class YouTube(Multimedia):

  entryClass = entry.YouTubeVideo

class YouTubeFavorites(Favorites):

  entryClass = entry.YouTubeFavorite