#ifndef __JLANG__JEQUATION__
#define __JLANG__JEQUATION__

#include <string>
#include <locale>
#include <cstdio>
#include <sstream>

#include "JLang/JString.hh"
#include "JLang/JEquationFacet.hh"
#include "JLang/JValue.hh"


/**
 * \author mdejong
 */

namespace JLANG {}
namespace JPP { using namespace JLANG; }

namespace JLANG {


  /**
   * General purpose equation class.
   *
   * An equation could have the following formats:
   *
   * <pre>
   *       \<skip line\>  "comment"  \<end of line\>
   *       \<skip line\>  "comment"  \<end of line\>
   *       \<key\> \<separator\> \<value\> \<comment\> "comment" \<end of line\>
   *       \<key\> \<separator\> \<left bracket\> \<value\> \<value> \<right bracket\> \<end of line\>
   *       \<key\>\<division\>\<key\> \<separator\> \<value\> \<end of line\>
   * </pre>
   * In this:
   *        - lines starting with one of the skip line characters are ignored;
   *        - <tt>key</tt>     is the key of the equation; 
   *        - <tt>value</tt>   is the value of the equation; 
   *        - <tt>comment</tt> marks the start of an inline comment (which is not part of the value); and
   *        - <tt>' '</tt> could be any of the specified white space characters.
   * In case of a division of the key, the value of the equation will include
   * the following key up to the end of line.
   * The special characters are defined in the JEquationParameters class.
   * The use of this class for I/O is handled via the JEquationFacet class.
   */
  class JEquation {
  public:
    /**
     * Auxiliary data structure for equation.
     */
    template<class T>
    struct equation_type {
      /**
       * Constructor.
       *
       * \param  __key            key
       * \param  __value          value
       */
      equation_type(const std::string __key,
		    const T&          __value) :
	key  (__key),
	value(__value)
      {}


      /**
       * Write equation to output stream.
       *
       * \param  out              output stream
       * \param  equation         equation
       * \return                  output stream
       */
      friend inline std::ostream& operator<<(std::ostream& out, const equation_type& equation)
      {
	using namespace std;
	
	ostream::sentry sentry(out);
	
	if (sentry) {
	  
	  const locale& loc = out.getloc();
	  
	  if (has_facet<JEquationFacet>(loc)) {
	    
	    const JEquationFacet& facet = use_facet<JEquationFacet>(loc);
	    
	    out << equation.key;
	    out << facet.getDefaultSeparator();
	    out << equation.value;
	    out << facet.getDefaultEndOfLine();
	    
	  } else {
	    
	    out << equation.key;
	    out << '=';
	    out << equation.value;
	    out << endl;
	  }
	}

	return out;
      }

      std::string key;
      const T&    value;
    };


    /**
     * Auxiliary method to create equation type.
     *
     * \param  key              key
     * \param  value            value
     */
    template<class T>
    static inline equation_type<T> make_equation(const std::string& key, const T& value)
    {
      return equation_type<T>(key, value);
    }
    
    
    /**
     * Default constructor.
     */
    JEquation() :
      key  (),
      sep  ('\0'),
      value()
    {}


    /**
     * Constructor.
     *
     * \param  key              key
     * \param  value            value
     */
    JEquation(const std::string& key, const std::string& value) :
      key  (key),
      sep  ('\0'),
      value(value)
    {}


    /**
     * Constructor.
     *
     * \param  buffer           input
     * \param  facet            facet
     */
    JEquation(const std::string& buffer, const JEquationFacet& facet)
    {
      setEquation(buffer, facet);
    }


    /**
     * Get key.
     *
     * \return                  key
     */
    const std::string& getKey() const
    {
      return key;
    }


    /**
     * Get separator.
     *
     * \return                  separator
     */
    const char getSeparator() const
    {
      return sep;
    }


    /**
     * Get value.
     *
     * \return                  value
     */
    const std::string& getValue() const
    {
      return value;
    }


    /**
     * Read equation from input stream.
     *
     * \param  in               input stream
     * \param  equation         equation
     * \return                  input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JEquation& equation)
    {
      using namespace std;

      istream::sentry sentry(in, false);

      if (sentry) {

	equation = JEquation();

	const locale& loc = in.getloc();

	if (has_facet<JEquationFacet>(loc)) {

	  const JEquationFacet& facet = use_facet<JEquationFacet>(loc);

	  ios_base::iostate state = in.rdstate();


	  for (int c; (c = in.peek()) != EOF && facet.isSkipLine((char) c); ) {
	    facet.ignore(in);
	  }


	  if (state == ios_base::goodbit) facet.get(in, istreambuf_iterator<char>(), in, state, equation.key);
	  if (state == ios_base::goodbit) facet.get(in, istreambuf_iterator<char>(), in, state, equation.sep);
	  if (state == ios_base::goodbit) facet.getline(in, equation.value);


	  // remove white spaces and brackets before evaluation

	  if (facet.isSeparator(equation.sep)) {

	    JString::const_iterator         p = equation.value. begin();
	    JString::const_reverse_iterator q = equation.value.rbegin();

	    for ( ; ; ++p, ++q) {

	      for ( ; p != equation.value. end() && facet.isWhiteSpace(*p); ++p) {}
	      for ( ; q != equation.value.rend() && facet.isWhiteSpace(*q); ++q) {}
	    
	      if (p == equation.value. end() || *p != facet.getLeftBracket() ||
		  q == equation.value.rend() || *q != facet.getRightBracket()) {
		break;
	      }
	    }

	    if (p != equation.value.begin() || q != equation.value.rbegin()) {
	      equation.value = string(p, q.base());
	    }
	  }

          if (state != ios_base::goodbit && state != ios_base::eofbit) {
            in.setstate(state);
	  }

	  if (!(state & ios_base::eofbit)) {
	    if (!facet.isDivision (equation.sep) &&
		!facet.isSeparator(equation.sep)) {
	      in.setstate(ios_base::badbit);
	    }
	  }

	} else {

	  in.setstate(ios_base::failbit);
	}
      }

      return in;
    }


    /**
     * Write equation to output stream.
     *
     * \param  out              output stream
     * \param  equation         equation
     * \return                  output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JEquation& equation)
    {
      using namespace std;

      ostream::sentry sentry(out);

      if (sentry) {

	const locale& loc = out.getloc();

	if (has_facet<JEquationFacet>(loc)) {

	  const JEquationFacet& facet = use_facet<JEquationFacet>(loc);

	  out << equation.key;
	  out << facet.getDefaultSeparator();
	  out << equation.value;
	  out << facet.getDefaultEndOfLine();

	} else {

	  out << equation.key;
	  out << equation.sep;
	  out << equation.value;
	  out << endl;
	}
      }

      return out;
    }


    /**
     * Set equation.
     *
     * \param  buffer           input
     * \param  facet            facet
     * \return                  this equation
     */
    JEquation& setEquation(const std::string& buffer, const JEquationFacet& facet)
    {
      using namespace std;

      istringstream in(buffer);

      in.imbue(locale(in.getloc(), facet.clone()));

      in >> *this;

      return *this;
    }


    /**
     * Set this equation to its value.
     *
     * \param  facet            facet
     * \return                  this equation
     */
    JEquation& setEquation(const JEquationFacet& facet)
    {
      setEquation(getValue(), facet);

      return *this;
    }


    /**
     * Extract equation.
     *
     * \param  buffer           input
     * \param  facet            facet
     * \return                  equation
     */
    static JEquation valueOf(const std::string& buffer, const JEquationFacet& facet)
    {
      return JEquation(buffer, facet);
    }


    /**
     * Convert equation to string.
     *
     * \return                  string
     */
    std::string toString() const
    {
      std::string buffer;

      buffer += getKey();
      buffer += getSeparator();
      buffer += getValue();

      return buffer;
    }

  protected:
    JString   key;
    char      sep;
    JString   value;
  };
}

#endif