#ifndef __JTOOLS__JROUTER__
#define __JTOOLS__JROUTER__

#include <vector>
#include <algorithm>

#include "JLang/JComparisonAvailable.hh"
#include "JLang/JClass.hh"


/**
 * \author mdejong
 */

namespace JTOOLS {}
namespace JPP { using namespace JTOOLS; }

namespace JTOOLS {

  using JLANG::JComparisonAvailable;


  /**
   * Direct addressing of elements with unique identifiers.
   */
  template<class JAddress_t, bool has_eq = JComparisonAvailable<JAddress_t>::has_eq>
  class JRouter;


  /**
   * Template specialisation of JRouter without default address comparison.
   */
  template<class JAddress_t>
  class JRouter<JAddress_t, false> :
    protected std::vector<JAddress_t>
  {

    typedef typename JLANG::JClass<JAddress_t>::argument_type  argument_type;

  public:
    /**
     * Default constructor.
     */
    JRouter() :
      std::vector<JAddress_t>(),
      first(0)
    {}


    /**
     * Virtual destructor.
     */
    virtual ~JRouter()
    {}


    /**
     * Get default address.
     *
     * \return            default address
     */
    virtual const JAddress_t& getDefaultAddress() const
    {
      static JAddress_t address;

      return address;
    }


    /**
     * Clear.
     */
    void clear()
    {
      static_cast<std::vector<JAddress_t>&>(*this).clear();

      this->first = 0;
    }


    /**
     * Swap router.
     *
     * \param  router     router
     */
    void swap(JRouter& router)
    {
      std::swap(this->first, router.first);

      static_cast<std::vector<JAddress_t>&>(*this).swap(router);
    }


    /**
     * Align router.
     *
     * \param  router     router
     */
    void align(const JRouter& router)
    {
      this->first = router.first;

      if (router.size() > this->size()) {
	this->resize(router.size());
      }
    }

      
    /**
     * Store address for given identifier.
     *
     * \param  id         identifier
     * \param  address    address
     */
    void put(const int id, argument_type address)
    {
      if (this->empty()) {

	this->push_back(address);
	
	this->first = id;
	
      } else if (id < this->first) {

	this->insert(this->begin(), this->first - id, getDefaultAddress());

	this->first = id;

	(*this)[0] = address;

      } else {

	const size_t index = (size_t) (id - this->first);

	if (index >= this->size()) {
	  this->resize(index + 1, getDefaultAddress());
	}

	(*this)[index] = address;
      }
    }

    
    /**
     * Check whether given identifier is in range of this router.
     *
     * \param  id         identifier
     * \return            true if in range; else false
     */
    bool in_range(const int id) const
    {
      return (id >= this->first && id < this->first + (int) this->size());
    }

    
    /**
     * Get address of given identifier.
     *
     * \param  id         identifier
     * \return            address
     */
    const JAddress_t& get(const int id) const
    {
      return (*this)[id - this->first];
    }

  protected:
    int first;
  };


  /**
   * Template specialisation of JRouter with default address comparison.
   */
  template<class JAddress_t>
  class JRouter<JAddress_t, true> :
    public JRouter<JAddress_t, false>
  {

    typedef typename JLANG::JClass<JAddress_t>::argument_type  argument_type;

  protected:
    /**
     * Simple data structure for validation of address.
     */
    class JAddress
    {
    public:
      /**
       * Default constructor.
       */
      JAddress() :
	__is_valid(false),
	__address ()
      {}


      /**
       * Constructor.
       *
       * \param  address    default address
       */
      JAddress(argument_type address) :
	__is_valid(true),
	__address (address)
      {}


      /**
       * Check validity.
       *
       * \return            true if valid; else false
       */
      bool is_valid() const
      {
	return __is_valid;
      }


      /**
       * Get address.
       *
       * \return            address
       */
      const JAddress_t& getAddress() const
      {
	return __address;
      }

      
      /**
       * Compare to given address.
       *
       * \param  address    address
       * \return            true if valid and equal; else false
       */
      bool equals(argument_type address) const
      {
	return __is_valid && address == __address;
      }


    private:
      bool       __is_valid;
      JAddress_t __address;
    };


  public:
    /**
     * Default constructor.
     */
    JRouter() :
      JRouter<JAddress_t, false>(),
      defaultAddress()
    {}


    /**
     * Constructor.
     *
     * \param  address    default address
     */
    JRouter(argument_type address) :
      JRouter<JAddress_t, false>(),
      defaultAddress(address)
    {}


    /**
     * Check availability of default address.
     *
     * \return            true if available; else false
     */
    bool hasDefaultAddress() const
    {
      return defaultAddress.is_valid();
    }


    /**
     * Get default address.
     *
     * \return            default address
     */
    virtual const JAddress_t& getDefaultAddress() const override 
    {
      return defaultAddress.getAddress();
    }


    /**
     * Set default address.
     *
     * \param  address    default address
     */
    void setDefaultAddress(argument_type address)
    {
      defaultAddress = JAddress(address);
    }

    
    /**
     * Test whether given identifier has valid address (i.e identifier is in range and corresponding address is not equal to default address).
     *
     * \param  id         identifier
     * \return            true if identifier in range and address not equal to default; else false
     */
    bool has(const int id) const
    {
      return (this->in_range(id) && !this->defaultAddress.equals(this->get(id)));
    }


  private:
    JAddress defaultAddress;
  };
}

#endif