#ifndef _FL_GENERAL_

#define _FL_GENERAL_

#include <frams/util/sstring.h>
#include <frams/param/mutableparam.h>
#include <frams/param/paramobj.h>
#include <vector>
#include <list>
#include <unordered_map>
#include <frams/model/model.h>
#include "fL_matheval.h"

/// determines to which class fL element belongs
enum fLElementType {
	TERM, ///< word of L-System
	INFO, ///< fL_Builder object
	RULE, ///< rule of L-System
	BRANCH ///< special type of fL word, which represents branch
};

/** @name Constants used in fL methods */
//@{
#define PART_PROPS_COUNT   4 ///<Count of part properties
#define JOINT_PROPS_COUNT  3 ///<Count of joint properties
#define PE_NEURO_DET       "d" ///<Id of details type definition in f0_neuro_paramtab
#define PE_CONN_WEIGHT     "w" ///<Id of weight type definition in f0_neuroconn_paramtab
//@}

extern const char *fL_part_names[];
extern const char *fL_joint_names[];
extern const char *fL_joint_fullnames[JOINT_PROPS_COUNT];
extern const char *fL_part_fullnames[PART_PROPS_COUNT];

#define LSYSTEM_PARAM_TYPE "s" ///< standard type of L-System elements

class fL_Builder;

/**
 * Most abstract class of L-System. It requires from inheriting classes to implement
 * methods processDefinition and toString.
 */
class fL_Element
{
public:
	fLElementType type; ///< type of fL_Element

	fL_Element(fLElementType type) : type(type) {}
	virtual ~fL_Element() { }

	/**
	 * Performs connecting current element to fL_Builder and parsing of input
	 * with respect of builder.
	 * @param builder fL_Builder object responsible for creating this element
	 * @return 0 if processing went successfully, other values otherwise
	 */
	virtual int processDefinition(fL_Builder *builder) = 0;

	/**
	 * Creates string line for current element. This method is used by Builder
	 * to create string representation of words, rules and informations of L-System.
	 * @return stringified element
	 */
	virtual SString toString() = 0;
};

/**
 * Represents word objects of L-System representation. They are used in axiom,
 * produced sequences and rules.
 */
class fL_Word : public fL_Element
{
public:
	SString name; ///<name of word
	int npar; ///<number of word parameters
	MutableParam mut; ///<MutableParam for word parameters
	ParamEntry *tab; ///<ParamTab used for loading and saving properties of word
	void *data; ///<pointer to properties of word
	bool builtin; ///<determines if word is built-in (true) or not (false).
	std::vector<MathEvaluation *> parevals; ///<stores MathEvaluation objects with parameter functions
	double creationiter; ///<this helper field is used during L-System iterations and determines when word was created
	fL_Word(bool builtin = false) :
		fL_Element(fLElementType::TERM), mut("Word", "Properties"), //TODO change Word to Term everywhere
		builtin(builtin)
	{
		name = "";
		npar = 0;
		tab = NULL;
		data = NULL;
		creationiter = 0;
	}

	/**
	 * Destroys data ParamObject and MathEvaluation objects. ParamTab for Word
	 * should be deleted separately, because all words with same name share same
	 * pointer to ParamTab.
	 */
	~fL_Word()
	{
		if (data)
			ParamObject::freeObject(data);
		for (MathEvaluation *ev : parevals)
		{
			delete ev;
		}
		parevals.clear();
	}

	/**
	 * Checks if there is no other word stored in the builder with the same name,
	 * prepares ParamTab for defined word and adds created word definition to the
	 * builder.
	 * @param builder pointer to the builder that process this word definition
	 * @return 0 if word is added, 1 if word is redefined
	 */
	int processDefinition(fL_Builder *builder);

	/**
	 * Operator copies name string, npar value, pointer to ParamTab and pointers
	 * to MathEvaluation objects for parameters. It sets data of this word to
	 * NULL.
	 * @param src source word
	 */
	void operator=(const fL_Word& src);

	/**
	 * TODO
	 */
	bool operator==(const fL_Word& other) const;

	/**
	 * Returns 'w:' line defining word in genotype.
	 * @return string representation of word definition
	 */
	virtual SString toString();

	/**
	 * Returns token version of this word. It is used during converting successor's
	 * list or axiom list into strings. Flag 'keepformulas' should be set to true
	 * if word parameters should be represented as formulas, and set to false if
	 * word parameters should contain the result of evaluation.
	 * @param keepformulas true if parameters should have mathematical formula, false if it should have result of evaluation
	 */
	virtual SString stringify(bool keepformulas = true);

	/**
	 * Saves formulas or evaluations of parameters in ParamObject.
	 * @param keepformulas true if parameters should have mathematical formula, false if it should have result of evaluation
	 * @return 0 if method successfully managed to save data, 1 if an error occured
	 */
	int saveEvals(bool keepformulas);
};

/**
 * Represents special branching word in L-System genotype.
 */
class fL_Branch : public fL_Word
{
public:
	/// Determines if branching parenthesis is opened or closed
	enum BranchType {
		OPEN,
		CLOSE
	};
	BranchType btype; ///< branch parenthesis type
	fL_Branch(BranchType branchtype) : fL_Word()
	{
		type = fLElementType::BRANCH;
		btype = branchtype;
		name = stringify();
	}
	SString toString() { return ""; };
	SString stringify(bool keepformulas = false) { return btype == BranchType::OPEN ? "[" : "]"; }
};

/**
 * Represents rules in L-System genotype. Every rule has predecessor and successors.
 * The optional argument is a condition of deploying rule. Every rule is ran
 * synchronously for every letter of the current genotype. If condition and
 * predecessor are satisfied, then predecessor is replaced by successors.
 */
class fL_Rule : public fL_Element
{
public:
	SString predecessor; ///<string representation of the predecessor
	SString condition; ///<string representation of the condition
	SString successor; ///<string representation of the successor

	fL_Word *objpred; ///<object representation of the predecessor
	MathEvaluation *condeval; ///<object representation of the condition

	std::list<fL_Word *> objsucc; ///<objec representation of successors

	int start; ///<beginning of the rule definition in genotype
	int end; ///<end of the rule definition in genotype

	fL_Rule(int start, int end) : fL_Element(fLElementType::RULE),
		start(start), end(end)
	{
		predecessor = "";
		condition = "";
		successor = "";
		objpred = NULL;
		condeval = NULL;
	}

	~fL_Rule()
	{
		if (objpred) delete objpred;
		if (condeval) delete condeval;
		for (fL_Word *word : objsucc)
		{
			delete word;
		}
		objsucc.clear();
	}

	/**
	 * Loads rule definition from the genotype, checks if word defined in
	 * predecessor does exist, tokenizes successor and condition.
	 * @param builder pointer to the builder that process this word definition
	 * @return 0 if word is added, 1 if an error occured during parsing
	 */
	int processDefinition(fL_Builder *builder);

	SString toString();

	/**
	 * Runs rule for a given word, if all conditions and starting rules are satisfied.
	 * Method alters given list of tokens by removing matching word pointed by
	 * pointer and iterator of list and inserting successor sequence into list.
	 * Final iterator value points to the first word after processed word.
	 * @param in word that is currently processed
	 * @param it iterator of genotype list which determines position of current analysis
	 * @param genotype current genotype. Words on the left of genotype are processed and possibly replaced by previous rules
	 * @param currtime value representing continuous time value for rule
	 * @return 0 if rule processed current word, 1 if rule is no applicable
	 */
	int deploy(fL_Word *in, std::list<fL_Word *>::iterator &it, std::list<fL_Word *> &genotype, double currtime);
};

struct fL_State
{
	Pt3D direction; ///<Direction of turtle
	Part *currpart; ///<Latest created part
	Neuro *currneuron; ///<Latest created neuron
	fL_State() : direction(1, 0, 0), currpart(NULL), currneuron(NULL)
	{ }
};

/**
 * Main class of L-System processing. It holds all information required to perform
 * steps of development of a creature. It allows to create Timed D0L-Systems with
 * following limitations:
 *
 *  - fractions of time affect only parameters of currently produced words,
 *  - integer steps deploy rules in order to develop new elements of body,
 *  - if parameter should use time fraction, then $t variable must be used,
 *  - $t variable always contain values from 0 to 1 that represent current fraction
 *    of step.
 */
class fL_Builder : public fL_Element
{
public:
	SString axiom; ///<starting sequence of genotype
	double time; ///<time of creature development
	int numckp; ///<number of checkpoints per growth step - checkpoints are always created after rules deployment in integer steps, numckp determines how many checkpoints should be created within single step (to watch changes of parameters)

	std::list<fL_Word *> genotype; ///<list of current words of genotype
	std::unordered_map<std::string, fL_Word *> words; ///<map from string to words existing in L-System
	std::vector<fL_Rule *> rules; ///<rules available in system

	fL_Builder() : fL_Element(fLElementType::INFO)
	{
		axiom = "";
		time = 1.0;
		numckp = 1;
	}
	~fL_Builder();

	/**
	 * Helper function for trimming leading and trailing spaces from sequence.
	 * @param data input string
	 * @return string with trimmed spaces
	 */
	static std::string trimSpaces(std::string data);

	/**
	 * Processes single line of input sequence and load line properties with use
	 * of proper ParamTab.
	 * @param type which type of line is this
	 * @param line line to be processed
	 * @param obj variable storing pointer to created L-System element
	 * @param linenumber for error messages
	 * @param begin index of first character of line
	 * @param end index of last character of line
	 * @return 0 if processing ended successfully, 1-based position of error otherwise
	 */
	int processLine(fLElementType type, SString line, fL_Element *&obj, int linenumber, int begin, int end);

	/**
	 * Parses input genotype with words, information and rules. First of all,
	 * model-specific words defined in addModelWords method are added to words map.
	 * Every genotype should start with words definitions. They cannot collide
	 * with model words and with each other. Secondly, information line, containing
	 * axiom and number of iteration must be processed. In the end, all rules
	 * have to be processed by builder. After determining line type and creating
	 * fL_Element specialized object, the builder runs object's processDefinition
	 * method to generate all important objects and register element in builder
	 * structures.
	 * @param genotype input genotype
	 * @return 0 if processing finished successfully, 1-based position of error if it occured
	 */
	int parseGenotype(SString genotype);

	/**
	 * Prepares structures and tokenizes axiom.
	 * @param builder this method should receive pointer to itself
	 * @return 0 if processing went successfully, 1 otherwise
	 */
	int processDefinition(fL_Builder *builder);

	/**
	 * Adds words used for Framsticks body and brain development.
	 */
	void addModelWords();

	/**
	 * Helper method that tokenizes string sequence by closing parenthesis
	 * with respect to parenthesis nesting.
	 * @param pos index of character, from which next token needs to be extracted. Method replaces this parameter with next starting position, or -1 if there was an error during parsing, like parenthesis mismatch
	 * @param src original sequence
	 * @param token reference to variable holding new token
	 * @return true if new token is found, false if there is no more tokens or when there was parenthesis mismatch (if pos == -1, then it is parenthesis mismatch)
	 */
	bool getNextObject(int &pos, SString src, SString &token);

	/**
	 * Helper function that converts input sequence into list of L-System words.
	 * @param sequence input sequence of stringified word objects
	 * @param result reference to list holding generated words
	 * @param numparams number of parameters that can be used for words stored in result list
	 * @return 0 if tokenizing finished successfully, 1 otherwise
	 */
	int tokenize(SString sequence, std::list<fL_Word *> &result, int numparams);

	/**
	 * Uses rules to process current genotype and make next iteration step for
	 * L-System development.
	 * @param currtime current time of genotype processing
	 * @return always 0
	 */
	int iterate(double currtime);

	/**
	 * Alters only parameters that depend on time. Should be used if only fraction
	 * of iteration has changed, not integer part.
	 * @param currtime current time of processing
	 * @return always 0
	 */
	int alterTimedProperties(double currtime);

	/**
	 * Developes L-System from given genotype and builds Framsticks Model from it.
	 */
	int develop();

	/**
	 * Creates new checkpoint for a given model based on current state of genotype.
	 * @param model reference to model
	 * @return 0 if developing went successfully, 1 otherwise
	 */
	int developModel(Model &model);

	/**
	 * Returns stringified product of L-System development.
	 * @return stringified words of developed L-System
	 */
	SString getStringifiedProducts();

	/**
	 * Returns genotype stored by objects in fL_Builder.
	 * @return genotype converted from L-System objects
	 */
	SString toString();

	/**
	 * TODO
	 */
	int alterPartProperties(Part *part, fL_Word *stickword, double &alterationcount);

	/**
	 * TODO
	 */
	Neuro *findInputNeuron(std::list<fL_Word *> genotype, std::list<fL_Word *>::iterator it, fL_Word *attractor);

	/**
	 * TODO
	 */
	void findNext(fL_Word *word, std::list<fL_Word *> genotype, std::list<fL_Word *>::iterator &it);
};

#endif // _FL_GENERAL_