# -*- mode: python; coding: utf-8 -*-

import logging

import gtk.glade
import util
import config
import widgets

# FIXME: no es posible usar el path del config, porque este glade no está donde los demás
# Hay que arreglar el config.path convenientemente
def config_path(fname):
    import os
    return os.path.join(os.path.dirname(__file__), fname)


class BaseForm(util.GladeWrapper):

    def __init__(self, valids, dlg_name):
        #util.GladeWrapper.__init__(self, config.path("formulator.glade"), dlg_name)
        util.GladeWrapper.__init__(self, config_path("formulator.glade"), dlg_name)
        self.dialog = self.get_widget(dlg_name)

        # Validators for this Form
        self.__valids = valids


    def __mark_invalid(self, item, msg):
        lab_inv = getattr (self, 'wg_label_%s_invalid' % item)
        lab_inv.set_markup('<span color="red"><b>*</b> %s</span>' % msg)
        lab_inv.show_all()


    def __mark_valid(self, item):
        getattr(self, 'wg_label_%s_invalid' % item).hide()


    # FIXME: focus on first invalid field
    def run(self):
        while True:
            res = self.dialog.run()
            if res != gtk.RESPONSE_ACCEPT:
                self.reset()
                return False

            overall = True
            for i in self.__valids:
                ok, msg = self.__valids[i](self.get_value(i))
                if not ok:
                    overall = False
                    self.__mark_invalid(i, msg)
                else:
                    self.__mark_valid(i)

            if overall:
                break

        self.reset()
        return True


    # To implement in childs
    def get_value(self, key):
        raise NotImplementedError

    def get_items(self):
        return {}

    def reset(self):
        self.dialog.hide()



class NewDir(BaseForm):
    def __init__(self, valids=[]):
        BaseForm.__init__(self, valids, "FormNewDir")

        self.wg_entry_name = widgets.Entry(clear=True)
        self.wg_entry_name.show_all()
        self.wg_entry_name.connect("activate", self.on_entry_name_activate)
        self.wg_box_entry_name.add(self.wg_entry_name)


    def reset(self):
        self.wg_label_name.show_all()
        self.wg_label_name_invalid.hide()
        self.wg_entry_name.grab_focus()
        self.dialog.hide()

    def get_value(self, key):
        return {'name':self.wg_entry_name.get_text}[key]()

    def get_items(self):
        return {'name':self.wg_entry_name.get_text()}

    # GUI Callbacks
    def on_entry_name_activate(self, widget):
        self.dialog.response(gtk.RESPONSE_ACCEPT)



class GetString(BaseForm):
    def __init__(self, valids=[], title="", msg=""):
        BaseForm.__init__(self, valids, "FormGetString")
        if title: self.dialog.set_title(title)
        if msg:   self.wg_label_string.set_text(msg)

        self.wg_entry_string = widgets.Entry(clear=True)
        self.wg_entry_string.show_all()
        self.wg_entry_string.connect("activate", self.on_entry_string_activate)
        self.wg_box_entry_string.add(self.wg_entry_string)

    def reset(self):
        self.wg_label_string_invalid.hide()
        self.wg_entry_string.grab_focus()
        self.dialog.hide()

    def get_value(self, key):
        return {'string':self.wg_entry_string.get_text}[key]()

    def get_items(self):
        return {'string':self.wg_entry_string.get_text()}

    # GUI Callbacks
    def on_entry_string_activate(self, widget):
        self.dialog.response(gtk.RESPONSE_ACCEPT)



class YesNo(BaseForm):
    def __init__(self, msg=''):
        BaseForm.__init__(self, [], "FormYesNo")
        if msg: self.wg_label_msg.set_markup(msg)



class KeyValue(BaseForm):
    def __init__(self, valids):
        BaseForm.__init__(self, valids, "FormKeyValue")

        self.wg_entry_key = widgets.Entry(clear=True)
        self.wg_entry_key.connect("activate", self.on_entry_key_activate)
        self.wg_entry_key.show_all()
        self.wg_box_entry_key.add(self.wg_entry_key)

        self.wg_entry_value = widgets.Entry(clear=True)
        self.wg_entry_value.connect("activate", self.on_entry_value_activate)
        self.wg_entry_value.show_all()
        self.wg_box_entry_value.add(self.wg_entry_value)


    def reset(self):
        self.wg_label_key_invalid.hide()
        self.wg_label_value_invalid.hide()
        self.wg_entry_key.grab_focus()
        self.dialog.hide()


    def get_value(self, key):
        return {'key':self.wg_entry_key.get_text,
                'value':self.wg_entry_value.get_text}[key]()

    def get_items(self):
        return {'key':self.wg_entry_key.get_text(),
                'value':self.wg_entry_value.get_text()}

    # GUI Callbacks
    def on_entry_key_activate(self, widget):
        self.wg_entry_value.grab_focus()

    def on_entry_value_activate(self, widget):
        self.dialog.response(gtk.RESPONSE_ACCEPT)



class ErrorMsg(BaseForm):
    def __init__(self, msg=''):
        BaseForm.__init__(self, [], "FormErrorMsg")
        if msg: self.wg_label_msg.set_markup(msg)



class Validators:

    @classmethod
    def dir_name(cls, name):
        if not name:
            return (False, 'Name cannot be empty')
        invalid = ['\\', '/', '<', '>']
        for i in invalid:
            if i in name:
                if i == '<': i = '&lt;'
                if i == '<': i = '&gt;'
                return (False, 'Invalid char at name: "%s"' % i)

        return (True, '')


    @classmethod
    def is_not_empty(cls, name):
        val = name != ""
        return (val, (not val) * "This cannot be empty")



class Progress(util.GladeWrapper):

    # Type of messages
    MSG_ERROR, MSG_WARNING, MSG_INFO = range(3)

    def __init__(self):
        #util.GladeWrapper.__init__(self, config.path("formulator.glade"), "Progress")
        util.GladeWrapper.__init__(self, config_path("formulator.glade"), "Progress")


    def display_message(self, kind, msg):
        icons = {self.MSG_ERROR:   'gtk-error',
                 self.MSG_WARNING: 'gtk-warning',
                 self.MSG_INFO:    'gtk-info'}

        # Logging this message
        self.logger = logging.getLogger("Progress")
        {self.MSG_ERROR:   self.logger.error,
         self.MSG_WARNING: self.logger.warning,
         self.MSG_INFO:    self.logger.info}[kind](msg)

        self.wg_label_progress.set_text(msg)
        img = gtk.image_new_from_stock(icons[kind], gtk.ICON_SIZE_DIALOG)
        img.show_all()
        self.wg_box_msg.pack_start(img)

        self.wg_Progress.run()
        self.wg_Progress.hide()


    def progress_init(self):
        self.wg_progressbar.show_all()



#class FormAction:
#    def __init__(self, name, form, xfer, affected_cb):
#        self.__name = name
#        self.__form = form
#        self.__xfer = xfer
#        self.__affected_cb = affected_cb
#
#        self.__progress = Progress()
#
#
#    def __call__(self):
#        # action, items, user_params, progress
#        # iction
#        args = [self.__name]
#
#        # items
#        if self.__affected_cb: args.append(self.__affected_cb())
#        else:                  args.append([])
#
#        # user_params
#        if self.__form:
#            if not self.__form.run(): return False
#            args.append(self.__form.get_items())
#        else:
#            args.append([])
#
#        # progress
#        args.append(self.__progress)
#
#        self.__xfer(*args)


class UI_FormAction:
    def __init__(self, cb, form, code): #, affected_cb):
        self.__cb = cb
        self.__form = form
        self.__code = code
        #self.__affected_cb = affected_cb
        self.__progress = Progress()


    def __call__(self, *user_args):
        # code, selected, user_input, progress
        # code of action
        args = util.Record(code=self.__code)

        # user_params
        if self.__form:
            if not self.__form.run(): return False
            args.user_input = self.__form.get_items()
        else:
            args.user_input = {}

        # selected
        #try:
        #    args.selected = self.__affected_cb()
        #except NotImplementedError:
        #    args.selected = tuple()

       # progress
        args.progress = self.__progress

        self.__cb(args, *user_args)


### Para retrocompatibilidad
#FormNewDir    = NewDir
#FormKeyValue  = KeyValue
#FormErrorMsg  = ErrorMsg
#FormYesNo     = YesNo
#FormGetString = GetString