/*
 *  conv_f8tof1.h
 *  L-systemToF1
 *
 *  Created by Maciej Wajcht on 08-03-21.
 *  Copyright 2008 __MyCompanyName__. All rights reserved.
 *
 */

#ifndef _CONV_F8_TO_F1_H
#define _CONV_F8_TO_F1_H

#include <map>
#include <vector>
#include <string>
#include <list>
#include <iostream>
#include "genoconv.h"
#include "model.h"

using std::ostream;
using std::vector;
using std::list;
using std::string;
using std::map;

enum RelationType {
	r_greater,
	r_greaterEqual,
	r_less,
	r_lessEqual,
	r_equal,
	r_different
};

class Condition {
public:
	RelationType relation;
	SString parameter;
	double value;
	
	friend ostream& operator<<(ostream& os, const Condition& c);
};

class ActionP;

class Action {
public:
	SString name;
	bool ignoreParams;
	virtual const SString getF1Genotype(vector<double> params) = 0;
	virtual const list<ActionP> getActionList(const vector<double> params) = 0;
	virtual const SString getF8Representation() = 0;
	virtual ~Action() {}
};

class ActionStrP {
public:
	Action *action;
	vector<SString> params;
};

class ActionP {
public:
	Action *action;
	vector<double> params;
};

class SubProduction {
public:
	vector<Condition> conditions;
	vector<ActionStrP> actions;
};

class PrimitiveProduction : public Action {
public:
	PrimitiveProduction(const SString command);
	const SString getF1Genotype(const vector<double> params);
	const list<ActionP> getActionList(const vector<double> params);
	const SString getF8Representation();
protected:
	SString f1command;
	SString f8command;
};

class ParamProduction : public Action {
public:
	ParamProduction(const SString paramName);
	const SString getF1Genotype(const vector<double> params);
	const list<ActionP> getActionList(const vector<double> params);
	const SString getF8Representation();
protected:
	SString paramName;
};

class NeuronProduction : public Action {
public:
	NeuronProduction(SString body);
	const SString getF1Genotype(const vector<double> params);
	const list<ActionP> getActionList(const vector<double> params);
	const SString getF8Representation();
protected:
	SString body;
};

/**
 * Pozycje liczone od 1 a nie od 0!
 */
class ParameterCollection {
public:
	const double getValue(int position);
	const double getValue(SString name);
	const SString getParameterName(int position);
	const int getParameterPosition(SString name); //zwróci index liczony od 1!
	void setValue(int position, double value);
	void setValue(SString name, double value);
	void addParameter(SString name, int position = -1, double value = 0.0);
	const int size();
	void removeParameter(int position);
	void removeParameter(SString name);
	bool paramExist(SString name);
protected:
	vector<string> parameters;
	map<string, double> paramValues;
};

class Production : public Action {
public:
	ParameterCollection parameters;
	vector<SubProduction> subproductions;
	
	Production();
	~Production() {};
	const SString getF1Genotype(const vector<double> params);
	const list<ActionP> getActionList(const vector<double> params);
	const SString getF8Representation();
};

class Lsystem {
public:
	int iterations;
	map<string, double> startParams;
	map<string, Production*> productions;
	vector<NeuronProduction*> neuronProductions;
	string firstProductionName;
	
	Lsystem();
	~Lsystem();
	PrimitiveProduction* getPrimitiveProduction(SString name);
	ParamProduction* getParamProduction(SString name);
	SString toString();
	vector<Action*> getAllActions(bool normal, bool primitives, bool params, bool neurons);
protected:
	map<string, PrimitiveProduction*> primitiveProductions;
	map<string, ParamProduction*> paramProductions;
	
	void removeEmptySubproductionsAndProductions();
};

class GenoConv_F8ToF1 : public GenoConverter {
public:
	GenoConv_F8ToF1() {
		name = "f8 to f1 converter";
		in_format = '8';
		out_format = '1';
		mapsupport = 0;
		info = "ble";
	}
	
	~GenoConv_F8ToF1() {}
	
	SString convert(SString &in, MultiMap *map);
	bool checkSyntax(const char *geno);
	vector<SString> readProductionNames(const SString &in);
	//Lsystem* createLsystem(const SString &in);
	Lsystem* createLsystem(SString in);
protected:
	bool parseInput(const char* src, Lsystem* lsys);
};

#endif