#!/bin/python

# coding: utf-8

#TODO: Check number of comments, if a comments feed exists

import time

import re

import unicodedata

from xml.dom import minidom

"""An object representing an entry in an RSS/Atom feed. This is the universal

object for representing any entry in a feed from any service. It can be

subclassed in order to handle the nuances or quirks of any particular web

service.

"""

class Entry:

  """Store the entry list from feedparser and parse it."""

  def __init__(self, entry):

    self.entry = entry

    self.parse()

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

  def parse(self):

    attrs = ['author', 'link', 'comments_feed', 'comments', 'title',

      'updated', 'updated_parsed', 'summary']

    for attr in attrs:

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

    self.content = self.get_content()

    self.updated_ts = self.get_timestamp()

    #this will save so many headaches TODO: more of this?

    self.title = unicodedata.normalize('NFKD', self.title).encode('ASCII', 'xmlcharrefreplace')

    if type(self.summary) == unicode:

      self.summary = unicodedata.normalize('NFKD', self.summary).encode('ASCII', 'xmlcharrefreplace')

    self.tags = []

    # For consistency, ignore case

    for tag in self.get_tags():

      self.tags += [tag.lower()]

  """Retrieve the main content of the story."""

  def get_content(self):

    if hasattr(self.entry, 'content'):

      return self.entry.content[0].value

    return ""

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

  def get_timestamp(self):

    #TODO: I don't know if this will work when DST is over...

    # also... time.altzone... but it's wrong during DST (time.daylight)

    return int(time.mktime(self.entry.updated_parsed)) - time.timezone

  """Retrive a list of tags on this entry from the feed."""

  def get_tags(self):

    tags = []

    if hasattr(self.entry, 'tags'):

      for tag in self.entry.tags:

        tags += [tag['term']]

    return tags

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

  def toXML(self, doc):

    xml = doc.createElement('entry')

    attrs = ['author', 'link', 'comments_feed', 'comments', 'updated']

    for attr in attrs:

      if getattr(self, attr):

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

    elements = ['title', 'summary', 'content']

    for element in elements:

      if getattr(self, element):

        e = doc.createElement(element)

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

        xml.appendChild( e )

    return xml

  """Ensure the entry is in the database and up-to-date.

  cursor - database cursor for performing queries

  feed_id - the ID of the feed from which the entry hails

  force - update regardless if set to true

  """

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

    self.entry_id = self.db_get_entry_id(cursor)

    if self.entry_id:

      self.db_update(cursor, feed_id, verbose, force)

    else:

      self.db_insert(cursor, feed_id, verbose)

  """Return the unique ID of this entry in the database.

  cursor - database cursor for performing queries

  """

  def db_get_entry_id(self, cursor):

    cursor.execute("SELECT id FROM entries WHERE link=%s", self.link)

    if cursor.rowcount == 0:

      return None

    elif cursor.rowcount == 1:

      return cursor._rows[0][0]

    else:

      raise Exception("Cannot determine unqiue entry_id")

  """Insert the entry into the database.

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

  cursor - database cursor for performing queries

  feed_id - the ID of the feed from which the entry hails

  verbose - output more information if set to True

  """

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

    cursor.execute(

      """INSERT INTO entries (link, title, author, summary, content,

        rec_created, rec_updated, comments, comments_feed,

        feed_id)

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

      (self.link, self.title, self.author, self.summary, self.content,

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

        self.comments, self.comments_feed, feed_id))

    self.entry_id = cursor.lastrowid

    #if verbose -- nah, this is important

    print "\t\tEntry inserted: %s" % self.title

    #TODO: raise error upon failure

    # Add tags

    for tag in self.tags:

      self.db_add_tag(cursor, tag, verbose)

  """Returns true if feed updated timestamp is more recent than the timestamp

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

  """

  def db_needs_update(self, cursor):

    cursor.execute(

      """SELECT COUNT(*) FROM entries

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

      (self.link, self.updated_ts))

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

  """Update entry in the database.

  pre-condition: db_has must be called first to make sure entry exist in db

  feed_id - the ID of the feed from which the entry hails

  verbose - output more information if set to True

  force - update regardless if set to True

  """

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

    if force or self.db_needs_update(cursor):

      # Only updating fields which are expected to change (e.g. not links)

      cursor.execute(

        """UPDATE entries SET title=%s, author=%s, summary=%s, 

          content=%s, rec_updated=%s, comments=%s, comments_feed=%s

          WHERE id=%s""",

        (self.title, self.author, self.summary, self.content, 

          self.updated_ts, self.comments, self.comments_feed, 

          self.entry_id))

      # Check tags

      current_tags = self.db_get_tags(cursor)

      # Tag entry if not already tagged

      for tag in self.tags:

        if not current_tags.__contains__(tag):

          self.db_add_tag(cursor, tag, verbose)

      # Remove tags which no longer exist in the feed

      for tag in current_tags:

        if not self.tags.__contains__(tag):

          self.db_remove_tag(cursor, tag, verbose)

      if verbose:

        print "\t\t"

      print "Entry updated: %s" % self.title

      #TODO: raise error upon failure

    elif verbose:

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

  """Add tag to entry, if not tagged as such alrady. If tag doesn't

  exist in the database, create it.

  Precondition: self.entry_id must be set

  cursor - database cursor for performing queries

  tag - the tag to add (string)

  verbose - output more information if set to True

  """

  def db_add_tag(self, cursor, tag, verbose=False):

    if not hasattr(self, 'entry_id'):

      raise Exception('entry_id must be set')

    added=False

    tag_id = self.db_get_tag_id(cursor, tag)

    if not tag_id:

      tag_id = self.db_insert_tag(cursor, tag)

      added = True

    if not self.db_tagged_with(cursor, tag_id):       

      cursor.execute("""

        INSERT INTO tag_relationships (entry_id, tag_id)

        VALUES (%s,%s) """, (self.entry_id, tag_id))

      #TODO: error checking

      if verbose:

        if added:

          print "\t\t\tTagged with %s [new]" % (tag)

        else:

          print "\t\t\tTagged with %s" % (tag)

  """Untags item. Does not delete tag from database."""

  def db_remove_tag(self, cursor, tag, verbose=False):

    if not hasattr(self, 'entry_id'):

      raise Exception('entry_id must be set')

    tag_id = self.db_get_tag_id(cursor, tag)

    if not tag_id:

      raise Exception('cannot find tag')

    cursor.execute("""

      DELETE FROM tag_relationships

      WHERE tag_id=%s AND entry_id=%s""", (tag_id, self.entry_id))

    #TODO: error checking

    if verbose:

      print "\t\t\tUntagged with %s" % (tag)

  """Returns the tag ID from the database."""

  def db_get_tag_id(self, cursor, tag):

    if not cursor.execute("SELECT id FROM tags WHERE name=%s", tag):

      return None

    else:

      return cursor._rows[0][0]

  """Return a list of all tags linked to this entry."""

  def db_get_tags(self, cursor):

    if not hasattr(self, 'entry_id'):

      raise Exception('entry_id must be set')

    tags = []

    #TODO: error checking

    cursor.execute("""

      SELECT t.name

      FROM tags t

      LEFT OUTER JOIN tag_relationships r ON t.id = r.tag_id

      WHERE r.entry_id=%s""", self.entry_id)

    for row in cursor._rows:

      tags += [row[0]]

    return tags

  """Insert tag into the database. Returns insert_id."""

  def db_insert_tag(self, cursor, tag):

    cursor.execute("INSERT INTO tags SET name=%s", tag)

    return cursor.lastrowid

  """Returns true if entry is tagged with given string, false o.w."""

  def db_tagged_with(self, cursor, tag_id):

    return cursor.execute("""

      SELECT * FROM tag_relationships

      WHERE entry_id=%s AND tag_id=%s""", (self.entry_id, tag_id))

"""Abstract classes."""

class BlogEntry(Entry):

  pass

class Comment(Entry):

  pass

class MicroBlogEntry(Entry):

  pass

class SharedItem(Entry):

  pass

class Favorite(SharedItem):

  pass

class MultimediaContent(SharedItem):

  def parse(self):

    SharedItem.parse(self)

    # The main link is the link to comments too

    self.comments = self.link

class StatusUpdate(Entry):

  pass

"""These classes can be used directly."""

class BackTypeComment(Comment):

  pass

class BlipFMUpdate(MicroBlogEntry):

  def parse(self):

    MicroBlogEntry.parse(self)

    self.tags += ['music'] #should I do this?

class DeliciousBookmark(SharedItem):

  """Delicious puts tags together, space separated."""

  def get_tags(self):

    tags = []

    if hasattr(self.entry, 'tags'):

      for tag in self.entry.tags[0]['term'].split():

        tags += [tag]

    return tags

class DuggItem(SharedItem):

  def parse(self):

    SharedItem.parse(self)

    self.comments = self.link

class FacebookPostedItem(SharedItem):

  pass

  #TODO: this needs to be smarter - input is a mess

  """def parse_other(self):

    # Need to catch errors, so this doesn't crash whole script

    try:

      x = minidom.parseString(self.summary)

      self.content = "%s %s %s" % (x.childNodes[0].childNodes[0].childNodes[0].childNodes[0].toxml(),

        x.childNodes[0].childNodes[1].childNodes[0].childNodes[0].childNodes[0].toxml(),

        x.childNodes[0].childNodes[1].childNodes[0].childNodes[1].childNodes[0].toxml())

      self.summary = x.childNodes[0].childNodes[1].childNodes[1].childNodes[0].childNodes[0].toxml()

    except Exception, e:

      print "Can't do it", e"""

class FacebookStatusUpdate(StatusUpdate):

  def get_content(self):

    return self.title

class FlickrPhoto(MultimediaContent):

  """Flickr dumps all sorts of different information into the content field.

  The first paragraph is redundant (username posted a photo);

  the second paragraph contains the thumbnail photo we want;

  if there's a third paragraph, it's a description -- this should be summary."""

  def parse(self):

    MultimediaContent.parse(self)

    try:

      # Get rid of line breaks, because that makes parsing more difficult

      new_content = ""

      for line in self.content.splitlines():

        new_content += line

      # Turn it into an xml object for easy parsing

      x = minidom.parseString('<div>' + new_content + '</div>')

      # Second paragraph is thumbnail (#TODO: not anymore? whitespace nonsense?)

      self.content = x.childNodes[0].childNodes[2].childNodes[0].toxml()

      # Third paragraph is description (optional)

      if len(x.childNodes[0].childNodes) >= 4:

        self.summary = x.childNodes[0].childNodes[3].childNodes[0].toxml()

    except IndexError:

      pass

class GitoriousUpdate(Entry):

  def parse(self):

    Entry.parse(self)

    self.tags += ['code'] #TODO: should I hardcode this?

  """No unique links, so we need a stronger criteria."""

  def db_get_entry_id(self, cursor):

    cursor.execute("""SELECT id FROM entries 

      WHERE link=%s AND rec_updated=%s""", 

      (self.link, self.updated_ts))

    if cursor.rowcount == 0:

      return None

    elif cursor.rowcount == 1:

      return cursor._rows[0][0]

    else:

      #TODO: need to output warning and move on, not raise exception

      print cursor._rows

      raise Exception("Cannot determine unqiue entry_id %d" % cursor.rowcount)

class GoogleReaderSharedItem(SharedItem):

  """Don't want tags because I didn't create them."""

  def get_tags(self):

    return []

  #TODO: db_has uniquely determined? what if I share something twice?

class IdenticaUpdate(MicroBlogEntry):

  def get_content(self):

    return self.title

class IdenticaFavorite(IdenticaUpdate):

  pass

class LastFMPlay(SharedItem):

  """Summary info isn't relevant at all here."""

  def parse(self):

    SharedItem.parse(self)

    self.summary = ""

    self.tags += ['music'] #should I do this?

  """Last.fm doesn't use unique links, so we need a stronger criteria."""

  def db_get_entry_id(self, cursor):

    cursor.execute("""SELECT id FROM entries 

      WHERE link=%s AND rec_updated=%s""", 

      (self.link, self.updated_ts))

    if cursor.rowcount == 0:

      return None

    elif cursor.rowcount == 1:

      return cursor._rows[0][0]

    else:

      #TODO: need to output warning and move on, not raise exception

      print cursor._rows

      raise Exception("Cannot determine unqiue entry_id %d" % cursor.rowcount)

class LibreFMPlay(LastFMPlay):

  """Libre.fm is using Dublin Core or something?."""

  def get_timestamp(self):

    return int(time.mktime(time.strptime(self.entry.dcterms_date, '%Y-%m-%dT%X+00:00'))) - time.timezone

class MySpaceBlogEntry(BlogEntry):

  def get_content(self):

    return self.summary

class GoogleReaderSharedItem(SharedItem):

  pass

class TTRSSPublishedItem(SharedItem):

  pass

class TwitterUpdate(MicroBlogEntry):

  def get_content(self):

    return self.title

  def parse(self):

    MicroBlogEntry.parse(self)

    m = re.search('([^:]+): (.+)', self.content)

    if (m):

      self.author = m.group(1)

      self.content = m.group(2)

      self.summary = m.group(2)

class TwitterFavorite(TwitterUpdate):

  pass

class TwitterSearchResult(TwitterUpdate):

  pass

class WordPressEntry(BlogEntry):

  def parse_other(self):

    self.comments_feed = self.entry.wfw_commentrss

class YouTubeVideo(MultimediaContent):

  def get_tags(self):

    tags = []

    if hasattr(self.entry, 'media_category'):

      for tag in self.entry.media_category.split():

        tags += [tag]

    return tags

class YouTubeFavorite(Favorite):

  pass