#!/usr/bin/python
# -*- coding: utf-8 -*-

# Libervia: a Salut à Toi frontend
# Copyright (C) 2011, 2012, 2013, 2014 Jérôme Poisson <goffi@goffi.org>

# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero 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 Affero General Public License for more details.

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

from pyjamas.ui.DragWidget import DragWidget
from pyjamas.ui.FileUpload import FileUpload
from pyjamas import Window
from nativedom import NativeDOM
from sat_frontends.tools import xmltools
import re

dom = NativeDOM()


def html_sanitize(html):
    """Naive sanitization of HTML"""
    return html.replace('<', '&lt;').replace('>', '&gt;')


def html_clean(html):
    """
    Remove HTML markup from the given string.
    Copied from nltk.clean_html (http://www.nltk.org/)

    @param html: the HTML string to be cleaned
    @type html: C{string}
    @rtype: C{string}
    """

    # First we remove inline JavaScript/CSS:
    cleaned = re.sub(r"(?is)<(script|style).*?>.*?(</\1>)", "", html.strip())
    # Then we remove html comments. This has to be done before removing regular
    # tags since comments can contain '>' characters.
    cleaned = re.sub(r"(?s)<!--(.*?)-->[\n]?", "", cleaned)
    # Next we can remove the remaining tags:
    cleaned = re.sub(r"(?s)<.*?>", " ", cleaned)
    # Finally, we deal with whitespace
    cleaned = re.sub(r"&nbsp;", " ", cleaned)
    cleaned = re.sub(r"  ", " ", cleaned)
    cleaned = re.sub(r"  ", " ", cleaned)
    return cleaned.strip()


def html_strip(html):
    """Strip leading/trailing white spaces, HTML line breaks and &nbsp; sequences."""
    cleaned = re.sub(r"^(<br/?>|&nbsp;|\s)+", "", html)
    cleaned = re.sub(r"(<br/?>|&nbsp;|\s)+$", "", cleaned)
    return cleaned


def inlineRoot(xhtml):
    """ make root element inline """
    doc = dom.parseString(xhtml)
    return xmltools.inlineRoot(doc)


def setPresenceStyle(item, state, base_style="contact"):
    """
    @item: any UI element
    @state: a value from ("", "chat", "away", "dnd", "xa")
    """
    if not hasattr(item, 'presence_style'):
        item.presence_style = None
    style = '%s-%s' % (base_style, state or 'connected')
    if style == item.presence_style:
        return
    if item.presence_style is not None:
        item.removeStyleName(item.presence_style)
    item.addStyleName(style)
    item.presence_style = style


class DragLabel(DragWidget):

    def __init__(self, text, _type):
        DragWidget.__init__(self)
        self._text = text
        self._type = _type

    def onDragStart(self, event):
        dt = event.dataTransfer
        dt.setData('text/plain', "%s\n%s" % (self._text, self._type))
        dt.setDragImage(self.getElement(), 15, 15)


class LiberviaDragWidget(DragLabel):
    """ A DragLabel which keep the widget being dragged as class value """
    current = None  # widget currently dragged

    def __init__(self, text, _type, widget):
        DragLabel.__init__(self, text, _type)
        self.widget = widget

    def onDragStart(self, event):
        LiberviaDragWidget.current = self.widget
        DragLabel.onDragStart(self, event)

    def onDragEnd(self, event):
        LiberviaDragWidget.current = None


class FilterFileUpload(FileUpload):

    def __init__(self, name, max_size, types=None):
        """
        @param name: the input element name
        @param max_size: maximum file size in MB
        @param types: allowed types as a list of couples (x, y, z):
        - x: MIME content type e.g. "audio/ogg"
        - y: file extension e.g. "*.ogg"
        - z: description for the user e.g. "Ogg Vorbis Audio"
        If types is None, all file format are accepted
        """
        FileUpload.__init__(self)
        self.setName(name)
        from pyjamas import DOM
        while DOM.getElementById(name):
            name = "%s_" % name
        self.setID(name)
        self._id = name
        self.max_size = max_size
        self.types = types

    def getFileInfo(self):
        from __pyjamas__ import JS
        JS("var file = top.document.getElementById(this._id).files[0]; return [file.size, file.type]")

    def check(self):
        if self.getFilename() == "":
            return False
        (size, filetype) = self.getFileInfo()
        if self.types and filetype not in [x for (x, y, z) in self.types]:
            types = ["- %s (%s)" % (z, y) for (x, y, z) in self.types]
            Window.alert('This file type is not accepted.\nAccepted file types are:\n\n%s' % "\n".join(types))
            return False
        if size > self.max_size * pow(2, 20):
            Window.alert('This file is too big!\nMaximum file size: %d MB.' % self.max_size)
            return False
        return True