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

# Libervia: a Salut à Toi frontend
# Copyright (C) 2013-2016 Adrien Cossa <souliane@mailoo.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 sat.core.log import getLogger
log = getLogger(__name__)
from sat.core.i18n import _

from pyjamas.ui.ClickListener import ClickHandler
from pyjamas.ui.FocusListener import FocusHandler
from pyjamas.ui.ChangeListener import ChangeHandler
from pyjamas.ui.DragHandler import DragHandler
from pyjamas.ui.KeyboardListener import KeyboardHandler, KEY_ENTER
from pyjamas.ui.DragWidget import DragWidget
from pyjamas.ui.ListBox import ListBox
from pyjamas.ui.Button import Button
from pyjamas.ui.FlowPanel import FlowPanel
from pyjamas.ui.HorizontalPanel import HorizontalPanel
from pyjamas.ui.FlexTable import FlexTable
from pyjamas.ui.AutoComplete import AutoCompleteTextBox

import base_panel
import base_widget
import libervia_widget

from sat_frontends.quick_frontend import quick_list_manager


unicode = str  # FIXME: pyjamas workaround


class ListItem(HorizontalPanel):
    """This class implements a list item with auto-completion and a delete button."""

    STYLE = {"listItem": "listItem",
             "listItem-box": "listItem-box",
             "listItem-box-invalid": "listItem-box-invalid",
             "listItem-button": "listItem-button",
             }

    VALID = 1
    INVALID = 2
    DUPLICATE = 3

    def __init__(self, listener=None, taglist=None, validate=None):
        """

        @param listener (ListItemHandler): handler for the UI events
        @param taglist (quick_list_manager.QuickTagList): list manager
        @param validate (callable): method returning a bool to validate the entry
        """
        HorizontalPanel.__init__(self)
        self.addStyleName(self.STYLE["listItem"])

        self.box = AutoCompleteTextBox(StyleName=self.STYLE["listItem-box"])
        self.remove_btn = Button('<span>x</span>', Visible=False)
        self.remove_btn.setStyleName(self.STYLE["listItem-button"])
        self.add(self.box)
        self.add(self.remove_btn)

        if listener:
            self.box.addFocusListener(listener)
            self.box.addChangeListener(listener)
            self.box.addKeyboardListener(listener)
            self.box.choices.addClickListener(listener)
            self.remove_btn.addClickListener(listener)

        self.taglist = taglist
        self.validate = validate
        self.last_checked_value = ""
        self.last_validity = self.VALID

    @property
    def text(self):
        return self.box.getText()

    def setText(self, text):
        """
        Set the text and refresh the Widget.
        
        @param text (unicode): text to set
        """
        self.box.setText(text)
        self.refresh()

    def refresh(self):
        if self.last_checked_value == self.text:
            return

        if self.taglist and self.last_checked_value:
            self.taglist.untag([self.last_checked_value])

        if self.validate:  # if None, the state is always valid
            self.last_validity = self.validate(self.text)

        if self.last_validity == self.VALID:
            self.box.removeStyleName(self.STYLE["listItem-box-invalid"])
            self.box.setVisibleLength(max(len(self.text), 10))
        elif self.last_validity == self.INVALID:
            self.box.addStyleName(self.STYLE["listItem-box-invalid"])
        elif self.last_validity == self.DUPLICATE:
            self.remove_btn.click()  # this may do more stuff then self.remove()
            return
        
        if self.taglist and self.text:
            self.taglist.tag([self.text])
        self.last_checked_value = self.text
        self.box.setSelectionRange(len(self.text), 0)  
        self.remove_btn.setVisible(len(self.text) > 0)
                     
    def setFocus(self, focused):
        self.box.setFocus(focused)

    def remove(self):
        """Remove the list item from its parent."""
        self.removeFromParent()

        if self.taglist and self.text:  # this must be done after the widget has been removed
            self.taglist.untag([self.text])


class DraggableListItem(ListItem, DragWidget):
    """This class is like ListItem, but in addition it can be dragged."""

    def __init__(self, listener=None, taglist=None, validate=None):
        """
    
        @param listener (ListItemHandler): handler for the UI events
        @param taglist (quick_list_manager.QuickTagList): list manager
        @param validate (callable): method returning a bool to validate the entry
        """
        ListItem.__init__(self, listener, taglist, validate)
        DragWidget.__init__(self)
        self.addDragListener(listener)


    def onDragStart(self, event):
        """The user starts dragging the item."""
        dt = event.dataTransfer
        dt.setData('text/plain', "%s\n%s" % (self.text, "CONTACT_TEXTBOX"))
        dt.setDragImage(self.box.getElement(), 15, 15)


class ListItemHandler(ClickHandler, FocusHandler, KeyboardHandler, ChangeHandler):
    """Implements basic handlers for the ListItem events."""

    last_item = None  # the last item is an empty text box for user input

    def __init__(self, taglist):
        """
        
        @param taglist (quick_list_manager.QuickTagList): list manager
        """
        ClickHandler.__init__(self)
        FocusHandler.__init__(self)
        ChangeHandler.__init__(self)
        KeyboardHandler.__init__(self)
        self.taglist = taglist

    def addItem(self, item):
        raise NotImplementedError

    def removeItem(self, item):
        raise NotImplementedError

    def onClick(self, sender):
        """The remove button or a suggested completion item has been clicked."""
        #log.debug("onClick sender type: %s" % type(sender))
        if isinstance(sender, Button):
            item = sender.getParent()
            self.removeItem(item)
        elif isinstance(sender, ListBox):
            # this is called after onChange when you click a suggested item, and now we get the final value
            textbox = sender._clickListeners[0]
            self.checkValue(textbox)
        else:
            raise AssertionError

    def onFocus(self, sender):
        """The text box has the focus."""
        #log.debug("onFocus sender type:  %s" % type(sender))
        assert isinstance(sender, AutoCompleteTextBox)
        sender.setCompletionItems(self.taglist.untagged)

    def onKeyUp(self, sender, keycode, modifiers):
        """The text box is being modified - or ENTER key has been pressed."""
        # this is called after onChange when you press ENTER, and now we get the final value
        #log.debug("onKeyUp sender type:  %s" % type(sender))
        assert isinstance(sender, AutoCompleteTextBox)
        if keycode == KEY_ENTER:
            self.checkValue(sender)

    def onChange(self, sender):
        """The text box has been changed by the user."""
        # this is called before the completion when you press ENTER or click a suggest item
        #log.debug("onChange sender type:  %s" % type(sender))
        assert isinstance(sender, AutoCompleteTextBox)
        self.checkValue(sender)

    def checkValue(self, textbox):
        """Internal handler to call when a new value is submitted by the user."""
        item = textbox.getParent()
        if item.text == item.last_checked_value:
            # this method has already been called (by self.onChange) and there's nothing new
            return
        item.refresh()
        if item == self.last_item and item.last_validity == ListItem.VALID and item.text:
            self.addItem()

class DraggableListItemHandler(ListItemHandler, DragHandler):
    """Implements basic handlers for the DraggableListItem events."""

    def __init__(self, manager):
        """
        
        @param manager (ListManager): list manager
        """
        ListItemHandler.__init__(self, manager)
        DragHandler.__init__(self)

    @property
    def manager(self):
        return self.taglist

    def onDragStart(self, event):
        """The user starts dragging the item."""
        self.manager.drop_target = None

    def onDragEnd(self, event):
        """The user dropped the list item."""
        text, dummy = libervia_widget.eventGetData(event)
        target = self.manager.drop_target  # self or another ListPanel
        if text == "" or target is None:
            return
        if target != self:  # move the item from self to target
            target.addItem(text)
            self.removeItem(self.getItem(text))


class ListPanel(FlowPanel, DraggableListItemHandler, libervia_widget.DropCell):
    """Implements a list of items."""
    # XXX: beware that pyjamas.ui.FlowPanel is not fully implemented:
    #     - it can not be used with pyjamas.ui.Label
    #     - FlowPanel.insert doesn't work

    STYLE = {"listPanel": "listPanel"}
    ACCEPT_NEW_ENTRY = False

    def __init__(self, manager, items=None):
        """Initialization with a button for the list name (key) and a DraggableListItem.

        @param manager (ListManager): list manager
        @param items (list): items to be set
        """
        FlowPanel.__init__(self)
        DraggableListItemHandler.__init__(self, manager)
        libervia_widget.DropCell.__init__(self, None)
        self.addStyleName(self.STYLE["listPanel"])
        self.manager = manager
        self.resetItems(items)

        # FIXME: dirty magic strings '@' and '@@'
        self.drop_keys = {"GROUP": lambda host, item_s: self.addItem("@%s" % item_s),
                          "CONTACT": lambda host, item_s: self.addItem(item_s),
                          "CONTACT_TITLE": lambda host, item_s: self.addItem('@@'),
                          "CONTACT_TEXTBOX": lambda host, item_s: setattr(self.manager, "drop_target", self),
                          }

    def onDrop(self, event):
        """Something has been dropped in this ListPanel"""
        try:
            libervia_widget.DropCell.onDrop(self, event)
        except base_widget.NoLiberviaWidgetException:
            pass
    
    def getItem(self, text):
        """Get an item from its text.
        
        @param text(unicode): item text
        """
        for child in self.getChildren():
            if child.text == text:
                return child
        return None

    def getItems(self):
        """Get the non empty items.

        @return list(unicode)
        """
        return [widget.text for widget in self.getChildren() if isinstance(widget, ListItem) and widget.text]

    def validateItem(self, text):
        """Return validation code after the item has been changed.

        @param text (unicode): item text to check
        @return: int value defined by one of these constants:
            - VALID if the item is valid
            - INVALID if the item is not valid but can be displayed
            - DUPLICATE if the item is a duplicate
        """
        def count(list_, item): # XXX: list.count in not implemented by pyjamas
            return len([elt for elt in list_ if elt == item])

        if count(self.getItems(), text) > 1:
            return ListItem.DUPLICATE  # item already exists in this list so we suggest its deletion
        if self.ACCEPT_NEW_ENTRY:
            return ListItem.VALID
        return ListItem.VALID if text in self.manager.items or not text else ListItem.INVALID

    def addItem(self, text=""):
        """Add an item.

        @param text (unicode): text to be set.
        @return: True if the item has been really added or merged.
        """
        if text in self.getItems():  # avoid duplicate in the same list
            return
        
        item = DraggableListItem(self, self.manager, self.validateItem)
        self.add(item)

        if self.last_item:
            if self.last_item.last_validity == ListItem.INVALID:
                # switch the two values so that the invalid one stays in last position
                item.setText(self.last_item.text)
                self.last_item.setText(text)
            elif not self.last_item.text:
                # copy the new value to previous empty item
                self.last_item.setText(text)
        else:  # first item of the list, or previous last item has been deleted
            item.setText(text)

        self.last_item = item
        self.last_item.setFocus(True)

    def removeItem(self, item):
        """Remove an item.
        
        @param item(DraggableListItem): item to remove
        """
        if item == self.last_item:
            self.addItem("")
        item.remove()  # this also updates the taglist

    def resetItems(self, items):
        """Reset the items.
        
        @param items (list): items to be set
        """
        for child in self.getChildren():
            child.remove()

        self.addItem()
        if not items:
            return

        items.sort()
        for item in items:
            self.addItem(unicode(item))


class ListManager(FlexTable, quick_list_manager.QuickTagList):
    """Implements a table to manage one or several lists of items."""

    STYLE = {"listManager-button": "group",
             "listManager-button-cell": "listManager-button-cell",
             }

    def __init__(self, data=None, items=None):
        """
        @param data (dict{unicode: list}): dict binding keys to tagged items.
        @param items (list): full list of items (tagged and untagged)
        """
        FlexTable.__init__(self, Width="100%")
        quick_list_manager.QuickTagList.__init__(self, [unicode(item) for item in items])
        self.lists = {}

        if data:
            for key, items in data.iteritems():
                self.addList(key, [unicode(item) for item in items])

    def addList(self, key, items=None):
        """Add a Button and ListPanel for a new list.

        @param key (unicode): list name
        @param items (list): items to append to the new list
        """
        if key in self.lists:
            return

        if items is None:
            items = []

        self.lists[key] = {"button": Button(key, Title=key, StyleName=self.STYLE["listManager-button"]),
                           "panel": ListPanel(self, items)}

        y, x = len(self.lists), 0
        self.insertRow(y)
        self.setWidget(y, x, self.lists[key]["button"])
        self.setWidget(y, x + 1, self.lists[key]["panel"])
        self.getCellFormatter().setStyleName(y, x, self.STYLE["listManager-button-cell"])

        try:
            self.popup_menu.registerClickSender(self.lists[key]["button"])
        except (AttributeError, TypeError):  # self.registerPopupMenuPanel hasn't been called yet
            pass

    def removeList(self, key):
        """Remove a ListPanel from this manager.

        @param key (unicode): list name
        """
        items = self.lists[key]["panel"].getItems()
        (y, x) = self.getIndex(self.lists[key]["button"])
        self.removeRow(y)
        del self.lists[key]
        self.untag(items)

    def untag(self, items):
        """Untag some items.
        
        Check first if the items are not used in any panel.

        @param items (list): items to be removed
        """
        items_assigned = set()
        for values in self.getItemsByKey().itervalues():
            items_assigned.update(values)
        quick_list_manager.QuickTagList.untag(self, [item for item in items if item not in items_assigned])

    def getItemsByKey(self):
        """Get the items grouped by list name.

        @return dict{unicode: list}
        """
        return {key: self.lists[key]["panel"].getItems() for key in self.lists}

    def getKeysByItem(self):
        """Get the keys groups by item.

        @return dict{object: set(unicode)}
        """
        result = {}
        for key in self.lists:
            for item in self.lists[key]["panel"].getItems():
                result.setdefault(item, set()).add(key)
        return result

    def registerPopupMenuPanel(self, entries, callback):
        """Register a popup menu panel for the list names' buttons.

        @param entries (dict{unicode: dict{unicode: unicode}}): menu entries
        @param callback (callable): common callback for all menu items, arguments are:
            - button widget
            - list name (item key)
        """
        self.popup_menu = base_panel.PopupMenuPanel(entries, callback=callback)
        for key in self.lists:  # register click sender for already existing lists
            self.popup_menu.registerClickSender(self.lists[key]["button"])


class TagsPanel(base_panel.ToggleStackPanel):
    """A toggle panel to set the tags"""

    TAGS = _("Tags")
    
    STYLE = {"main": "tagsPanel-main",
             "tags": "tagsPanel-tags"}

    def __init__(self, suggested_tags, tags=None):
        """
        
        @param suggested_tags (list[unicode]): list of all suggested tags
        @param tags (list[unicode]): already assigned tags
        """
        base_panel.ToggleStackPanel.__init__(self, Width="100%")
        self.addStyleName(self.STYLE["main"])
        
        if tags is None:
            tags = []

        self.tags = ListPanel(quick_list_manager.QuickTagList(suggested_tags), tags)
        self.tags.addStyleName(self.STYLE["tags"])
        self.tags.ACCEPT_NEW_ENTRY = True
        self.add(self.tags, self.TAGS)
        self.addStackChangeListener(self)

    def onStackChanged(self, sender, index, visible=None):
        if visible is None:
            visible = sender.getWidget(index).getVisible()
        text = ", ".join(self.getTags())
        suffix = "" if (visible or not text) else (": %s" % text)
        sender.setStackText(index, self.TAGS + suffix)

    def getTags(self):
        return self.tags.getItems()

    def setTags(self, items):
        self.tags.resetItems(items)