#include <string>
#include <memory>

#include "Individual.hpp"
#include "Mlp.hpp"
#include "Dataset.hpp"
#include "MlpObjectives.hpp"

using namespace std;

#ifndef MLPINDIVIDUAL_HPP_
#define	MLPINDIVIDUAL_HPP_

class MlpIndividual;

// FIXME: Design proper datatypes for the set of objectives to evaluate:
/** A tentative unary operator for improvement. FIXME: design these holistically.*/
class MlpBackpropUnaryOperator{
private:
    size_t _iters;
    double _step;
    double _preErr;
    double _incRat;
    double _decRat;
    vector<double> _classweights;
    double _sswpen;
    bool _rerandomize;
    bool _applyssw;
    bool _mee;
public:
    MlpBackpropUnaryOperator(size_t iters, double step, const vector<double> & classweights, bool rerandomize, bool applyssw, bool mee);
    void operate(MlpIndividual & mi, mt19937 * mt);
};

/** Concrete MLP individual for Pareto memetic optimization. */
class MlpIndividual : public Individual {
    friend class MlpBackpropUnaryOperator; // the operator simply needs tight coupling(?)
private:
    unique_ptr<jymlp::Mlp> mlp;
    shared_ptr<Dataset> ds;
    MlpObjKind objkind; /**< which objectives to evaluate */

    // Mock-up part which actually isn't fully designed as of yet:
    unique_ptr<MlpBackpropUnaryOperator> improver;
protected:
    void impl_from_stream(istream& repr);
    void impl_to_stream(ostream& repr);
//  void internal_evaluate_objectives(const vector<double> &invec, const vector<double> &target);
//  void internal_evaluate_one_vec(const vector<double> &v);
    /** This is specific to MlpIndividual. FIXME: Probably to go away.*/
    void crossWith(MlpIndividual &other);
public:
    /** Construct uninitialized; only for reading values very soon. */
    MlpIndividual();

    /** Constructor by taking ownership of a jyu::Mlp instance and
     * shared ownership of a dataset. All of these are required for
     * meaningful computations.
     */
    MlpIndividual(const MlpObjectives& mobj, unique_ptr<jymlp::Mlp> imlp, shared_ptr<Dataset> ids);

    // Deep-copying constructor
    MlpIndividual(const MlpIndividual & original);

    virtual ~MlpIndividual();

    virtual void addUnaryOperator(unique_ptr<MlpBackpropUnaryOperator> uop);

    virtual Individual * clone();

    virtual void evaluate();

    virtual void mutate();

    virtual void improve(mt19937 * mt);

    virtual vector<double> getTrace();

    virtual pair<unique_ptr<Individual>,unique_ptr<Individual> >
        crossWith(Individual & other);


};

class MlpIndividualReader : public IndividualReader{
public:
    virtual Individual * fromStream(istream & ist) const;
};

/* Likely not necessary (?) ... we'll see..
class MlpIndividualEvaluator : public IndividualEvaluator{
    shared_ptr<Dataset> ds;
public:
    MlpIndividualEvaluator(string inistr);
    evaluate(const & MlpIndividual indiv);
};
*/

#endif