// This file is part of The New Aspell

// Copyright (C) 2004 by Christoph Hintermüller (JEH) 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/.

#include "settings.h"

#ifdef USE_POSIX_REGEX

#  include <sys/types.h>

#  include <regex.h>

#endif

#include "stack_ptr.hpp"

#include "cache-t.hpp"

#include "string.hpp"

#include "vector.hpp"

#include "config.hpp"

#include "errors.hpp"

#include "filter.hpp"

#include "string_enumeration.hpp"

#include "string_list.hpp"

#include "posib_err.hpp"

#include "file_util.hpp"

#include "fstream.hpp"

#include "getdata.hpp"

#include "strtonum.hpp"

#include "asc_ctype.hpp"

#include "iostream.hpp"

#include "gettext.h"

namespace acommon {

  class FilterMode {

  public:

    class MagicString {

    public:

      MagicString(const String & mode) : mode_(mode), fileExtensions() {}

      MagicString(const String & magic, const String & mode)

        : magic_(magic), mode_(mode) {} 

      bool matchFile(FILE * in, const String & ext);

      static PosibErr<bool> testMagic(FILE * seekIn, String & magic, const String & mode);

      void addExtension(const String & ext) { fileExtensions.push_back(ext); }

      bool hasExtension(const String & ext);

      void remExtension(const String & ext);

      MagicString & operator += (const String & ext) {addExtension(ext);return *this;}

      MagicString & operator -= (const String & ext) {remExtension(ext);return *this;}

      MagicString & operator = (const String & ext) { 

        fileExtensions.clear();

        addExtension(ext);

        return *this; 

      }

      const String & magic() const { return magic_; }

      const String & magicMode() const { return mode_; }

      ~MagicString() {}

    private:

      String magic_;

      String mode_;

      Vector<String> fileExtensions;

    };

    FilterMode(const String & name);

    PosibErr<bool> addModeExtension(const String & ext, String toMagic);

    PosibErr<bool> remModeExtension(const String & ext, String toMagic);

    bool lockFileToMode(const String & fileName,FILE * in = NULL);

    const String & modeName() const;

    void setDescription(const String & desc) {desc_ = desc;}

    const String & getDescription() const {return desc_;}

    PosibErr<void> expand(Config * config);

    PosibErr<void> build(FStream &, int line = 1, 

                         const char * fname = "mode file");

    ~FilterMode();

  private:

    //map extensions to magic keys 

    String name_;

    String desc_;

    String file_;

    Vector<MagicString> magicKeys;

    struct KeyValue {

      String key;

      String value;

      KeyValue() {}

      KeyValue(ParmStr k, ParmStr v) : key(k), value(v) {}

    };

    Vector<KeyValue> expansion;

  };

  class FilterModeList : public Cacheable, public Vector<FilterMode>

  {

  public:

    typedef Config CacheConfig;

    typedef String CacheKey;

    String key;

    static PosibErr<FilterModeList *> get_new(const String & key, const Config *);

    bool cache_key_eq(const String & okey) const {

      return key == okey;

    }

  };

  class ModeNotifierImpl : public Notifier

  {

  private:

    ModeNotifierImpl();

    ModeNotifierImpl(const ModeNotifierImpl &);

    ModeNotifierImpl & operator= (const ModeNotifierImpl & b);

    CachePtr<FilterModeList> filter_modes_;

  public:

    Config * config;

    PosibErr<FilterModeList *> get_filter_modes();

    ModeNotifierImpl(Config * c) : config(c) 

    {

      c->filter_mode_notifier = this;

    }

    ModeNotifierImpl(const ModeNotifierImpl & other,  Config * c) 

      : filter_modes_(other.filter_modes_), config(c) 

    {

      c->filter_mode_notifier = this;

    }

    ModeNotifierImpl * clone(Config * c) const {return new ModeNotifierImpl(*this, c);}

    PosibErr<void> item_updated(const KeyInfo * ki, ParmStr);

    PosibErr<void> list_updated(const KeyInfo * ki);

    ~ModeNotifierImpl() {}

  };

  FilterMode::FilterMode(const String & name)

  : name_(name) {}

  PosibErr<bool> FilterMode::addModeExtension(const String & ext, String toMagic) {

    bool extOnly = false;

    if (    ( toMagic == "" )

         || ( toMagic == "<noregex>" )

         || ( toMagic == "<nomagic>" )

         || ( toMagic == "<empty>" ) ) {

      extOnly = true;

    }

    else {

      RET_ON_ERR(FilterMode::MagicString::testMagic(NULL,toMagic,name_));

    } 

    Vector<MagicString>::iterator it;

    for ( it = magicKeys.begin() ; it != magicKeys.end() ; it++ ) {

      if (    (    extOnly

                && ( it->magic() == "" ) )

           || ( it->magic() == toMagic ) ) {

        *it += ext;

        return true;

      }

    }

    if ( it != magicKeys.end() ) {

      return false;

    }

    if ( extOnly ) {

      magicKeys.push_back(MagicString(name_));

    }

    else {

      magicKeys.push_back(MagicString(toMagic,name_));

    }

    for ( it = magicKeys.begin() ; it != magicKeys.end() ; it++ ) {

      if (    (    extOnly

                && ( it->magic() == "" ) )

           || ( it->magic() == toMagic ) ) {

        *it += ext;

        return true;

      }

    }

    return make_err(mode_extend_expand,name_.str());

  }

  PosibErr<bool> FilterMode::remModeExtension(const String & ext, String toMagic) {

    bool extOnly = false;

    if (    ( toMagic == "" )

         || ( toMagic == "<nomagic>" )

         || ( toMagic == "<empty>" ) ) {

      extOnly = true;

    }

    else {

      PosibErr<bool> pe = FilterMode::MagicString::testMagic(NULL,toMagic,name_);

      if ( pe.has_err() ) {

        return PosibErrBase(pe);

      }

    }

    for ( Vector<MagicString>::iterator it = magicKeys.begin() ;

          it != magicKeys.end() ; it++ ) {

      if (    (    extOnly

                && ( it->magic() == "" ) )

           || ( it->magic() == toMagic ) ) {

        *it -= ext;

        return true;

      }

    }

    return false;

  }

  bool FilterMode::lockFileToMode(const String & fileName,FILE * in) {

    Vector<unsigned int> extStart;

    int first_point = fileName.size();

    while ( first_point > 0 ) {

      while (    ( --first_point >= 0 )

              && ( fileName[first_point] != '.' ) ) {

      }

      if (    ( first_point >= 0 )

           && ( fileName[first_point] == '.' ) ) {

        extStart.push_back(first_point + 1);

      }

    }

    if ( extStart.size() < 1 )  {

      return false;

    }

    bool closeFile = false;

    if ( in == NULL ) {

      in = fopen(fileName.str(),"rb");

      closeFile= true;

    }

    for ( Vector<unsigned int>::iterator extSIt = extStart.begin() ;

          extSIt != extStart.end() ; extSIt ++ ) {

      String ext(fileName);

      ext.erase(0,*extSIt);

      for ( Vector<MagicString>::iterator it = magicKeys.begin() ;

            it != magicKeys.end() ; it++ ) {

        PosibErr<bool> magicMatch = it->matchFile(in,ext);

        if (    magicMatch 

             || magicMatch.has_err() ) {

          if ( closeFile ) {

            fclose ( in );

          }

          if ( magicMatch.has_err() ) {

            magicMatch.ignore_err();

            return false;

          }

          return true;

        }

      }

    }

    if ( closeFile ) {

      fclose(in);

    }

    return false;

  }

  const String & FilterMode::modeName() const {

    return name_;

  }

  FilterMode::~FilterMode() {

  }

  bool FilterMode::MagicString::hasExtension(const String & ext) {

    for ( Vector<String>::iterator it = fileExtensions.begin() ;

          it != fileExtensions.end() ; it++ ) {

      if ( *it == ext ) {

        return true;

      }

    }

    return false;

  }

  void FilterMode::MagicString::remExtension(const String & ext) {

    Vector<String>::iterator it = fileExtensions.begin();

    while (it != fileExtensions.end()) {

      if (*it == ext) {

        it = fileExtensions.erase(it);

      } else {

        it++;

      }

    }

  }

  bool FilterMode::MagicString::matchFile(FILE * in,const String & ext) {

    Vector<String>::iterator extIt;

    for ( extIt = fileExtensions.begin() ; 

          extIt != fileExtensions.end() ; extIt ++ ) {

      if ( *extIt == ext ) {

        break;

      }

    }

    if ( extIt == fileExtensions.end() ) {

      return false;

    }

    PosibErr<bool> pe = testMagic(in,magic_,mode_);

    if ( pe.has_err() ) {

      pe.ignore_err();

      return false;

    }

    return true;

  }

  PosibErr<bool> FilterMode::MagicString::testMagic(FILE * seekIn,String & magic, const String & mode) {

#ifdef USE_POSIX_REGEX

    if ( magic.size() == 0 ) {

      return true;

    }

    unsigned int magicFilePosition = 0;

    while (    ( magicFilePosition < magic.size() )

            && ( magic[magicFilePosition] != ':' ) ) {

      magicFilePosition++;

    }

    String number(magic);

    number.erase(magicFilePosition,magic.size() - magicFilePosition);

    const char * num = number.str();

    const char * numEnd = num + number.size();

    const char * endHere = numEnd;

    long position = 0;

    if (    ( number.size() == 0 ) 

         || ( (position = strtoi_c(num,&numEnd)) < 0 )

         || ( numEnd != endHere ) ) {

      return make_err(file_magic_pos,"",magic.str());

    }

    if (    ( magicFilePosition >= magic.size() )

         || (    ( seekIn != NULL )

              && ( fseek(seekIn,position,SEEK_SET) < 0 ) ) ) {

      if ( seekIn != NULL ) {

        rewind(seekIn);

      }

      return false;

    }

    //increment magicFilePosition to skip the `:'

    unsigned int seekRangePos = ++ magicFilePosition; 

    while (    ( magicFilePosition < magic.size() )

            && ( magic[magicFilePosition] != ':' ) ) {

      magicFilePosition++;

    }

    String magicRegExp(magic);

    magicRegExp.erase(0,magicFilePosition + 1);

    if ( magicRegExp.size() == 0 ) {

      if ( seekIn != NULL ) {

        rewind(seekIn);

      }

      return make_err(missing_magic,mode.str(),magic.str()); //no regular expression given

    }

    number = magic;

    number.erase(magicFilePosition,magic.size() - magicFilePosition);

    number.erase(0,seekRangePos);//already incremented by one see above

    num = (char*)number.str();

    endHere = numEnd = num + number.size();

    if (    ( number.size() == 0 )

         || ( (position = strtoi_c(num,&numEnd)) < 0 )

         || ( numEnd != endHere ) ) {

      if ( seekIn != NULL ) {

        rewind(seekIn);

      }

      return make_err(file_magic_range,mode.str(),magic.str());//no magic range given

    }

    regex_t seekMagic;

    int regsucess = 0;

    if ( (regsucess = regcomp(&seekMagic,magicRegExp.str(),

                              REG_NEWLINE|REG_NOSUB|REG_EXTENDED)) ){

      if ( seekIn != NULL ) {

        rewind(seekIn);

      }

      char regError[256];

      regerror(regsucess,&seekMagic,&regError[0],256);

      return make_err(bad_magic,mode.str(),magic.str(),regError);

    }

    if ( seekIn == NULL ) {

      regfree(&seekMagic);

      return true;

    }

    char * buffer = new char[(position + 1)];

    if ( buffer == NULL ) {

      regfree(&seekMagic);

      rewind(seekIn);

      return false;

    }

    memset(buffer,0,(position + 1));

    if ( (position = fread(buffer,1,position,seekIn)) == 0 ) {

      rewind(seekIn);

      regfree(&seekMagic);

      delete[] buffer;

      return false;

    }

    if ( regexec(&seekMagic,buffer,0,NULL,0) ) {

      delete[] buffer;

      regfree(&seekMagic);

      rewind(seekIn);

      return false;

    }

    delete[] buffer;

    regfree(&seekMagic);

    rewind(seekIn);

    return true;

#else

    return true;

#endif

  }

  PosibErr<void> FilterMode::expand(Config * config) {

    config->replace("clear-filter","");

    for ( Vector<KeyValue>::iterator it = expansion.begin() ;

          it != expansion.end() ; it++ ) 

    {

      PosibErr<void> pe = config->replace(it->key, it->value);

      if (pe.has_err()) return pe.with_file(file_);

    }

    return no_err;  

  }

  PosibErr<void> FilterMode::build(FStream & toParse, int line0, const char * fname) {

    String buf;

    DataPair dp;

    file_ = fname;

    dp.line_num = line0;

    while ( getdata_pair(toParse, dp, buf) ) {

      to_lower(dp.key);

      if ( dp.key == "filter" ) {

        to_lower(dp.value);

        expansion.push_back(KeyValue("add-filter", dp.value));

      } else if ( dp.key == "option" ) {

        split(dp);

        // FIXME: Add check for empty key

        expansion.push_back(KeyValue(dp.key, dp.value));

      } else {

        return make_err(bad_mode_key,dp.key).with_file(fname,dp.line_num);

      }

    }

    return no_err;

  }

  static GlobalCache<FilterModeList> filter_modes_cache("filter_modes");

  PosibErr<void> set_mode_from_extension (Config * config, ParmString filename, FILE * in) 

  {

    RET_ON_ERR_SET(static_cast<ModeNotifierImpl *>(config->filter_mode_notifier)

                   ->get_filter_modes(), FilterModeList *, fm);

    for ( FilterModeList::iterator it = fm->begin(); it != fm->end(); it++ ) 

    {

      if ( it->lockFileToMode(filename,in) ) {

        RET_ON_ERR(config->replace("mode", it->modeName().str()));

        break;

      }

    }

    return no_err;

  }

  void activate_filter_modes(Config *config);

  PosibErr<FilterModeList *>  ModeNotifierImpl::get_filter_modes()

  {

    if (!filter_modes_) {

      //FIXME is filter-path proper for filter mode files ???

      //      if filter-options-path better ???

      //      do we need a filter-mode-path ???

      //      should change to use genetic data-path once implemented

      //        and then search filter-path - KevinA

      String filter_path;

      StringList filter_path_lst;

      config->retrieve_list("filter-path", &filter_path_lst);

      combine_list(filter_path, filter_path_lst);

      RET_ON_ERR(setup(filter_modes_, &filter_modes_cache, config, filter_path));

    }

    return filter_modes_.get();

  }

  PosibErr<void> ModeNotifierImpl::item_updated(const KeyInfo * ki, ParmStr value)

  {

    if ( strcmp(ki->name, "mode") == 0 ) {

      RET_ON_ERR_SET(get_filter_modes(), FilterModeList *, filter_modes);

      for ( Vector<FilterMode>::iterator it = filter_modes->begin() ;

            it != filter_modes->end() ; it++ ) {

        if ( it->modeName() == value )

          return it->expand(config);

      }

      return make_err(unknown_mode, value); 

    }

    return no_err;

  }

  PosibErr<void> ModeNotifierImpl::list_updated(const KeyInfo * ki)

  {

    if (strcmp(ki->name, "filter-path") == 0) {

      filter_modes_.reset(0);

    }

    return no_err;

  }

  PosibErr<FilterModeList *> FilterModeList::get_new(const String & key,

                                                     const Config *) 

  {

    StackPtr<FilterModeList> filter_modes(new FilterModeList);

    filter_modes->key = key;

    StringList mode_path;

    separate_list(key, mode_path);

    PathBrowser els(mode_path, ".amf");

    String possMode;

    String possModeFile;

    const char * file;

    while ((file = els.next()) != NULL) 

    {

      possModeFile = file;

      possMode.assign(possModeFile.str(), possModeFile.size() - 4);

      unsigned pathPos = 0;

      unsigned pathPosEnd = 0;

      while (    ( (pathPosEnd = possMode.find('/',pathPos)) < possMode.size() )

              && ( pathPosEnd >= 0 ) ) {

        pathPos = pathPosEnd + 1;

      }

      possMode.erase(0,pathPos);

      to_lower(possMode.mstr());

      Vector<FilterMode>::iterator fmIt = filter_modes->begin();

      for ( fmIt = filter_modes->begin() ; 

            fmIt != filter_modes->end() ; fmIt++ ) {

        if ( (*fmIt).modeName() == possMode ) {

          break;

        }

      }

      if ( fmIt != filter_modes->end() ) {

        continue;

      }

      FStream toParse;

      RET_ON_ERR(toParse.open(possModeFile.str(),"rb"));

      String buf;

      DataPair dp;

      bool get_sucess = getdata_pair(toParse, dp, buf);

      to_lower(dp.key);

      to_lower(dp.value);

      if (    !get_sucess

           || ( dp.key != "mode" ) 

           || ( dp.value != possMode.str() ) )

        return make_err(expect_mode_key,"mode").with_file(possModeFile, dp.line_num);

      get_sucess = getdata_pair(toParse, dp, buf);

      to_lower(dp.key);

      if (    !get_sucess

           || ( dp.key != "aspell" )

           || ( dp.value == NULL )

           || ( *(dp.value) == '\0' ) )

        return make_err(mode_version_requirement).with_file(possModeFile, dp.line_num);

#ifdef FILTER_VERSION_CONTROL

      PosibErr<void> peb = check_version(dp.value.str);

      if (peb.has_err()) return peb.with_file(possModeFile, dp.line_num);

#endif

      FilterMode collect(possMode);

      while ( getdata_pair(toParse,dp,buf) ) {

        to_lower(dp.key);

        if (   ( dp.key == "desc" ) 

            || ( dp.key == "description" ) ) 

        {

          unescape(dp.value);

          collect.setDescription(dp.value);

          break;

        }

        if ( dp.key == "magic" ) {

          char * regbegin = dp.value;

          while (    regbegin

                  && ( *regbegin != '/' ) ) {

            regbegin++;

          }

          if (    ( regbegin == NULL )

               || ( *regbegin == '\0' ) 

               || ( *(++regbegin) == '\0' ) )

            return make_err(missing_magic_expression).with_file(possModeFile, dp.line_num);

          char * regend = regbegin;

          bool prevslash = false;

          while (    regend

                  && ( *regend != '\0' )

                  && (    prevslash

                       || ( * regend != '/' ) ) )  {

            if ( *regend == '\\' ) {

              prevslash = !prevslash;

            }

            else {

              prevslash = false;

            }

            regend ++ ;

          }

          if ( regend == regbegin )

            return make_err(missing_magic_expression).with_file(possModeFile, dp.line_num);

          char swap = *regend;

          *regend = '\0';

          String magic(regbegin);

          *regend = swap;

          unsigned int extCount = 0;

          while ( *regend != '\0' ) {

            regend ++;

            extCount ++;

            regbegin = regend;

            while (    ( *regend != '/' ) 

                    && ( *regend != '\0' ) ) {

              regend++;

            }

            if ( regend == regbegin ) 

            {

              char charCount[64];

              sprintf(&charCount[0],"%li",(long)(regbegin - (char *)dp.value));

              return  make_err(empty_file_ext,charCount).with_file(possModeFile,dp.line_num);

            }

            bool remove = false;

            bool add = true;

            if ( *regbegin == '+' ) {

              regbegin++;

            }

            else if ( *regbegin == '-' ) {

              add = false;

              remove = true;

              regbegin++;

            }

            if ( regend == regbegin ) 

            {

              char charCount[64];

              sprintf(&charCount[0],"%li",(long)(regbegin - (char *)dp.value));

              return  make_err(empty_file_ext,charCount).with_file(possModeFile,dp.line_num);

            }

            swap = *regend;

            *regend = '\0';

            String ext(regbegin);

            *regend = swap;

            // partially unescape magic

            char * dest = magic.mstr();

            const char * src  = magic.mstr();

            while (*src) {

              if ((*src == '\\' && src[1] == '/') || src[1] == '#')

                ++src;

              *dest++ = *src++;

            }

            magic.resize(dest - magic.mstr());

            PosibErr<bool> pe;

            if ( remove )

              pe = collect.remModeExtension(ext,magic);

            else

              pe = collect.addModeExtension(ext,magic);

            if ( pe.has_err() )

              return pe.with_file(possModeFile, dp.line_num);

          }

          if (extCount > 0 ) continue;

          char charCount[64];

          sprintf(&charCount[0],"%lu",(unsigned long)strlen((char *)dp.value));

          return  make_err(empty_file_ext,charCount).with_file(possModeFile,dp.line_num);

        }

        return make_err(expect_mode_key,"ext[tension]/magic/desc[ription]/rel[ation]")

          .with_file(possModeFile,dp.line_num);

      }//while getdata_pair

      RET_ON_ERR(collect.build(toParse,dp.line_num,possModeFile.str()));

      filter_modes->push_back(collect);

    }

    return filter_modes.release();

  }

  void activate_filter_modes(Config *config) 

  {

    config->add_notifier(new ModeNotifierImpl(config));

  }

  class FilterModesEnumeration : public StringPairEnumeration

  {

  public:

    typedef Vector<FilterMode>::const_iterator Itr;

  private:

    Itr it;

    Itr end;

  public:

    FilterModesEnumeration(Itr i, Itr e) : it(i), end(e) {}

    bool at_end() const {return it == end;}

    StringPair next()

    {

      if (it == end) return StringPair();

      StringPair res = StringPair(it->modeName().str(), it->getDescription().str());

      ++it;

      return res;

    }

    StringPairEnumeration * clone() const {return new FilterModesEnumeration(*this);}

    void assign(const StringPairEnumeration * other0)

    {

      const FilterModesEnumeration * other = (const FilterModesEnumeration *)other0;

      *this = *other;

    }

  };

  PosibErr<StringPairEnumeration *> available_filter_modes(Config * config)

  {

    RET_ON_ERR_SET(static_cast<ModeNotifierImpl *>(config->filter_mode_notifier)

                   ->get_filter_modes(), FilterModeList *, fm);

    return new FilterModesEnumeration(fm->begin(), fm->end());

  }

}