#!/usr/bin/python
import commands, cgi, os, re, sys, time
from xml.sax.saxutils import escape
from glob import glob
from config import directory
import cache, nonce
from atomef import unescape

fs = cgi.FieldStorage()
charset=cgi.parse_header(fs.headers['content-type'])[1].get('charset','utf-8')
def param(key):
  value=(fs.list and fs.has_key(key) and fs.getvalue(key)) or ''
  try:
    return unicode(value,charset)
  except:
    return str(value).decode('iso-8859-1')

def xmlchars(text):
  # convert high bit characters to numeric equivalents
  for i in range(len(text)-1,-1,-1):
    if ord(text[i])>=128:
      text = '%s&#%d;%s' % (text[:i], ord(text[i]), text[i+1:])
  return text

cp1252 = {
  128: 8364, # euro sign
  130: 8218, # single low-9 quotation mark
  131:  402, # latin small letter f with hook
  132: 8222, # double low-9 quotation mark
  133: 8230, # horizontal ellipsis
  134: 8224, # dagger
  135: 8225, # double dagger
  136:  710, # modifier letter circumflex accent
  137: 8240, # per mille sign
  138:  352, # latin capital letter s with caron
  139: 8249, # single left-pointing angle quotation mark
  140:  338, # latin capital ligature oe
  142:  381, # latin capital letter z with caron
  145: 8216, # left single quotation mark
  146: 8217, # right single quotation mark
  147: 8220, # left double quotation mark
  148: 8221, # right double quotation mark
  149: 8226, # bullet
  150: 8211, # en dash
  151: 8212, # em dash
  152:  732, # small tilde
  153: 8482, # trade mark sign
  154:  353, # latin small letter s with caron
  155: 8250, # single right-pointing angle quotation mark
  156:  339, # latin small ligature oe
  158:  382, # latin small letter z with caron
  159:  376} # latin capital letter y with diaeresis

#########################################################################
#	  Permit only selected HTML constructs, escape the rest		#
#########################################################################

def sanitize(body):
  if not body: return body
  original = body

  def hyperlink(match):
    href=re.sub("&","&",match.group(1))
    return '<a rel="nofollow" href="%s">%s</a>' % (href, match.group(2))

  # code (literal) support
  chunks=re.split('{{{((?:.|\n)*?)}}}',body)
  if len(chunks)>1:
    work=chunks[:]
    for i in range(1,len(chunks),2):
      if chunks[i].find('\n')>=0:
        chunks[i] = '<pre class="code">' + escape(chunks[i].strip()) + '</pre>'
        work[i]="\n\n{{{%d}}}\n\n" % i
      else:
        chunks[i] = '<code>' + escape(chunks[i]) + '</code>'
        work[i]="{{{%d}}}" % i
    body=''.join(work)
  else:
    # naked urls become hypertext links
    body=re.sub('(^|[\\s.:;?\\-\\]<\\(])' + 
                '(http://[-\\w;/?:@&=+$.!~*\'()%,#]+[\\w/])' +
                '(?=$|[\\s.:;?\\-\\[\\]>\\)])',
                '\\1<a href="\\2">[link]</a>',body)

  # html characters used in text become escaped
  body=escape(body)

  # canonicalize line control characters
  body=re.sub('\r\n?','\n', body.strip())

  # support NCR characters 
  body=re.sub('&amp;#x([\da-zA-Z]+);', lambda n: "&#x%s;" % n.group(1), body)
  body=re.sub('&amp;#(\d+);', lambda n: "&#%s;" % n.group(1), body)

  # map windows-1252 to unicode
  for i in range(len(body)-1,-1,-1):
    if ord(body[i]) in cp1252:
      body=body[0:i] + "&#" + str(cp1252[ord(body[i])]) + ";" + body[i+1:]

  # remove control characters
  body=re.compile("[\x01-\x08\x0B\x0C\x0E-\x1F]"). \
    sub(lambda c: u'<acronym title="U+%s">&#xFFFD;</acronym>' %
    hex(ord(c.group(0)))[2:].rjust(4,'0').upper(),body)

  # passthru <a href>, <em>, <i>, <b>, <blockquote>, <br/>, <p>
  body=re.sub('&lt;a href="([^"]*)"&gt;([^&]*)&lt;/a&gt;',
              hyperlink, body)
  body=re.sub('&lt;a href=\'([^\']*)\'&gt;([^&]*)&lt;/a&gt;',
              hyperlink, body)
  body=re.sub('&lt;abbr title="([^"]*)"&gt;([^&]*)&lt;/abbr&gt;',
              '<abbr title="\\1">\\2</abbr>', body)
  body=re.sub('&lt;acronym title="([^"]*)"&gt;([^&]*)&lt;/acronym&gt;',
              '<acronym title="\\1">\\2</acronym>', body)
  body=re.sub('&lt;em&gt;([^&]*)&lt;/em&gt;', '<em>\\1</em>', body)
  body=re.sub('&lt;i&gt;([^&]*)&lt;/i&gt;', '<i>\\1</i>', body)
  body=re.sub('&lt;b&gt;([^&]*)&lt;/b&gt;', '<b>\\1</b>', body)
  body=re.sub('&lt;strong&gt;([^&]*)&lt;/strong&gt;', '<strong>\\1</strong>', body)
  body=re.sub('&lt;blockquote&gt;([^~]*?)&lt;/blockquote&gt;', 
              '\n\n<blockquote><p>\\1</p></blockquote>\n\n', body)
  body=re.sub('&lt;br\s*/?&gt;\n?','\n',body)
  body=re.sub('&lt;/?p&gt;','\n\n',body).strip()

  # typographic support for mdash, curly quotes
  body=re.sub(r'(\s)--(\s)', r'\1&mdash;\2', body)
  body=re.sub(r'(\w)\'(\w)', r'\1&#8217;\2', body)
  body=re.sub(r"(^|\s)'([^<]*?)'(\s|[,;.\]]|$)", r'\1&lsquo;\2&rsquo;\3', body)
  body=re.sub(r'(^|\s)"([^<]*?)"(\s|[,;.\]]|$)', r'\1&ldquo;\2&rdquo;\3', body)

  # wiki like support: _em_, -del-, *b*, [url title]
  body=re.sub(r'\b_(\w.*?)_\b', r'<em>\1</em>', body)
  body=re.sub(r'\*(\w.*?\w)\*', r'<b>\1</b>', body)
  body=re.sub(r'\[(\w+:\S+\.gif) (.*?)\]', r'<img src="\1" alt="\2" />', body)
  body=re.sub(r'\[(\w+:\S+\.jpg) (.*?)\]', r'<img src="\1" alt="\2" />', body)
  body=re.sub(r'\[(\w+:\S+\.png) (.*?)\]', r'<img src="\1" alt="\2" />', body)
  body=re.sub(r'\[(\w+:\S+) (.*?)\]', hyperlink, body).strip()

  # cvs urls
  body=re.sub(r'/<b>checkout</b>/', r'/*checkout*/', body)
  body=re.sub(r'/<em>checkout</em>/', r'/_checkout_/', body)

  # email style quotes (lines beginning with '>')
  body=re.sub('^&gt;(.*)\n\n+&gt;', r'&gt;\1\n&gt;\n&gt;', body)
  quotes=re.compile(r'^( *&gt;.*(?:\n *&gt;.*)*)',re.M).split(body)
  for i in range(1, len(quotes), 2):
    (html,depth)=('',0)
    qline=re.compile('^ *(&gt;(?: |&gt;)*)(.*)',re.M);
    for indent,line in qline.findall(quotes[i])+[('','')]:
      indent=len(indent.replace(' ','').replace('&gt;','>'))
      while indent>depth: 
        (depth,html)=(depth+1,html+'<blockquote class="quote"><p>')
      while indent<depth: (depth,html)=(depth-1,html+'</p></blockquote>')
      html+=line+"\r"
    quotes[i]=html.strip()
  body=''.join(quotes)

  # unordered lists: consecutive lines starting with spaces and an asterisk
  lists=re.compile(r'^( *\*.*(?:\n *\*.*)*)\n*',re.M).split(body)
  for i in range(1, len(lists), 2):
    (html,stack)=('', [''])
    for indent,line in re.findall(r'( +)\* +(.*)', lists[i]) + [('','')]:
      if indent>stack[-1]: (stack,html)=(stack+[indent],html+'\n<ul>\r')
      while indent<stack[-1]: (stack,html)=(stack[:-1],html+'</ul>\r')
      if line: html += '<li>'+line+'</li>\r'
    lists[i]=html+"\n\n"
  body = ''.join(lists)

  # white space
  stanzas=re.split('\n\n+', body.strip())
  if len(stanzas)>1:
    for i in range(0,len(stanzas)):
      if not stanzas[i].startswith('<ul>') and \
        not stanzas[i].startswith('<blockquote'):
        stanzas[i] = '<p>%s</p>' % stanzas[i]
    body = '\r'.join(stanzas)
  body=re.sub('\n</p>','</p>', body)
  body=re.sub('\n','<br />\n', body)
  body=re.compile('<p>(<ul>.*?</ul>)</p>?',re.M).sub(r'\1',body)
  body=re.sub('  +', '&nbsp; ', body)

  # reinsert literals
  if len(chunks)>1:
    for i in range(1,len(chunks),2):
      body=re.sub("<p>\{\{\{%d\}\}\}</p>" % i, chunks[i].replace('\\','\\\\'),
        body)
      body=body.replace("{{{%d}}}" % i, chunks[i])

  # renormalize linefeeds
  body=re.sub('\r\n*', '\n', body).strip()

  from atomize import html2xml
  body = html2xml(body)

  try:
    from xml.dom import minidom
    if type(body) == unicode:
      minidom.parseString("<div>%s</div>" % body.encode('utf-8'))
    else:
      minidom.parseString("<div>%s</div>" % body)
  except:
    body = escape(original).replace('\n','<br />')

  return body

#########################################################################
#	     Determine if this entry has already been found		#
#########################################################################

def existingBacklink(entry,link):
  link=xmlchars(link)
  for filename in glob('%s%s-*.cmt' % (directory.data,entry)):
    file = open(filename)
    try:
      for line in file: 
        if line.find(link)>0: return True
    finally:
      file.close()
  return False

#########################################################################
#		  Determine if a comment is a duplicate			#
#########################################################################

def duplicateComment(entry,title,body):
  (title,body)=(xmlchars(title),xmlchars(body))
  for filename in glob('%s%s-*.cmt' % (directory.data,entry)):
    file = open(filename)
    try:
      if file.readline().strip()==title and file.read()==body: return True
    finally:
      file.close()
  return False

#########################################################################
#		       Write a comment out to disk			#
#########################################################################

def writeComment(entry,title,body,decache=True):

  # Throttle comments from any one individual
  import spamthrottle
  if spamthrottle.spammer(body):
    message="POST limit exceeded"
    nonce.generate(time.time()+86400, repr([message, entry, title, body]))
    raise Exception(message)

  if not title: title=open(directory.data+entry+'.txt').readline().strip()

  cmtid = time.mktime(time.gmtime())
  while (os.path.exists('%s%s-%d.cmt' % (directory.data,entry,cmtid))): cmtid+=1

  file='%s%s-%d.cmt' % (directory.data,entry,cmtid)
  out=open(file, 'w')
  out.write("%s\n%s" % (xmlchars(title), xmlchars(body)))
  out.close()
  os.chmod(file, 0664)

  if decache:
    cache.clear(entry)
    notify(file)

  return file

def notify(file):
  try:
    import xnotify
    xnotify.send(os.path.basename(file))
  except:
    import traceback, nonce, time
    tb = ''.join(apply(traceback.format_exception, sys.exc_info()))
    nonce.generate(time.time()+86400, tb)

#########################################################################
#                 Decache and index in the background                   #
#########################################################################
def cleanup(posted):
  import daemonize, fcntl, search

  # complete the http request
  log=open(directory.web+"post.log","w")
  daemonize.daemonize(stdout=log.name)

  for file, entry in posted:
    cache.clear(entry)
    notify(file)

  fcntl.flock(log.fileno(),fcntl.LOCK_EX)
  search.index()
  fcntl.flock(log.fileno(),fcntl.LOCK_UN)

  log.close()

#########################################################################
#		   Handle both Trackbacks and Comments			#
#########################################################################

def post(url=None):
  posted=[]

  name = escape(param('name') or param('blog_name') or 'anonymous')
  addr = param('url')
  email = param('email')
  title = sanitize(unescape(param('title')))

  body = sanitize(param('comment') or param('excerpt'));
  entry = param('parent') or param('tb_id')
  if addr:
    if addr.find(':')<0 and not addr.startswith('='):
      if addr.find('.')>=0 and url[0].isalnum():
        if not addr.find('/')>=0: url = url + '/'
        addr = "http://" + addr
  if url.endswith('.tb'): entry=url.split('.')[0]

  host=os.environ['REMOTE_ADDR']

  match = re.search(r' domain name pointer (\S+)\.\s*$',
          commands.getoutput('host ' + host))
  if match: host=match.group(1)
  host=escape(host)

  moderate = False

  preview = param('preview')
  if param('nonce') and nonce.unique(param('nonce'), time.time()+86400, body):
    preview = moderate = 1

  if param('comment'):
    from spamthrottle import captcha_valid
    if not param('captcha'):
      preview = 1
    elif not captcha_valid(param('captcha')):
      preview = moderate = 1

  # wierd spammers 
  if name == 'ninki': preview = moderate = 1
  # if body.find('http://maxi')>=0: preview = moderate = 1
  # if body.find('http://bardak.com.ru/')>=0: preview = moderate = 1
  # if body.find('http://funny-gift-idea')>=0: preview = moderate = 1
  # if body.find('http://advertisersworld.com')>=0: preview = moderate = 1
  # if body.find('ugly.as/')>=0: preview = moderate = 1
  if title.startswith('&lt;a href="'): preview = moderate = 1
  if param('excerpt'):
    try:
      if open(directory.data+entry+'.txt').readline().strip().startswith(body.strip('.')):
        preview = moderate = 1
      if name == 'anonymous':
        preview = moderate = 1
    except:
      preview = moderate = 1
    
  if not moderate:
    import community
    moderate = not community.find(host, addr)
    if not moderate:
      body = body.replace('<a rel="nofollow" ',"<a ")
      nofollow=""
    else:
      nofollow=' rel="nofollow"'

  if preview:

    from config import channel
    from template.comment import comment as template
    from spamthrottle import warn
    from atomize import html2xml
    title=xmlchars(title)
    if moderate:
      body=html2xml(body)
    else:
      from spellcheck import spellcheck
      body=html2xml(spellcheck(body))
    comment=param('comment')
    comment=re.compile("[\x01-\x08\x0B\x0C\x0E-\x1F]"). \
      sub(lambda c: u'<acronym title="U+%s">\ufffd</acronym>' %
      hex(ord(c.group(0)))[2:].rjust(4,'0').title(),comment)
    if moderate:
      warning = ['moderate']
    else:
      warning = warn(entry, host, addr, comment)
    if param('warn'): warning += param('warn').split()

    # spamlog = open(directory.spamlog + host,'w')
    # spamlog.write(str(warning))
    # spamlog.close()

    from entry import post
    parent={'title':title, 'description':body, 'comment':comment,
            'entry':entry, 'link':post(entry).link(), 'id':'',
            'mtime':time.localtime(), 'warning':warning, 'host':host,
            'name':name, 'url':addr, 'email':email}
    data={'channel':channel, 'Items':[], 'children':[], 'parent':parent, 'age':0}

    from config import service, __dict__ as config
    print template(searchList=[data, config])

    if param('nonce') and not nonce.unique(param('nonce')):
      nonce.remove(param('nonce'))

  elif (body or param('blog_name')) and entry:

    message = None
  
    # address tweaks: handle omitted http, default to email if present
    addr = re.sub('^(\\w+(\\.\\w+)+)', 'http://\\1', addr)
    if "http://".startswith(addr): addr=""
    if email and not addr: addr='mailto:'+email
  
    # add who the post was from, possibly annotated with IP info
    if param('comment'):
      body = re.sub(r'\s+$','',body)
      if body[-4:] <> '</p>': body += '\n<br />\n<br />'
      body += "\nPosted by"

      # Verify nonce
      if param('nonce') and not nonce.unique(param('nonce')):
        nonce.remove(param('nonce'))
      else:
        message="Invalid nonce"

    else:
      body=re.sub('&amp;(#?\w+;)','&\\1',body)

      # if len(body)>252: body=body[:body.rfind(' ',0,252)][:252]
      body += "...\n"
      if addr: body += "<a href=\"%s\">[more]</a>" % escape(addr)
      body += "<br /><br />Trackback from"
  
      try:
        from urllib import urlopen
        urlopen(addr).read().index('intertwingly')
      except:
        message = 'spam'

      # if blogname is a URL, set it as the address
      addr = None
      if re.match('^\w+\\.[\w\\.]+$',name): addr = "http://%s/" % name
      if re.match('^http://',name): addr=name
  
    if duplicateComment(entry, title, body):
      message = 'Duplicate comment'

    name = xmlchars(name)

    # openid?
    redirect = None
    if addr and param('comment'):
      import identity
      redirect=identity.lookup(addr,
        {'name': param('name'), 'url': param('url'), 'email': param('email'),
         'title': param('title'), 'comment': param('comment'), 'parent': entry})

    if redirect:
      print 'Status: 302 Found\r\nLocation: %s\r\n\r\nRedirecting' % redirect
    else:
      # add who the post was from, possibly annotated with link info
      if addr:
        id = "<a%s href=\"%s\" title=\"%s\">%s</a>" % (nofollow, escape(addr), host, name)
      else:
        id = "<a title=\"%s\">%s</a>" % (host, name)
      body += " " + id
   
      # do the post
      if not message:
        file = writeComment(entry, title, body, decache=False)
        from entry import post
        from config import channel
        link = post(entry).link()
        redirect = channel.link + link + '?#c%d' % os.stat(file).st_mtime
        if os.path.exists(os.path.join(directory.cache,link)):
          os.remove(os.path.join(directory.cache,link))
        posted.append((file, entry))

      # produce response
      if param('comment') and not message:
        if redirect:
          print 'Status: 302 Found\r\nLocation: %s\r\n\r\nRedirecting'%redirect
        else:
          from entry import post
          from get import format
          response=format(post(entry).link())
          print response
          cache.save('index.html', response)
      else:
        from template.tb import tb as template
        print template(searchList=[{'error':0,'message':message}])

  elif entry and re.search(r'\bxml\b', fs.type):
    # from soap import soap
    # soap(entry, fs.file)

    from config import channel
    try:

      from entryparser import parse
      comment=parse(fs.file)
      comment['url'] = comment['link']

      if 'doPreview' in comment:
        from spellcheck import spellcheck
        comment['content']=spellcheck(str(comment['content']))
        comment['link'] = '%s.html#commentForm' % entry
        filename=directory.data+entry+'.txt'
      else:
        name=escape(str(comment['name']))
  
        # add who the post was from, possibly annotated with link info
        if 'link' in comment:
          id = ("<a href=\"%s\" title=\"%s\">%s</a>" % 
            (escape(str(comment['link'])), host, name))
        else:
          id = "<a title=\"%s\">%s</a>" % (host, name)
        comment['content'] += "<p/>Message from %s" % id

        filename = writeComment(entry, escape(str(comment['title'])), 
          str(comment['content']), decache=False)
        posted.append((filename, entry))
        mtime=int(os.stat(filename).st_mtime)
        comment['modified']=time.localtime(mtime)
        comment['link'] = '%s.html#c%d' % (entry,mtime)

      if not comment['title']:
         comment['title']=open(filename).readline().strip()

      # reply
      from template.atomapi import atomapi as reply
      print reply(searchList=[{'channel': channel, 'entry':comment}])
  
    except:
      import traceback
      tb = ''.join(apply(traceback.format_exception, sys.exc_info()))

      nonce.generate(time.time()+86400, tb)
  
      from template.soapfault import soapfault as reply
      print reply(searchList=[])

  else:

    data=''
    if fs.file:
      data += "===\n" + fs.file.read() + "\n" + "===\n" + "\n"

    data += "fstype: " + fs.type + "\n"
    data += "fshead: " + str(fs.headers) + "\n"

    try:
      for key in fs.keys():
        data += key + ": " +  fs.getvalue(key) + "\n"
    except:
      pass

    for (key,value) in  os.environ.items():
      data += key + ": " +  value + "\n"

    nonce.generate(time.time()+86400, data)

    print "Content-type: text/plain\r\n\r\n"

  if posted: cleanup(posted)