// This file is part of The New Aspell
// Copyright (C) 2001 by Kevin Atkinson under the GNU LGPL license
// version 2.0 or 2.1.  You should have received a copy of the LGPL
// license along with this library if you did not you can find
// it at http://www.gnu.org/.

#ifndef ASPELL_CONFIG___HPP
#define ASPELL_CONFIG___HPP

#include "can_have_error.hpp"
#include "key_info.hpp"
#include "posib_err.hpp"
#include "string.hpp"
#include "vector.hpp"

namespace acommon {

  class OStream;
  class KeyInfoEnumeration;
  class StringPairEnumeration;
  class MutableContainer;
  class Cacheable;
  struct Conv;

  // The Config class is used to hold configuration information.
  // it has a set of keys which it will except.  Inserting or even
  // trying to look at a key that it does not know will produce
  // an error.  Extra accepted keys can be added with the set_extra 
  // method.

  // Keys tagged with KEYINFO_UTF8 are expected to be in UTF-8 format.
  // Keys with file/dir names may contain 8-bit characters and must
  //   remain untranslated
  // All other keys are expected to only contain ASCII characters.

  class Config;

  struct ConfigModule {
    const char * name; 
    const char * file; // path of shared object or dll
    const char * desc; // description of module
    const KeyInfo * begin;
    const KeyInfo * end;
  };

  class Notifier {
  public:
    // returns a copy if a copy should be made otherwise returns null
    virtual Notifier * clone(Config *) const {return 0;}
    virtual ~Notifier() {}

    virtual PosibErr<void> item_updated(const KeyInfo *, bool)    {return no_err;}
    virtual PosibErr<void> item_updated(const KeyInfo *, int)     {return no_err;}
    virtual PosibErr<void> item_updated(const KeyInfo *, ParmStr) {return no_err;}
    virtual PosibErr<void> list_updated(const KeyInfo *)          {return no_err;}
  };

  class PossibleElementsEmul;
  class NotifierEnumeration;
  class GetLine;
  class MDInfoListofLists;

  static const bool REPLACE = true;
  static const bool INSERT  = false;

  // prefixes
  //
  // reset - resets a value to the default
  //
  // enable - sets a boolean value to true
  // dont, disable - sets a boolean value to false
  // -- setting a boolean value to an empty string is the same as setting 
  //    it to true
  //
  // lset - sets a list, items separated by ':'
  // rem, remove - removes item from a list
  // add - add an item to a list
  // clear - removes all items from a list
  // -- setting a list item directly, ie with out a prefix, is the same as 
  //    setting it to a single value

  class Config : public CanHaveError {
    // copy and destructor provided
    friend class MDInfoListofLists;

  public:
    enum Action {NoOp, Set, Reset, Enable, Disable, 
                 ListSet, ListAdd, ListRemove, ListClear};

    struct Entry {
      Entry * next;
      String key;
      String value;
      String file;
      unsigned line_num;
      Action action;
      bool need_conv;
      bool secure; // if the value was set in a secure content
      short place_holder;
      Entry() : line_num(0), action(NoOp), 
                need_conv(false), secure(false), place_holder(-1) {}
    };

  private:
    static const int num_parms_[9];

  public:
    static inline bool list_action(Action a) {return (int)a >= (int)ListAdd; }
    static inline int num_parms(Action a) {return num_parms_[a];}

  private:
    String    name_;

    Entry * first_;
    Entry * * insert_point_;
    Entry * others_;

    bool committed_;
    bool attached_;    // if attached can't copy
    Vector<Notifier *> notifier_list;

    friend class PossibleElementsEmul;

    const KeyInfo       * keyinfo_begin;
    const KeyInfo       * keyinfo_end;
    const KeyInfo       * extra_begin;
    const KeyInfo       * extra_end;

    int md_info_list_index;

    void copy(const Config & other);
    void del();

    PosibErr<int> commit(Entry * entry, Conv * conv = 0);

    bool settings_read_in_;

  public:

    // the first
    // if the second parameter is set than flagged options will be
    // converted to utf-8 if needed
    PosibErr<void> commit_all(Vector<int> * = 0, const char * codeset = 0);

    PosibErr<void> replace(ParmStr, ParmStr);
    PosibErr<void> remove(ParmStr);

    bool empty() const {return !first_;}

    PosibErr<void> merge(const Config & other);

    PosibErr<void> lang_config_merge(const Config & other,
                                     int which, ParmStr codeset);

    bool settings_read_in() {return settings_read_in_;}

    PosibErr<void> set_committed_state(bool val);

    const Entry * lookup(const char * key) const;
    PosibErr<void> lookup_list(const KeyInfo * ki, MutableContainer & m, 
                               bool include_default) const;

    String temp_str;

    PosibErr<const ConfigModule *> (* load_filter_hook)(Config * config, ParmStr value);
    Notifier * filter_mode_notifier;

    Vector<ConfigModule> filter_modules;
    Vector<Cacheable *>  filter_modules_ptrs;

    Config(ParmStr name,
	   const KeyInfo * mainbegin, 
	   const KeyInfo * mainend);

    Config(const Config &);
    ~Config();
    Config & operator= (const Config &);

    bool get_attached() const {return attached_;}
    void set_attached(bool a) {attached_ = a;}

    Config * clone() const;
    void assign(const Config * other);

    const char * name() const {return name_.c_str();}

    NotifierEnumeration * notifiers() const;
  
    bool add_notifier    (      Notifier *);
    bool remove_notifier (const Notifier *);
    bool replace_notifier(const Notifier *, Notifier *);

    void set_extra(const KeyInfo * begin, const KeyInfo * end);

    void set_filter_modules(const ConfigModule * modbegin, const ConfigModule * modend);

    static const char * base_name(const char * name, Action * action = 0);
  
    PosibErr<const KeyInfo *> keyinfo(ParmStr key) const;

    KeyInfoEnumeration * possible_elements(bool include_extra = true,
                                           bool include_modules = true) const;
    
    StringPairEnumeration * elements() {return 0;} // FIXME
    
    String get_default(const KeyInfo * ki) const;
    PosibErr<String> get_default(ParmStr) const;

    PosibErr<String> retrieve(ParmStr key) const;

    struct Value {
      String val;
      bool secure;
      Value() {}
      Value(const String & v, bool s = false) : val(v), secure(s) {}
    };
    PosibErr<Value> retrieve_value(ParmStr key) const;

    // will also retrieve a list, with one value per line
    PosibErr<String> retrieve_any(ParmStr key) const;
  
    bool have (ParmStr key) const;

    PosibErr<void> retrieve_list (ParmStr key, MutableContainer *) const;
    PosibErr<bool> retrieve_bool (ParmStr key) const;
    PosibErr<int>  retrieve_int  (ParmStr key) const;
    
    // will take ownership of entry, even if there is an error
    PosibErr<void> set(Entry * entry, bool do_unescape = false);
      
    void replace_internal (ParmStr, ParmStr);
    
    void write_to_stream(OStream & out, bool include_extra = false);

    PosibErr<bool> read_in_settings(const Config * = 0);

    PosibErr<void> read_in(IStream & in, ParmStr id = "");
    PosibErr<void> read_in_file(ParmStr file);
    PosibErr<void> read_in_string(ParmStr str, const char * what = "");
  };

  Config * new_config();
  Config * new_basic_config(); // config which doesn't require any
			       // external symbols

  class NotifierEnumeration {
    // no copy and destructor needed
    Vector<Notifier *>::const_iterator i;
    Vector<Notifier *>::const_iterator end;
  public:
    NotifierEnumeration(const Vector<Notifier *> & b) 
      : i(b.begin()), end(b.end()) {}
    const Notifier * next() {
      const Notifier * temp = *i;
      if (i != end)
	++i;
      return temp;
    }
    bool at_end() const {return i == end;}
  };

  class KeyInfoEnumeration {
  public:
    typedef const KeyInfo * Value;
    virtual KeyInfoEnumeration * clone() const = 0;
    virtual void assign(const KeyInfoEnumeration *) = 0;
    virtual bool at_end() const = 0;
    virtual const KeyInfo * next() = 0;
    virtual const char * active_filter_module_name(void) = 0;
    virtual const char * active_filter_module_desc(void) = 0;
    virtual bool active_filter_module_changed(void) = 0;
    virtual ~KeyInfoEnumeration() {}
  };

  static const unsigned KEYINFO_MAY_CHANGE = 1 << 0;
  static const unsigned KEYINFO_UTF8       = 1 << 1;
  static const unsigned KEYINFO_HIDDEN     = 1 << 2;
  static const unsigned KEYINFO_COMMON     = 1 << 4;
  
  class AddableContainer;
  class StringList;

  void separate_list(ParmStr value, AddableContainer & out, bool do_unescape = true);
  void combine_list(String & res, const StringList &);


}

#endif