#ifndef __JOSCPROB__JOSCPARAMETERSHELPER__
#define __JOSCPROB__JOSCPARAMETERSHELPER__

#include <memory>

#include "JLang/JException.hh"

#include "JOscParametersInterface.hh"


/**
 * \author bjung
 */

namespace JOSCPROB {}
namespace JPP { using namespace JOSCPROB; }

namespace JOSCPROB {
  
  /**
   * Helper class for oscillation parameters.
   */
  template<class T = double>
  struct JOscParametersHelper :
    public std::shared_ptr<JOscParametersInterface<T> >
  {
    typedef JOscParametersHelper<T>                     JOscParametersHelper_t;
    typedef JOscParametersInterface<T>                  JOscParameters_t;
    
    typedef typename JOscParameters_t::JOscParameter_t  JOscParameter_t;
    typedef typename JOscParameters_t::JParameter_t     JParameter_t;
    typedef typename JOscParameters_t::argument_type    argument_type;
    
    typedef std::shared_ptr<JOscParameters_t>           pointer_type;

    using pointer_type::reset;

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


    /**
     * Constructor.
     *
     * \param  parameters          oscillation parameters
     */
    JOscParametersHelper(const JOscParameters_t& parameters)
    {
      this->configure(parameters);
    }


    /**
     * Constructor.
     *
     * \param  parameters      oscillation parameters
     * \param  name            parameter name
     * \param  value           parameter value
     * \param  args            remaining pairs of parameter names and values
     */
    template<class ...Args>
    JOscParametersHelper(const JOscParameters_t& parameters,
			 const std::string&      name,
			 argument_type           value,
			 const Args&          ...args)
    {
      this->configure(parameters);
      this->set(name, value, args...);
    }


    /**
     * Configure oscillation parameters.
     *
     * \param  parameters          oscillation parameters
     */    
    virtual void configure(const JOscParameters_t& parameters)
    {
      using namespace std;
      using namespace JPP;
      
      JOscParameters_t* p = dynamic_cast<JOscParameters_t*>(parameters.clone());

      if (p != NULL) {
	reset(p);
      } else {
	THROW(JNullPointerException, "JOscParametersHelper::configure(): Unable to retrieve oscillation parameters interface.");
      }
    }


    /**
     * Get reference to oscillation parameters interface.
     *
     * \return                 reference to oscillation parameters interface
     */
    JOscParameters_t& getParameters() const
    {
      using namespace JPP;

      if (static_cast<const JOscParametersHelper_t&>(*this)) {
	return *(this->get());
      } else {
	THROW(JNullPointerException, "JOscParametersHelper::getParameters(): Oscillation parameters interface is not set.");
      }
    }


    /**
     * Set value for a given oscillation parameter.
     *
     * \param  name            parameter name
     * \param  value           parameter value
     */
    virtual void set(const std::string& name,
		     argument_type      value) const
    {
      getParameters().set(name, value);
    }


    /**
     * Set value for given list of oscillation parameters.
     *
     * \param  name            parameter name
     * \param  value           parameter value
     * \param  args            remaining pairs of parameter names and values
     */
    template<class ...Args>
    void set(const std::string& name,
	     argument_type      value,
	     const Args&     ...args) const
    {
      this->set(name, value);
      this->set(args...);
    }


    /**
     * Set oscillation parameters.
     *
     * \param  parameters      oscillation parameters
     */
    void set(const JOscParameters_t& parameters) const
    {
      using namespace std;
      using namespace JPP;

      const JProperties properties = parameters.getProperties();

      for (JProperties::const_iterator i = properties.cbegin(); i != properties.cend(); ++i) {
	const JOscParameter_t& parameter = i->second.getValue<const JOscParameter_t>();
	
	this->set(i->first, parameter.getValue());
      }
    }


    /**
     * Check validity of oscillation parameters.
     *
     * \return                 true if all oscillation parameters are valid; else false
     */
    bool is_valid() const
    {
      return getParameters().is_valid();
    }
  };
}

#endif