/*
 * This file is a part of morm
 * and is distributed under the 2-Clause BSD licence.
 * Author: Tomasz Sowa <t.sowa@ttmath.org>
 */

/*
 * Copyright (c) 2018-2019, Tomasz Sowa
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */

#ifndef headerfile_morm_baseexpression
#define headerfile_morm_baseexpression

#include <list>
#include <set>
#include "textstream/textstream.h"
#include "date/date.h"
#include "morm_types.h"
#include "modelenv.h"



namespace morm
{
class Model;
class ModelConnector;


class BaseExpression
{
public:

	BaseExpression();
	virtual ~BaseExpression();

	virtual void set_work_mode(int work_mode);
	virtual int  get_work_mode();

	virtual void prepare_to_new_expression();
	virtual void set_column_prefix(const std::string & prefix);
	virtual void set_column_prefix(const std::string & prefix, int index);

	virtual std::string get_column_prefix();
	virtual int get_column_prefix_index();

	virtual void generate_from_model(PT::TextStream & stream, Model & model);

	virtual PT::TextStream * get_current_stream();

	// rename me
	virtual void allow_to_use_prefix(bool use_prefix);

	// give me a better name
	virtual void put_field_doc(Model & model, const void * field_pointer, bool insertable, bool updatable, bool is_primary_key, ModelEnv * model_env);



	template<typename FieldValue>
	void field(const wchar_t * field_name, const FieldValue & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false,
			   bool add_column_prefix = true, ModelEnv * model_env = nullptr)
	{
		if( out_stream && can_field_be_generated(insertable, updatable, is_primary_key) )
		{
			field_before();

			if( work_mode == MORM_WORK_MODE_MODEL_FIELDS )
			{
				put_field_name(field_name, add_column_prefix);
			}
			else
			if( work_mode == MORM_WORK_MODE_MODEL_SAVE_FIELDS )
			{
				PT::TextStream str;
				PT::TextStream * old_out_stream = out_stream;

				out_stream = &str;
				put_field_name(field_name, add_column_prefix);
				out_stream = old_out_stream;

				if( model_env && model_env->finder_helper )
				{
					model_env->finder_helper->morm_foreign_keys.emplace_back();
					std::string & key_str = model_env->finder_helper->morm_foreign_keys.back();
					str.to_string(key_str, false);
				}
			}
			else
			if( work_mode == MORM_WORK_MODE_MODEL_VALUES )
			{
				put_field_value(field_value);
			}
			else
			if( work_mode == MORM_WORK_MODE_MODEL_FIELDS_VALUES )
			{
				put_field_name(field_name);
				put_name_value_separator();
				put_field_value(field_value);
			}


			field_after();
		}
	}



	template<typename FieldValue>
	void field_doc(Model & model, const wchar_t * field_name, const FieldValue & field_value,
			bool insertable = true, bool updatable = true,
			bool is_primary_key = false, bool add_column_prefix = true,
			ModelEnv * model_env = nullptr)
	{
		if( out_stream )
		{
			field_before();

			put_field_name(field_name, add_column_prefix);
			put_name_value_separator();

			put_field_doc(model, reinterpret_cast<const void*>(&field_value), insertable, updatable, is_primary_key, model_env);
			put_name_value_separator();

			put_type(field_value, *out_stream);

			field_after();
		}
	}


	/*
	template<typename FieldValue>
	void field(const PT::TextStream & field_name, const FieldValue & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false, bool add_column_prefix = true)
	{
		std::wstring field_name_str; // field() methods can be called recursively, so don't make it as class object
		field_name.to_string(field_name_str);

		return field(field_name_str.c_str(), field_value, insertable, updatable, is_primary_key, add_column_prefix);
	}
	*/

	template<typename FieldValue>
	void field_in(PT::TextStream & stream, const wchar_t * field_name, const std::set<FieldValue> & container)
	{
		field_in_generic<FieldValue, std::set<FieldValue>>(stream, field_name, container);
	}

	template<typename FieldValue>
	void field_in(PT::TextStream & stream, const wchar_t * field_name, const std::list<FieldValue> & container)
	{
		field_in_generic<FieldValue, std::list<FieldValue>>(stream, field_name, container);
	}

	template<typename FieldValue>
	void field_in(PT::TextStream & stream, const wchar_t * field_name, const std::vector<FieldValue> & container)
	{
		field_in_generic<FieldValue, std::vector<FieldValue>>(stream, field_name, container);
	}

	template<typename ModelContainer>
	void field_list(const wchar_t * field_name, ModelContainer & field_value, bool insertable, bool updatable, bool is_primary_key,
				    ModelConnector * model_connector, ModelEnv * model_env)
	{
		if( out_stream && can_field_be_generated(insertable, updatable, is_primary_key) )
		{
			field_before();

//			if( work_mode == MORM_WORK_MODE_MODEL_FIELDS )
//			{
//				put_field_name(field_name);
//			}
//			else
			if( work_mode == MORM_WORK_MODE_MODEL_FIELDS_VALUES )
			{
				put_field_name(field_name);
				put_name_value_separator();
				put_field_value_list(field_value, model_connector, model_env);
			}

			field_after();
		}
	}

	template<typename ModelClass>
	void field_model(const wchar_t * field_name, ModelClass & field_model, bool insertable = true, bool updatable = true, bool is_primary_key = false)
	{
		if( out_stream && can_field_be_generated(insertable, updatable, is_primary_key) )
		{
			field_before();

			if( work_mode == MORM_WORK_MODE_MODEL_FIELDS )
			{
				put_field_name(field_name);
			}
			else
			if( work_mode == MORM_WORK_MODE_MODEL_VALUES )
			{
				generate_from_model(field_model); // is it ok as a value?
			}
			else
			if( work_mode == MORM_WORK_MODE_MODEL_FIELDS_VALUES )
			{
				put_field_name(field_name);
				put_name_value_separator();
				generate_from_model(field_model);
			}

			field_after();
		}
	}

	template<typename FieldValue>
	void field_to_stream(PT::TextStream & stream, const wchar_t * field_name, const FieldValue & field_value, bool insertable = true, bool updatable = true, bool is_primary_key = false)
	{
		this->out_stream = &stream;
		field(field_name, field_value, insertable, updatable, is_primary_key);
		this->out_stream = nullptr;
	}



	virtual void esc(char val, 					PT::TextStream & stream);
	virtual void esc(unsigned char val, 		PT::TextStream & stream);

	virtual void esc(const std::wstring & val, 	PT::TextStream & stream);
	virtual void esc(const wchar_t * val, 		PT::TextStream & stream);

	virtual void esc(const std::string & val, 	PT::TextStream & stream);
	virtual void esc(const char * val, 			PT::TextStream & stream);

	virtual void esc(bool val, 					PT::TextStream & stream);
	virtual void esc(short val, 				PT::TextStream & stream);
	virtual void esc(unsigned short val, 		PT::TextStream & stream);
	virtual void esc(int val, 					PT::TextStream & stream);
	virtual void esc(unsigned int val, 			PT::TextStream & stream);
	virtual void esc(long val, 					PT::TextStream & stream);
	virtual void esc(unsigned long val, 		PT::TextStream & stream);
	virtual void esc(long long val, 			PT::TextStream & stream);
	virtual void esc(unsigned long long val, 	PT::TextStream & stream);
	virtual void esc(float val, 				PT::TextStream & stream);
	virtual void esc(double val, 				PT::TextStream & stream);
	virtual void esc(long double val, 			PT::TextStream & stream);
	//virtual void esc(void* val, 					PT::TextStream & stream);

	virtual void esc(const PT::Date & date, 	PT::TextStream & stream);




protected:

	int work_mode;   /* what to do: generating fields list, values list or fields-values list */
	bool is_first_field;

	// niech Stream bedzie jakims interfejsem z operatorami << dla standardowych typow
	// albo w pikotoolsach dodać klase bazowa (intefejs) dla streamow
	// i dodatkowo dodac loger ktory dziedziczy po niej i dodaje loglevel i endline
	// jako metode bazowa dodac format("string", parametry,...)
	// przyda sie do formatowania doubli
	PT::TextStream * out_stream;


	std::string column_prefix;
	int column_prefix_index;
	bool use_prefix;

	virtual void generate_from_model(Model & model);

	virtual void before_generate_from_model();
	virtual void after_generate_from_model();
	virtual bool can_field_be_generated(bool insertable, bool updatable, bool is_primary_key);
	virtual void field_before();
	virtual void field_after();

	//void field(const wchar_t * field_name, Model & field, bool insertable = true, bool updatable = true);

	virtual void put_field_name(const wchar_t * field_name, bool add_column_prefix = true);

	template<typename FieldValue>
	void put_field_value(const FieldValue & field_value)
	{
		if( out_stream )
		{
			before_field_value(field_value);
			esc(field_value, *out_stream);
			after_field_value(field_value);
		}
	}


	virtual void before_field_value_list()
	{
	}


	virtual void after_field_value_list()
	{
	}


	virtual void field_value_list_separator()
	{
		(*out_stream) << ",";
	}


	// what about lists with a pod types? e.g. list<int>
	template<typename ModelContainer>
	void put_field_value_list(ModelContainer & field_value, ModelConnector * model_connector, ModelEnv * model_env)
	{
		if( model_connector && model_env && out_stream )
		{
			bool is_first = true;
			before_field_value_list();

			for(auto & m : field_value)
			{
				if( !is_first )
				{
					field_value_list_separator();
				}

				ModelEnv model_env_local(*model_env);
				m.model_env = &model_env_local;
				//before_field_value(field_value);
				m.set_connector(model_connector);
				generate_from_model(m);
				m.model_env = nullptr;
				//after_field_value(field_value);
				is_first = false;
			}

			after_field_value_list();
		}
	}


	// used in 'in()' statements, may should be renamed?
	template<typename FieldValue, typename Container>
	void field_in_generic(PT::TextStream & stream, const wchar_t * field_name, const Container & container)
	{
		// IMPROVE ME
		// what about if container is empty?
		// only 'in()' statement would be generated
		this->out_stream = &stream;

		field_before();
		put_field_name(field_name);
		put_name_value_separator();

		bool is_first = true;
		(*out_stream) << "(";

		for(const FieldValue & v : container)
		{
			if( !is_first )
			{
				(*out_stream) << ",";
			}

			put_field_value(v);
			is_first = false;
		}

		(*out_stream) << ") ";
		field_after();
		this->out_stream = nullptr;
	}


	virtual void before_field_name();
	virtual void after_field_name();

	virtual void before_field_value(const std::wstring &);
	virtual void after_field_value(const std::wstring &);

	virtual void before_field_value(const std::string &);
	virtual void after_field_value(const std::string &);

	virtual void before_field_value(const wchar_t *);
	virtual void after_field_value(const wchar_t *);

	virtual void before_field_value(const char *);
	virtual void after_field_value(const char *);

	virtual void before_field_value(const PT::Date &);
	virtual void after_field_value(const PT::Date &);


	template<typename FieldValue>
	void before_field_value(const FieldValue &)
	{
	}

	template<typename FieldValue>
	void after_field_value(const FieldValue &)
	{
	}

	virtual void put_name_value_separator();


	virtual void put_type(char val, 				PT::TextStream & stream);
	virtual void put_type(unsigned char val, 		PT::TextStream & stream);

	virtual void put_type(const std::wstring & val, PT::TextStream & stream);
	virtual void put_type(const wchar_t * val, 		PT::TextStream & stream);

	virtual void put_type(const std::string & val, 	PT::TextStream & stream);
	virtual void put_type(const char * val, 			PT::TextStream & stream);

	virtual void put_type(bool val, 				PT::TextStream & stream);
	virtual void put_type(short val, 				PT::TextStream & stream);
	virtual void put_type(unsigned short val, 		PT::TextStream & stream);
	virtual void put_type(int val, 					PT::TextStream & stream);
	virtual void put_type(unsigned int val, 		PT::TextStream & stream);
	virtual void put_type(long val, 				PT::TextStream & stream);
	virtual void put_type(unsigned long val, 		PT::TextStream & stream);
	virtual void put_type(long long val, 			PT::TextStream & stream);
	virtual void put_type(unsigned long long val, 	PT::TextStream & stream);
	virtual void put_type(float val, 				PT::TextStream & stream);
	virtual void put_type(double val, 				PT::TextStream & stream);
	virtual void put_type(long double val, 			PT::TextStream & stream);
	//virtual void put_type(void* val, 				PT::TextStream & stream);

	virtual void put_type(const PT::Date & date, 	PT::TextStream & stream);
	virtual void put_type(const Model & model, 		PT::TextStream & stream);

	template<typename ListType>
	void put_type(const std::list<ListType> & model, 		PT::TextStream & stream)
	{
		stream << "table";
	}

};

}

#endif