/*
 * This file is part of the KFTPGrabber project
 *
 * Copyright (C) 2003-2006 by the KFTPGrabber developers
 * Copyright (C) 2003-2006 Jernej Kos <kostko@jweb-network.net>
 *
 * 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 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and
 * NON-INFRINGEMENT.  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, write to the Free Software
 * Foundation, Inc., 51 Franklin Steet, Fifth Floor, Boston,
 * MA 02110-1301, USA.
 *
 * In addition, as a special exception, the copyright holders give
 * permission to link the code of portions of this program with the
 * OpenSSL library under certain conditions as described in each
 * individual source file, and distribute linked combinations
 * including the two.
 *
 * You must obey the GNU General Public License in all respects
 * for all of the code used other than OpenSSL.  If you modify
 * file(s) with this exception, you may extend this exception to your
 * version of the file(s), but you are not obligated to do so.  If you
 * do not wish to do so, delete this exception statement from your
 * version.  If you delete this exception statement from all source
 * files in the program, then also delete it here.
 */
#include "filterwidgethandler.h"

#include <tqcombobox.h>
#include <tqlabel.h>

#include <tdelocale.h>
#include <kstaticdeleter.h>
#include <klineedit.h>
#include <knuminput.h>
#include <kcolorbutton.h>

namespace KFTPCore {

namespace Filter {

namespace {

static const struct {
  const Condition::Type type;
  const char *name;
} TextTypes[] = {
  { Condition::Contains,      I18N_NOOP("contains") },
  { Condition::ContainsNot,   I18N_NOOP("does not contain") },
  { Condition::Is,            I18N_NOOP("equals") },
  { Condition::IsNot,         I18N_NOOP("does not equal") },
  { Condition::Matches,       I18N_NOOP("matches regexp") },
  { Condition::MatchesNot,    I18N_NOOP("does not match regexp") }
};

static const int TextTypeCount = sizeof(TextTypes) / sizeof(*TextTypes);

class TextWidgetHandler : public ConditionWidgetHandler
{
public:
    TextWidgetHandler()
      : ConditionWidgetHandler()
    {
    }
    
    TQWidget *createTypeWidget(TQWidget *parent, const TQObject *receiver) const
    {
      TQComboBox *combo = new TQComboBox(parent);
      
      for (int i = 0; i < TextTypeCount; i++) {
        combo->insertItem(i18n(TextTypes[i].name));
      }
      
      combo->adjustSize();
      
      // Connect the signal
      TQObject::connect(combo, SIGNAL(activated(int)), receiver, SLOT(slotTypeChanged()));
      
      return combo;
    }
    
    Condition::Type getConditionType(TQWidget *widget) const
    {
      TQComboBox *combo = static_cast<TQComboBox*>(widget);
      return TextTypes[combo->currentItem()].type;
    }
    
    void createValueWidgets(TQWidgetStack *stack, const TQObject *receiver) const
    {
      KLineEdit *lineEdit = new KLineEdit(stack, "textWidgetHandler_LineEdit");
      TQObject::connect(lineEdit, SIGNAL(textChanged(const TQString&)), receiver, SLOT(slotValueChanged()));
      stack->addWidget(lineEdit);
    }
    
    TQVariant getConditionValue(TQWidgetStack *values) const
    {
      KLineEdit *lineEdit = static_cast<KLineEdit*>(values->child("textWidgetHandler_LineEdit"));
      return TQVariant(lineEdit->text());
    }
    
    void update(int field, TQWidgetStack *types, TQWidgetStack *values) const
    {
      types->raiseWidget(field);
      values->raiseWidget((TQWidget*) values->child("textWidgetHandler_LineEdit"));
    }
    
    void setCondition(TQWidgetStack *types, TQWidgetStack *values, const Condition *condition)
    {
      // Set condition type
      const Condition::Type type = condition->type();
      int typeIndex = 0;
      
      for (; typeIndex < TextTypeCount; typeIndex++)
        if (type == TextTypes[typeIndex].type)
          break;
      
      TQComboBox *combo = static_cast<TQComboBox*>(types->widget(((int) condition->field())));
      combo->blockSignals(true);
      combo->setCurrentItem(typeIndex);
      combo->blockSignals(false);
      types->raiseWidget(combo);
      
      // Set condition value
      KLineEdit *lineEdit = static_cast<KLineEdit*>(values->child("textWidgetHandler_LineEdit"));
      lineEdit->blockSignals(true);
      lineEdit->setText(condition->value().toString());
      lineEdit->blockSignals(false);
      values->raiseWidget(lineEdit);
    }
};

}

namespace {

static const struct {
  const Condition::Type type;
  const char *name;
} EntryTypes[] = {
  { Condition::Is,            I18N_NOOP("is") },
  { Condition::IsNot,         I18N_NOOP("is not") }
};

static const int EntryTypeCount = sizeof(EntryTypes) / sizeof(*EntryTypes);

class EntryWidgetHandler : public ConditionWidgetHandler
{
public:
    EntryWidgetHandler()
      : ConditionWidgetHandler()
    {
    }
    
    TQWidget *createTypeWidget(TQWidget *parent, const TQObject *receiver) const
    {
      TQComboBox *combo = new TQComboBox(parent);
      
      for (int i = 0; i < EntryTypeCount; i++) {
        combo->insertItem(i18n(EntryTypes[i].name));
      }
      
      combo->adjustSize();
      
      // Connect the signal
      TQObject::connect(combo, SIGNAL(activated(int)), receiver, SLOT(slotTypeChanged()));
      
      return combo;
    }
    
    Condition::Type getConditionType(TQWidget *widget) const
    {
      TQComboBox *combo = static_cast<TQComboBox*>(widget);
      return EntryTypes[combo->currentItem()].type;
    }
    
    void createValueWidgets(TQWidgetStack *stack, const TQObject *receiver) const
    {
      TQComboBox *combo = new TQComboBox(stack, "entryWidgetHandler_Combo");
      combo->insertItem(i18n("File"), 0);
      combo->insertItem(i18n("Directory"), 1);
      
      TQObject::connect(combo, SIGNAL(activated(int)), receiver, SLOT(slotValueChanged()));
      stack->addWidget(combo);
    }
    
    TQVariant getConditionValue(TQWidgetStack *values) const
    {
      TQComboBox *combo = static_cast<TQComboBox*>(values->child("entryWidgetHandler_Combo"));
      TQVariant value;
      
      if (combo->currentItem() == 0)
        value = TQVariant(TQString("f"));
      else
        value = TQVariant(TQString("d"));
      
      return value;
    }
    
    void update(int field, TQWidgetStack *types, TQWidgetStack *values) const
    {
      types->raiseWidget(field);
      values->raiseWidget((TQWidget*) values->child("entryWidgetHandler_Combo"));
    }
    
    void setCondition(TQWidgetStack *types, TQWidgetStack *values, const Condition *condition)
    {
      // Set condition type
      const Condition::Type type = condition->type();
      int typeIndex = 0;
      
      for (; typeIndex < EntryTypeCount; typeIndex++)
        if (type == EntryTypes[typeIndex].type)
          break;
      
      TQComboBox *combo = static_cast<TQComboBox*>(types->widget(((int) condition->field())));
      combo->blockSignals(true);
      combo->setCurrentItem(typeIndex);
      combo->blockSignals(false);
      types->raiseWidget(combo);
      
      // Set condition value
      combo = static_cast<TQComboBox*>(values->child("entryWidgetHandler_Combo"));
      combo->blockSignals(true);
      combo->setCurrentItem(condition->value().toString() == "f" ? 0 : 1);
      combo->blockSignals(false);
      values->raiseWidget(combo);
    }
};

}

namespace {

static const struct {
  const Condition::Type type;
  const char *name;
} SizeTypes[] = {
  { Condition::Is,            I18N_NOOP("equals") },
  { Condition::IsNot,         I18N_NOOP("does not equal") },
  { Condition::Greater,       I18N_NOOP("is greater than") },
  { Condition::Smaller,       I18N_NOOP("is smaller than") }
};

static const int SizeTypeCount = sizeof(SizeTypes) / sizeof(*SizeTypes);

class SizeWidgetHandler : public ConditionWidgetHandler
{
public:
    SizeWidgetHandler()
      : ConditionWidgetHandler()
    {
    }
    
    TQWidget *createTypeWidget(TQWidget *parent, const TQObject *receiver) const
    {
      TQComboBox *combo = new TQComboBox(parent);
      
      for (int i = 0; i < SizeTypeCount; i++) {
        combo->insertItem(i18n(SizeTypes[i].name));
      }
      
      combo->adjustSize();
      
      // Connect the signal
      TQObject::connect(combo, SIGNAL(activated(int)), receiver, SLOT(slotTypeChanged()));
      
      return combo;
    }
    
    Condition::Type getConditionType(TQWidget *widget) const
    {
      TQComboBox *combo = static_cast<TQComboBox*>(widget);
      return SizeTypes[combo->currentItem()].type;
    }
    
    void createValueWidgets(TQWidgetStack *stack, const TQObject *receiver) const
    {
      KIntNumInput *numInput = new KIntNumInput(stack, "sizeWidgetHandler_NumInput");
      numInput->setMinValue(0); 
      numInput->setSuffix(" " + i18n("bytes"));
      
      TQObject::connect(numInput, SIGNAL(valueChanged(int)), receiver, SLOT(slotValueChanged()));
      stack->addWidget(numInput);
    }
    
    TQVariant getConditionValue(TQWidgetStack *values) const
    {
      KIntNumInput *numInput = static_cast<KIntNumInput*>(values->child("sizeWidgetHandler_NumInput"));
      return TQVariant(numInput->value());
    }
    
    void update(int field, TQWidgetStack *types, TQWidgetStack *values) const
    {
      types->raiseWidget(field);
      values->raiseWidget((TQWidget*) values->child("sizeWidgetHandler_NumInput"));
    }
    
    void setCondition(TQWidgetStack *types, TQWidgetStack *values, const Condition *condition)
    {
      // Set condition type
      const Condition::Type type = condition->type();
      int typeIndex = 0;
      
      for (; typeIndex < SizeTypeCount; typeIndex++)
        if (type == SizeTypes[typeIndex].type)
          break;
      
      TQComboBox *combo = static_cast<TQComboBox*>(types->widget(((int) condition->field())));
      combo->blockSignals(true);
      combo->setCurrentItem(typeIndex);
      combo->blockSignals(false);
      types->raiseWidget(combo);
      
      // Set condition value
      KIntNumInput *numInput = static_cast<KIntNumInput*>(values->child("sizeWidgetHandler_NumInput"));
      numInput->blockSignals(true);
      numInput->setValue(condition->value().toInt());
      numInput->blockSignals(false);
      values->raiseWidget(numInput);
    }
};

}

class EmptyActionWidgetHandler : public ActionWidgetHandler
{
public:
    EmptyActionWidgetHandler()
      : ActionWidgetHandler()
    {
    }
    
    virtual TQWidget *createWidget(TQWidget *parent, const TQObject *receiver) const
    {
      Q_UNUSED(receiver);

      return new TQWidget(parent);
    }
    
    TQVariant getActionValue(TQWidget *widget) const
    {
      Q_UNUSED(widget);
      
      return TQVariant(TQString());
    }
    
    void setAction(TQWidgetStack *stack, const Action *action) const
    {
      stack->raiseWidget((int) action->type());
    }
};

class NoneActionWidgetHandler : public EmptyActionWidgetHandler
{
public:
    NoneActionWidgetHandler()
      : EmptyActionWidgetHandler()
    {
    }
    
    TQWidget *createWidget(TQWidget *parent, const TQObject *receiver) const
    {
      Q_UNUSED(receiver);

      return new TQLabel(i18n("Please select an action."), parent);
    }
};

class PriorityActionWidgetHandler : public ActionWidgetHandler
{
public:
    PriorityActionWidgetHandler()
      : ActionWidgetHandler()
    {
    }
    
    TQWidget *createWidget(TQWidget *parent, const TQObject *receiver) const
    {
      KIntNumInput *numInput = new KIntNumInput(parent);
      numInput->setPrefix(i18n("Priority:") + " ");
      
      TQObject::connect(numInput, SIGNAL(valueChanged(int)), receiver, SLOT(slotValueChanged()));
      return numInput;
    }
    
    TQVariant getActionValue(TQWidget *widget) const
    {
      KIntNumInput *numInput = static_cast<KIntNumInput*>(widget);
      return TQVariant(numInput->value());
    }
    
    void setAction(TQWidgetStack *stack, const Action *action) const
    {
      stack->raiseWidget((int) action->type());
      KIntNumInput *numInput = static_cast<KIntNumInput*>(stack->visibleWidget());
      numInput->setValue(action->value().toInt());
    }
};

class ColorizeActionWidgetHandler : public ActionWidgetHandler
{
public:
    ColorizeActionWidgetHandler()
      : ActionWidgetHandler()
    {
    }
    
    TQWidget *createWidget(TQWidget *parent, const TQObject *receiver) const
    {
      KColorButton *colorButton = new KColorButton(parent);
      
      TQObject::connect(colorButton, SIGNAL(changed(const TQColor&)), receiver, SLOT(slotValueChanged()));
      return colorButton;
    }
    
    TQVariant getActionValue(TQWidget *widget) const
    {
      KColorButton *colorButton = static_cast<KColorButton*>(widget);
      return TQVariant(colorButton->color());
    }
    
    void setAction(TQWidgetStack *stack, const Action *action) const
    {
      stack->raiseWidget((int) action->type());
      KColorButton *colorButton = static_cast<KColorButton*>(stack->visibleWidget());
      colorButton->setColor(action->value().toColor());
    }
};

WidgetHandlerManager *WidgetHandlerManager::m_self = 0;
static KStaticDeleter<WidgetHandlerManager> staticHandlerManagerDeleter;

WidgetHandlerManager *WidgetHandlerManager::self()
{
  if (!m_self) {
    staticHandlerManagerDeleter.setObject(m_self, new WidgetHandlerManager());
  }
  
  return m_self;
}

WidgetHandlerManager::WidgetHandlerManager()
{
  // Register condition handlers
  registerConditionHandler(Filename, new TextWidgetHandler());
  registerConditionHandler(EntryType, new EntryWidgetHandler());
  registerConditionHandler(Size, new SizeWidgetHandler());
  
  // Register action handlers
  registerActionHandler(Action::None, new NoneActionWidgetHandler());
  registerActionHandler(Action::Priority, new PriorityActionWidgetHandler());
  registerActionHandler(Action::Skip, new EmptyActionWidgetHandler());
  registerActionHandler(Action::Colorize, new ColorizeActionWidgetHandler());
  registerActionHandler(Action::Hide, new EmptyActionWidgetHandler());
  registerActionHandler(Action::Lowercase, new EmptyActionWidgetHandler());
}

WidgetHandlerManager::~WidgetHandlerManager()
{
  if (m_self == this)
    staticHandlerManagerDeleter.setObject(m_self, 0, false);
}

void WidgetHandlerManager::registerConditionHandler(Field field, ConditionWidgetHandler *handler)
{
  m_conditionHandlers[field] = handler;
}

void WidgetHandlerManager::registerActionHandler(Action::Type type, ActionWidgetHandler *handler)
{
  m_actionHandlers[type] = handler;
}

void WidgetHandlerManager::createConditionWidgets(TQWidgetStack *types, TQWidgetStack *values, const TQObject *receiver)
{
  ConditionHandlerMap::ConstIterator le = m_conditionHandlers.end();
  for (ConditionHandlerMap::ConstIterator i = m_conditionHandlers.begin(); i != le; ++i) {
    Field field = i.key();
    const ConditionWidgetHandler *handler = i.data();
    
    types->addWidget(handler->createTypeWidget(types, receiver), (int) field);
    handler->createValueWidgets(values, receiver);
  }
}

void WidgetHandlerManager::createActionWidgets(TQWidgetStack *stack, const TQObject *receiver)
{
  ActionHandlerMap::ConstIterator le = m_actionHandlers.end();
  for (ActionHandlerMap::ConstIterator i = m_actionHandlers.begin(); i != le; ++i) {
    Action::Type type = i.key();
    const ActionWidgetHandler *handler = i.data();
    
    stack->addWidget(handler->createWidget(stack, receiver), (int) type);
  }
}

void WidgetHandlerManager::update(Field field, TQWidgetStack *types, TQWidgetStack *values)
{
  m_conditionHandlers[field]->update((int) field, types, values);
}

void WidgetHandlerManager::setCondition(TQWidgetStack *types, TQWidgetStack *values, const Condition *condition)
{
  m_conditionHandlers[condition->field()]->setCondition(types, values, condition);
}

Condition::Type WidgetHandlerManager::getConditionType(Field field, TQWidgetStack *types)
{
  return m_conditionHandlers[field]->getConditionType(types->widget((int) field));
}

TQVariant WidgetHandlerManager::getConditionValue(Field field, TQWidgetStack *values)
{
  return m_conditionHandlers[field]->getConditionValue(values);
}

void WidgetHandlerManager::setAction(TQWidgetStack *stack, const Action *action)
{
  m_actionHandlers[action->type()]->setAction(stack, action);
}

TQVariant WidgetHandlerManager::getActionValue(TQWidgetStack *stack)
{
  TQWidget *widget = stack->visibleWidget();
  return m_actionHandlers[(Action::Type) stack->id(widget)]->getActionValue(widget);
}

}

}
