import sys
from ..Qt import QtGui, QtCore
from ..SignalProxy import SignalProxy
from collections import OrderedDict
from ..python2_3 import asUnicode, basestring


class ComboBox(QtGui.QComboBox):
    """Extends QComboBox to add extra functionality.

    * Handles dict mappings -- user selects a text key, and the ComboBox indicates
      the selected value.
    * Requires item strings to be unique
    * Remembers selected value if list is cleared and subsequently repopulated
    * setItems() replaces the items in the ComboBox and blocks signals if the
      value ultimately does not change.
    """
    
    
    def __init__(self, parent=None, items=None, default=None):
        QtGui.QComboBox.__init__(self, parent)
        self.currentIndexChanged.connect(self.indexChanged)
        self._ignoreIndexChange = False
        
        #self.value = default
        if 'darwin' in sys.platform: ## because MacOSX can show names that are wider than the comboBox
            self.setSizeAdjustPolicy(QtGui.QComboBox.AdjustToContents)
            #self.setMinimumContentsLength(10)
        self._chosenText = None
        self._items = OrderedDict()
        
        if items is not None:
            self.setItems(items)
            if default is not None:
                self.setValue(default)
    
    def setValue(self, value):
        """Set the selected item to the first one having the given value."""
        text = None
        for k,v in self._items.items():
            if v == value:
                text = k
                break
        if text is None:
            raise ValueError(value)
            
        self.setText(text)

    def setText(self, text):
        """Set the selected item to the first one having the given text."""
        ind = self.findText(text)
        if ind == -1:
            raise ValueError(text)
        #self.value = value
        self.setCurrentIndex(ind)
       
    def value(self):
        """
        If items were given as a list of strings, then return the currently 
        selected text. If items were given as a dict, then return the value
        corresponding to the currently selected key. If the combo list is empty,
        return None.
        """
        if self.count() == 0:
            return None
        text = asUnicode(self.currentText())
        return self._items[text]
    
    def ignoreIndexChange(func):
        # Decorator that prevents updates to self._chosenText
        def fn(self, *args, **kwds):
            prev = self._ignoreIndexChange
            self._ignoreIndexChange = True
            try:
                ret = func(self, *args, **kwds)
            finally:
                self._ignoreIndexChange = prev
            return ret
        return fn
    
    def blockIfUnchanged(func):
        # decorator that blocks signal emission during complex operations
        # and emits currentIndexChanged only if the value has actually
        # changed at the end.
        def fn(self, *args, **kwds):
            prevVal = self.value()
            blocked = self.signalsBlocked()
            self.blockSignals(True)
            try:
                ret = func(self, *args, **kwds)
            finally:
                self.blockSignals(blocked)
                
            # only emit if the value has changed
            if self.value() != prevVal:
                self.currentIndexChanged.emit(self.currentIndex())
                
            return ret
        return fn
    
    @ignoreIndexChange
    @blockIfUnchanged
    def setItems(self, items):
        """
        *items* may be a list, a tuple, or a dict. 
        If a dict is given, then the keys are used to populate the combo box
        and the values will be used for both value() and setValue().
        """
        prevVal = self.value()
        
        self.blockSignals(True)
        try:
            self.clear()
            self.addItems(items)
        finally:
            self.blockSignals(False)
            
        # only emit if we were not able to re-set the original value
        if self.value() != prevVal:
            self.currentIndexChanged.emit(self.currentIndex())
        
    def items(self):
        return self.items.copy()
        
    def updateList(self, items):
        # for backward compatibility
        return self.setItems(items)

    def indexChanged(self, index):
        # current index has changed; need to remember new 'chosen text'
        if self._ignoreIndexChange:
            return
        self._chosenText = asUnicode(self.currentText())
        
    def setCurrentIndex(self, index):
        QtGui.QComboBox.setCurrentIndex(self, index)
        
    def itemsChanged(self):
        # try to set the value to the last one selected, if it is available.
        if self._chosenText is not None:
            try:
                self.setText(self._chosenText)
            except ValueError:
                pass

    @ignoreIndexChange
    def insertItem(self, *args):
        raise NotImplementedError()
        #QtGui.QComboBox.insertItem(self, *args)
        #self.itemsChanged()
        
    @ignoreIndexChange
    def insertItems(self, *args):
        raise NotImplementedError()
        #QtGui.QComboBox.insertItems(self, *args)
        #self.itemsChanged()
    
    @ignoreIndexChange
    def addItem(self, *args, **kwds):
        # Need to handle two different function signatures for QComboBox.addItem
        try:
            if isinstance(args[0], basestring):
                text = args[0]
                if len(args) == 2:
                    value = args[1]
                else:
                    value = kwds.get('value', text)
            else:
                text = args[1]
                if len(args) == 3:
                    value = args[2]
                else:
                    value = kwds.get('value', text)
        
        except IndexError:
            raise TypeError("First or second argument of addItem must be a string.")
            
        if text in self._items:
            raise Exception('ComboBox already has item named "%s".' % text)
        
        self._items[text] = value
        QtGui.QComboBox.addItem(self, *args)
        self.itemsChanged()
        
    def setItemValue(self, name, value):
        if name not in self._items:
            self.addItem(name, value)
        else:
            self._items[name] = value
        
    @ignoreIndexChange
    @blockIfUnchanged
    def addItems(self, items):
        if isinstance(items, list) or isinstance(items, tuple):
            texts = items
            items = dict([(x, x) for x in items])
        elif isinstance(items, dict):
            texts = list(items.keys())
        else:
            raise TypeError("items argument must be list or dict or tuple (got %s)." % type(items))
        
        for t in texts:
            if t in self._items:
                raise Exception('ComboBox already has item named "%s".' % t)
                
        
        for k,v in items.items():
            self._items[k] = v
        QtGui.QComboBox.addItems(self, list(texts))
        
        self.itemsChanged()
        
    @ignoreIndexChange
    def clear(self):
        self._items = OrderedDict()
        QtGui.QComboBox.clear(self)
        self.itemsChanged()
        
    def saveState(self):
        ind = self.currentIndex()
        data = self.itemData(ind)
        #if not data.isValid():
        if data is not None:
            try:
                if not data.isValid():
                    data = None
                else:
                    data = data.toInt()[0]
            except AttributeError:
                pass
        if data is None:
            return asUnicode(self.itemText(ind))
        else:
            return data
        
    def restoreState(self, v):
        if type(v) is int:
            ind = self.findData(v)
            if ind > -1:
                self.setCurrentIndex(ind)
                return
        self.setCurrentIndex(self.findText(str(v)))

    def widgetGroupInterface(self):
        return (self.currentIndexChanged, self.saveState, self.restoreState)
