#ifndef __JTOOLS__JTUPLE__
#define __JTOOLS__JTUPLE__

#include <istream>
#include <ostream>

#include "JLang/JTypeList.hh"
#include "JLang/JNullType.hh"
#include "JLang/JClass.hh"
#include "JLang/JComparable.hh"
#include "JLang/JType.hh"
#include "JLang/JNumber.hh"
#include "JMath/JMath.hh"
#include "JIO/JSerialisable.hh"


/**
 * \file
 * Data structure based on type list.
 * \author mdejong
 */
namespace JTOOLS {}
namespace JPP { using namespace JTOOLS; }

namespace JTOOLS {

  using JLANG::JTypeList;
  using JLANG::JTYPELIST;
  using JLANG::JNullType;
  using JLANG::JClass;
  using JLANG::JType;
  using JLANG::JNumber;
  using JLANG::for_each;
  using JMATH::JMath;
  using JLANG::JComparable;
  using JIO::JReader;
  using JIO::JWriter;


  /**
   * Template data structure.
   */
  template<class T>
  struct JTuple :
    public JMath      < JTuple<T> >,
    public JComparable< JTuple<T> >
  {

    typedef JTypeList<T>  typelist;

    /**
     * Default constructor.
     */
    JTuple()
    {}


    /**
     * Constructor.
     *
     * \param   __first        first
     */
    JTuple(typename JClass<T>::argument_type __first) :
      first(__first)
    {}


    /**
     * Negate tuple.
     *
     * \return                 this tuple
     */
    JTuple& negate()
    {
      first = -first;
 
      return *this;
    }


    /**
     * Add tuple.
     *
     * \param  tuple           tuple
     * \return                 this tuple
     */
    JTuple& add(const JTuple& tuple)
    {
      first += tuple.first;
 
      return *this;
    }


    /**
     * Subtract tuple.
     *
     * \param  tuple           tuple
     * \return                 this tuple
     */
    JTuple& sub(const JTuple& tuple)
    {
      first -= tuple.first;
 
      return *this;
    }


    /**
     * Scale tuple.
     *
     * \param  factor          multiplication factor
     * \return                 this tuple
     */
    JTuple& mul(const double factor)
    {
      first *= factor;
 
      return *this;
    }


    /**
     * Scale tuple.
     *
     * \param  factor          division factor
     * \return                 this tuple
     */
    JTuple& div(const double factor)
    {
      first /= factor;
 
      return *this;
    }


    /**
     * Compare tuple.
     *
     * \param  tuple           tuple
     * \return                 true if this tuple less than given tuple; else false
     */
    bool less(const JTuple& tuple) const
    {
      return first < tuple.first;
    }


    /**
     * Read tuple from input.
     *
     * \param  in              input stream
     * \param  tuple           tuple
     * \return                 input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JTuple& tuple)
    {
      return in >> tuple.first;
    }


    /**
     * Write tuple to output.
     *
     * \param  out             output stream
     * \param  tuple           tuple
     * \return                 output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JTuple& tuple)
    {
      return out << tuple.first;
    }


    /**
     * Read tuple from input.
     *
     * \param  in              reader
     * \param  tuple           tuple
     * \return                 reader
     */
    friend inline JReader& operator>>(JReader& in, JTuple& tuple)
    {
      return in >> tuple.first;
    }


    /**
     * Write tuple to output.
     *
     * \param  out             writer
     * \param  tuple           tuple
     * \return                 writer
     */
    friend inline JWriter& operator<<(JWriter& out, const JTuple& tuple)
    {
      return out << tuple.first;
    }


    T first;
  };
  


  /**
   * Template specialisation of JTuple for multiple data types.
   */
  template<class JHead_t, class JTail_t>
  struct JTuple< JTypeList<JHead_t, JTail_t> > :
    public JMath      < JTuple< JTypeList<JHead_t, JTail_t> > >,
    public JComparable< JTuple< JTypeList<JHead_t, JTail_t> > >
  {
    
    typedef JTypeList<JHead_t, JTail_t>  typelist;


    /**
     * Default constructor.
     */
    JTuple()
    {}


    /**
     * Constructor.
     *
     * \param   __first        first
     * \param   __second       second
     */
    JTuple(typename JClass<JHead_t>::argument_type __first, const JTuple<JTail_t>& __second) :
      first (__first),
      second(__second)
    {}


    /**
     * Initialise constructor.
     *
     * \param  value           first value
     * \param  args            remaining values
     */
    template<class ...Args>
    JTuple(typename JClass<JHead_t>::argument_type value, const Args& ...args) :
      first (value),
      second(args...)
    {}


    /**
     * Negate tuple.
     *
     * \return                 this tuple
     */
    JTuple& negate()
    {
      first  = -first;
      second.negate();
 
      return *this;
    }


    /**
     * Add tuple.
     *
     * \param  tuple           tuple
     * \return                 this tuple
     */
    JTuple& add(const JTuple& tuple)
    {
      first  +=  tuple.first;
      second.add(tuple.second);
 
      return *this;
    }


    /**
     * Subtract tuple.
     *
     * \param  tuple           tuple
     * \return                 this tuple
     */
    JTuple& sub(const JTuple& tuple)
    {
      first  -=  tuple.first;
      second.sub(tuple.second);
 
      return *this;
    }


    /**
     * Scale tuple.
     *
     * \param  factor          multiplication factor
     * \return                 this tuple
     */
    JTuple& mul(const double factor)
    {
      first  *=  factor;
      second.mul(factor);
 
      return *this;
    }


    /**
     * Scale tuple.
     *
     * \param  factor          division factor
     * \return                 this tuple
     */
    JTuple& div(const double factor)
    {
      first  /=  factor;
      second.div(factor);
 
      return *this;
    }


    /**
     * Compare tuple.
     *
     * \param  tuple           tuple
     * \return                 true if this tuple less than given tuple; else false
     */
    bool less(const JTuple& tuple) const
    {
      if (first == tuple.first)
	return second < tuple.second;
      else
	return first  < tuple.first;
    }


    /**
     * Read tuple from input.
     *
     * \param  in              input stream
     * \param  tuple           tuple
     * \return                 input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JTuple& tuple)
    {
      in >> tuple.first;
      in >> tuple.second;

      return in;
    }


    /**
     * Write tuple to output.
     *
     * \param  out             output stream
     * \param  tuple           tuple
     * \return                 output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JTuple& tuple)
    {
      out << tuple.first;
      out << ' ';
      out << tuple.second;

      return out;
    }


    /**
     * Read tuple from input.
     *
     * \param  in              reader
     * \param  tuple           tuple
     * \return                 reader
     */
    friend inline JReader& operator>>(JReader& in, JTuple& tuple)
    {
      in >> tuple.first;
      in >> tuple.second;

      return in;
    }


    /**
     * Write tuple to output.
     *
     * \param  out             writer
     * \param  tuple           tuple
     * \return                 writer
     */
    friend inline JWriter& operator<<(JWriter& out, const JTuple& tuple)
    { 
      out << tuple.first;
      out << tuple.second;

      return out;
    }


    JHead_t         first;
    JTuple<JTail_t> second;
  };


  /**
   * Template specialisation of JTuple for two data types.
   */
  template<class JHead_t, class JTail_t>
  struct JTuple< JTypeList<JHead_t, JTypeList<JTail_t, JNullType> > > :
    public JMath      < JTuple<JTypeList<JHead_t, JTypeList<JTail_t, JNullType> > > >,
    public JComparable< JTuple<JTypeList<JHead_t, JTypeList<JTail_t, JNullType> > > >
  {
    
    typedef JTypeList<JHead_t, JTail_t>  typelist;

    /**
     * Default constructor.
     */
    JTuple()
    {}


    /**
     * Constructor.
     *
     * \param   __first        first
     * \param   __second       second
     */
    JTuple(typename JClass<JHead_t>::argument_type __first,
	   typename JClass<JTail_t>::argument_type __second) :
      first (__first),
      second(__second)
    {}


    /**
     * Constructor.
     *
     * \param   __first        first
     * \param   __second       second
     */
    JTuple(typename JClass<JHead_t>::argument_type __first, const JTuple<JTail_t>& __second) :
      first (__first),
      second(__second.first)
    {}


    /**
     * Negate tuple.
     *
     * \return                 this tuple
     */
    JTuple& negate()
    {
      first  = -first;
      second = -second;
 
      return *this;
    }


    /**
     * Add tuple.
     *
     * \param  tuple           tuple
     * \return                 this tuple
     */
    JTuple& add(const JTuple& tuple)
    {
      first  +=  tuple.first;
      second +=  tuple.second;
 
      return *this;
    }


    /**
     * Subtract tuple.
     *
     * \param  tuple           tuple
     * \return                 this tuple
     */
    JTuple& sub(const JTuple& tuple)
    {
      first  -=  tuple.first;
      second -=  tuple.second;
 
      return *this;
    }


    /**
     * Scale tuple.
     *
     * \param  factor          multiplication factor
     * \return                 this tuple
     */
    JTuple& mul(const double factor)
    {
      first  *=  factor;
      second *=  factor;
 
      return *this;
    }


    /**
     * Scale tuple.
     *
     * \param  factor          division factor
     * \return                 this tuple
     */
    JTuple& div(const double factor)
    {
      first  /=  factor;
      second /=  factor;
 
      return *this;
    }


    /**
     * Compare tuple.
     *
     * \param  tuple           tuple
     * \return                 true if this tuple less than given tuple; else false
     */
    bool less(const JTuple& tuple) const
    {
      if (first == tuple.first)
	return second < tuple.second;
      else
	return first  < tuple.first;
    }


    /**
     * Read tuple from input.
     *
     * \param  in              input stream
     * \param  tuple           tuple
     * \return                 input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JTuple& tuple)
    {
      in >> tuple.first;
      in >> tuple.second;

      return in;
    }


    /**
     * Write tuple to output.
     *
     * \param  out             output stream
     * \param  tuple           tuple
     * \return                 output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JTuple& tuple)
    {
      out << tuple.first;
      out << ' ';
      out << tuple.second;

      return out;
    }


    /**
     * Read tuple from input.
     *
     * \param  in              reader
     * \param  tuple           tuple
     * \return                 reader
     */
    friend inline JReader& operator>>(JReader& in, JTuple& tuple)
    {
      in >> tuple.first;
      in >> tuple.second;

      return in;
    }


    /**
     * Write tuple to output.
     *
     * \param  out             writer
     * \param  tuple           tuple
     * \return                 writer
     */
    friend inline JWriter& operator<<(JWriter& out, const JTuple& tuple)
    { 
      out << tuple.first;
      out << tuple.second;

      return out;
    }


    JHead_t first;
    JTail_t second;
  };


  /**
   * Terminator class of recursive JTuple class.
   */
  template<class JHead_t>
  struct JTuple< JTypeList<JHead_t, JNullType> > :
    public JTuple<JHead_t>
  {
    
    typedef JTypeList<JHead_t>  typelist;

    /**
     * Default constructor.
     */
    JTuple()
    {}


    /**
     * Constructor.
     *
     * \param   __first        first
     */
    JTuple(typename JClass<JHead_t>::argument_type __first) :
      JTuple<JHead_t>(__first)
    {}


    /**
     * Constructor.
     *
     * \param   __first        first
     * \param   __second       second
     */
    JTuple(typename JClass<JHead_t>::argument_type __first, const JTuple<JNullType>& __second) :
      JTuple<JHead_t>(__first)
    {}
  };



  /**
   * For each data type method.
   *
   * The given object should provide for the function object operator
   * <pre>
   *    template<class T>
   *    void object()(JType<T> type, tuple);
   * </pre>
   *
   * \param  object           object
   * \param  typelist         type list
   * \param  tuple            tuple
   * \return                  object
   */
  template<class JObject_t, class JHead_t, class JTail_t, class T>
  JObject_t& for_each(JObject_t& object, JType< JTypeList<JHead_t, JTail_t> > typelist, const JTuple<T>& tuple)
  {
    for_each(object, JType<JHead_t>(), tuple);
    for_each(object, JType<JTail_t>(), tuple);

    return object;
  }


  /**
   * For each data type method.
   *
   * The given object should provide for the function object operator
   * <pre>
   *    template<class T>
   *    void object()(JType<T> type, tuple);
   * </pre>
   *
   * \param  object           object
   * \param  type             type
   * \param  tuple            tuple
   * \return                  object
   */
  template<class JObject_t, class JTypelist_t, class T>
  JObject_t& for_each(JObject_t& object, JType<JTypelist_t> type, const JTuple<T>& tuple)
  {
    object(type, tuple);

    return object;
  }


  /**
   * Helper method for tuple.
   *
   * \param  args            values
   * \return                 tuple
   */
  template<class ...Args>
  inline JTuple<typename JTYPELIST<Args...>::typelist> make_tuple(const Args& ...args)
  {
    return JTuple<typename JTYPELIST<Args...>::typelist>(args...);
  }


  /**
   * Termination method of for each data type method.
   *
   * \param  object           object
   * \param  type             null type
   * \param  tuple            tuple
   * \return                  object
   */
  template<class JObject_t, class T>
  JObject_t& for_each(JObject_t& object, JType<JNullType> type, const JTuple<T>& tuple)
  {
    return object;
  }
}

#endif