/* 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/.                                              */

#include "settings.h"

#include "config.hpp"
#include "filter.hpp"
#include "speller.hpp"
#include "indiv_filter.hpp"
#include "strtonum.hpp"
#include "errors.hpp"
#include "asc_ctype.hpp"

#ifdef HAVE_LIBDL
#  include <dlfcn.h>
#endif

namespace acommon {

  FilterHandle::~FilterHandle() 
  {
    //FIXME: This causes a seg fault
    //if (handle) dlclose(handle);
  } 

  Filter::Filter() {}

  void Filter::add_filter(IndividualFilter * filter)
  {
    Filters::iterator cur, end;
    cur = filters_.begin();
    end = filters_.end();
    while ((cur != end) && (filter->order_num() > (*cur)->order_num())){
      ++cur;
    }
    filters_.insert(cur, filter);
  }

  void Filter::reset()
  {
    Filters::iterator cur, end;
    cur = filters_.begin();
    end = filters_.end();
    for (; cur != end; ++cur)
      (*cur)->reset();
  }

  void Filter::process(FilterChar * & start, FilterChar * & stop)
  {
    Filters::iterator cur, end;
    cur = filters_.begin();
    end = filters_.end();
    for (; cur != end; ++cur)
      (*cur)->process(start, stop);
  }

  void Filter::clear()
  {
    Filters::iterator cur, end;
    cur = filters_.begin();
    end = filters_.end();
    for (; cur != end; ++cur){
      delete *cur;
    }
    filters_.clear();
  }

  Filter::~Filter() 
  {
    clear();
  }

  static PosibErr<int> version_compare(const char * x, const char * y)
  {
    do {
      int xn = 0, yn = 0;
      if (*x) {
        if (!asc_isdigit(*x)) return make_err(bad_version_string);
        xn = strtoi_c(x, &x);}
      if (*y) {
        if (!asc_isdigit(*y)) return make_err(bad_version_string);
        yn = strtoi_c(y, &y);}
      int diff = xn - yn;
      if (diff != 0) return diff;
      if (*x) {
        if (*x != '.') return make_err(bad_version_string);
        ++x;}
      if (*y) {
        if (*y != '.') return make_err(bad_version_string);
        ++y;}
    } while (*x || *y);
    return 0;
  }

  PosibErr<bool> verify_version(const char * rel_op, 
                                const char * actual, const char * required) 
  {
    assert(actual != NULL && required != NULL);

    RET_ON_ERR_SET(version_compare(actual, required), int, cmp);

    if (cmp == 0 && strchr(rel_op, '=')) return true;
    if (cmp < 0  && strchr(rel_op, '<')) return true;
    if (cmp > 0  && strchr(rel_op, '>')) return true;
    return false;
  }

  PosibErr<void> check_version(const char * requirement)
  {
    const char * s = requirement;
    
    if (*s == '>' || *s == '<') s++;
    if (*s == '=')              s++;

    String rel_op(requirement, s - requirement);
    String req_ver(s);
    
    char act_ver[] = PACKAGE_VERSION;

    char * seek = act_ver;
    while (*seek && *seek != '-') ++seek; // remove any part after the '-'
    *seek = '\0';

    PosibErr<bool> peb = verify_version(rel_op.str(), act_ver, req_ver.str());
    
    if (peb.has_err()) {
      peb.ignore_err();
      return make_err(confusing_version);
    } else if ( peb == false ) {
      return make_err(bad_version);
    } else {
      return no_err;
    }
  }
}