from htmlentitydefs import name2codepoint as n2cp

from htmlentitydefs import codepoint2name as cp2n

import re

####

# Module header

##

webhelpers_helpers = ['regex_url',

                      'regex_ahref',

                      'rewrite_url',

                      'substitiute_from_entity',

                      'substitiute_to_entity',

                      'unquotestring',

                      'quotestring',

                      'shorten_url',

                      'expand_url',

                      'convert_to_irc_string',

                      'convert_to_twitter_string']

do_modurl_command = { 'description': "Modify URL's",

                      'arguments': [("expand <url> [<url2> [..]]", "Expand a short url to a long url."),

                                    ("compress <url> [<url2> [..]]", "Compress a long url into a short url.")],

                      'public': True,

                      'level': 0}

webhelpers_alias = {'curl': 'modurl compress',

                    'eurl': 'modurl expand'}

def do_modurl(bot, server, sender, target, args):

    if args:

        if args[0] == "compress":

            do_compress_url(bot, server, sender, target, args[1:])

        elif args[0] == "expand":

            do_expand_url(bot, server, sender, target, args[1:])

        else:

            bot.respond(server, sender, target, "\x02'%s'\x02 is not a valid argument." % args[0])

    else:

        bot.respond(server, sender, target, "Not enough arguments.")

##

# End of module header

####

# Regexp for recognising URLs

regex_url = r'http:\/\/([\w.]+\/?)\S*'

# Regexp for recognising html hyperlinks such as <a href="linkurl">Linkname</a>

regex_ahref = r'<a .*?href=[\'"](.*?)[\'"].*>(.*?)</a>'

def do_compress_url(bot, server, sender, target, args):

    """This is another of the commands and all it does is take a url and return a short

       version of it."""

    if args:

        for url in args:

            if re.match(bot.regex_url, url):

                surl = shorten_url(url)

                print " + Shortening url '%s' to '%s'." % (url, surl)

                bot.respond(server, sender, target, "Short url is: %s" % surl)

            else:

                bot.respond(server, sender, target, "Could not shorten: %s" % url)

    else:

        bot.respond(server, sender, target, "Not enough arguments.")

def do_expand_url(bot, server, sender, target, args):

    """This is another of the commands and all it does is take a url and return a short

       version of it."""

    if args:

        for url in args:

            if re.match(bot.regex_url, url):

                lurl = expand_url(url)

                print " + Expanding url '%s' to '%s'." % (url, lurl)

                bot.respond(server, sender, target, "Long url is: %s" % lurl)

            else:

                bot.respond(server, sender, target, "Could not expand: %s" % url)

    else:

        bot.respond(server, sender, target, "Not enough arguments.")

def rewrite_url(match):

    """ [Internal] Rewrite html link to irc version. """

    url = match.group(1)

    name = match.group(2)

    if re.match(regex_url, name) or name == url:

        return url

    else:

        return "%s [%s]" % (name, url)

def substitiute_from_entity(match):

    """ [Internal] Substitiue all html-entities to real characters."""

    ent = match.group(2)

    if match.group(1) == '#':

        return unichr(int(ent))

    else:

        cp = n2cp.get(ent)

        if cp:

            return unichr(cp)

        else:

            return match.group()

def substitiute_to_entity(match):

    """ [Internal] Substitute special characters to html-entities."""

    code = ord(match.group(1))

    n = cp2n.get(code)

    if n:

        return "&%s;" % n

    else:

        return unichr(code)

def unquotestring(string):

    """ [Internal] Make html string into real string."""

    return re.sub(r'&(#?)(\d{1,5}|\w{1,8});', substitiute_from_entity, string)

def quotestring(string):

    """ [Internal] Make real string into html string."""

    return re.sub(r'([^a-zA-Z0-9,. !@])', substitiute_to_entity, string)

def convert_to_irc_string(string):

    """ [Internal] Format the string for posting in IRC."""

    try:

        return unquotestring(string).encode("utf-8")

    except Exception, e:

        print "Convert to irc string:", e

        return string

def convert_to_twitter_string(string):

    """ [Internal] Format the string for posting to twitter."""

    try:

        return quotestring(string)

    except Exception, e:

        print "Convert to twitter string:", e

        return string

### Cache of earlier shortened or expanded url's. ###

### { short_url: long_url }

url_cache = {}

def shorten_url(url):

    """ [Internal] Use is.gd to convert a link to a short version."""

    for key, value in url_cache.iteritems():

        if value == url:

            return key

    try:

        import urllib

        apiurl = "http://is.gd/api.php?longurl="

        tinyurl = urllib.urlopen(apiurl+url).read()

        url_cache[tinyurl] = url

    except:

        return url

    return tinyurl

def expand_url(url):

    """ [Internal] Expand a url in short format."""

    if url in url_cache:

        return url_cache[url]

    try:

        import urllib

        apiurl = "http://api.longurl.org/v2/expand?url="

        longurl_respons = urllib.urlopen(apiurl+url).read()

    except:

        return url

    ### longurl_respons is formated as such:                        ###

    ### <?xml version="1.0"?>                                       ###

    ###   <response>                                                ###

    ###     <long-url><![CDATA[http://www.google.com/]]></long-url> ###

    ###   </response>                                               ###

    res = re.search('<!\[CDATA\[(.*)\]\]>', longurl_respons, re.M)

    if res:

        longurl = res.group(1)

        if not url == longurl:

            url_cache[url] = longurl

        return longurl

    else:

        return url