####################################################################################################
def NormalizeURL(url):

	if '/embed-' in url:
		url = url.replace('/embed-', '/')
		url = url.split('-')[0]

	return url

####################################################################################################
def MetadataObjectForURL(url):

	try:
		html = HTML.ElementFromURL(url)
	except:
		raise Ex.MediaNotAvailable

	if len(html.xpath('//*[contains(., "deleted")]')) > 0:
		raise Ex.MediaNotAvailable

	title = html.xpath('//h2[@class="video-title"]/text()')

	if len(title) < 1:
		raise Ex.MediaNotAvailable

	title = title[0].strip()
	thumb = html.xpath('//span[@id="vplayer"]/img/@src')[0]

	return VideoClipObject(
		title = title,
		thumb = thumb
	)

####################################################################################################
def MediaObjectsForURL(url):
	return [
		MediaObject(
			video_resolution = 'sd',
			audio_channels = 2,
			optimized_for_streaming = False,
			parts = [
				PartObject(key=Callback(PlayVideo, url=url))
			]
		)
	]

####################################################################################################
@indirect
def PlayVideo(url, **kwargs):

	page = HTTP.Request(url).content
	data = Regex("<script type=.text\/javascript.>(eval\(function\(p,a,c,k,e,.+\.split\('\|'\)\)\))").search(page)

	if data:

		data = unpack(data.group(1))
		file = Regex('file:"([^"]+\.mp4)"').search(data).group(1)
		Log.Debug('Play file: ' + file)
		if file:
			return IndirectResponse(VideoClipObject, key=file)

	raise Ex.MediaNotAvailable


####################################################################################################
####################################################################################################
"""
    urlresolver XBMC Addon
    Copyright (C) 2013 Bstrdsmkr

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Adapted for use in xbmc from:
    https://github.com/einars/js-beautify/blob/master/python/jsbeautifier/unpackers/packer.py

Unpacker for Dean Edward's p.a.c.k.e.r
"""

def unpack(source):
    """Unpacks P.A.C.K.E.R. packed js code."""
    payload, symtab, radix, count = filterargs(source)

    if count != len(symtab):
        raise UnpackingError('Malformed p.a.c.k.e.r. symtab.')

    try:
        unbase = Unbaser(radix)
    except TypeError:
        raise UnpackingError('Unknown p.a.c.k.e.r. encoding.')

    def lookup(match):
        """Look up symbols in the synthetic symtab."""
        word  = match.group(0)
        return symtab[unbase(word)] or word

    source = Regex(r'\b\w+\b').sub(lookup, payload)
    return replacestrings(source)

def filterargs(source):
    """Juice from a source file the four args needed by decoder."""
    argsregex = (r"}\('(.*)', *(\d+), *(\d+), *'(.*?)'\.split\('\|'\)")
    args = Regex(argsregex).search(source, Regex.DOTALL).groups()

    try:
        return args[0], args[3].split('|'), int(args[1]), int(args[2])
    except ValueError:
        raise UnpackingError('Corrupted p.a.c.k.e.r. data.')

def replacestrings(source):
    """Strip string lookup table (list) and replace values in source."""
    match = Regex(r'var *(_\w+)\=\["(.*?)"\];').search(source, Regex.DOTALL)

    if match:
        varname, strings = match.groups()
        startpoint = len(match.group(0))
        lookup = strings.split('","')
        variable = '%s[%%d]' % varname
        for index, value in enumerate(lookup):
            source = source.replace(variable % index, '"%s"' % value)
        return source[startpoint:]
    return source

class Unbaser(object):
    """Functor for a given base. Will efficiently convert
    strings to natural numbers."""
    ALPHABET  = {
        64 : '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+/',
        95 : (' !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ'
              '[\]^_`abcdefghijklmnopqrstuvwxyz{|}~')
    }

    def __init__(self, base):
        self.base = base

        # If base can be handled by int() builtin, let it do it for us
        if 2 <= base <= 36:
            self.unbase = lambda string: int(string, base)
        else:
            # Build conversion dictionary cache
            try:
                self.dictionary = dict((cipher, index) for
                    index, cipher in enumerate(self.ALPHABET[base]))
            except KeyError:
                try:
                    self.dictionary = dict((cipher, index) for
                        index, cipher in enumerate(self.ALPHABET[64][:base]))
                except KeyError:
                    raise TypeError('Unsupported base encoding.')

            self.unbase = self.dictunbaser

    def __call__(self, string):
        return self.unbase(string)

    def dictunbaser(self, string):
        """Decodes a  value to an integer."""
        ret = 0
        for index, cipher in enumerate(string[::-1]):
            ret += (self.base ** index) * self.dictionary[cipher]
        return ret

class UnpackingError(Exception):
    """Badly packed source or general error. Argument is a
    meaningful description."""
    pass