// SSPHH/Fluxions/Unicornfish/Viperfish/Hatchetfish/Sunfish/KASL/GLUT Extensions
// Copyright (C) 2017 Jonathan Metzgar
// All rights reserved.
//
// This program is free software : you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.If not, see <https://www.gnu.org/licenses/>.
//
// For any other type of licensing, please contact me at jmetzgar@outlook.com
#ifndef KASL_HPP
#define KASL_HPP

#include <map>
#include <string>
#include <vector>

//#ifndef KASL_STATIC
//#ifdef KASLDLLEXPORTS
//#define KASL_API __declspec(dllexport) 
//#else
//#define KASL_API __declspec(dllimport) 
//#endif
//#else
//#define KASL_API
//#endif

namespace KASL
{
	using namespace std;
	using StringType = std::string;

	enum class TokenType {
		TT0_NOTHING,
		TT0_CHAR,
		TT0_SPACE,
		TT0_TAB,
		TT0_NEWLINE,
		TT0_DIGIT,
		TT0_ALPHA,
		TT0_CNTRL,
		TT0_PUNCT,
		TT1_EXCLAMATION_POINT,
		TT1_DOUBLE_QUOTE,
		TT1_NUMBER_SIGN,
		TT1_DOLLAR_SIGN,
		TT1_PERCENT_SIGN,
		TT1_AMPERSAND,
		TT1_SINGLE_QUOTE,
		TT1_LPAREN,
		TT1_RPAREN,
		TT1_ASTERICK,
		TT1_PLUS_SIGN,
		TT1_COMMA,
		TT1_DASH,
		TT1_PERIOD,
		TT1_FORWARD_SLASH,
		TT1_COLON,
		TT1_SEMICOLON,
		TT1_LESS_THAN_SIGN,
		TT1_EQUAL_SIGN,
		TT1_GREATER_THAN_SIGN,
		TT1_QUESTION_MARK,
		TT1_AT_SYMBOL,
		TT1_LBRACKET,
		TT1_BACK_SLASH,
		TT1_RBRACKET,
		TT1_CARET,
		TT1_UNDERSCORE,
		TT1_GRAVE_ACCENT,
		TT1_LBRACE,
		TT1_VERTICAL_BAR,
		TT1_RBRACE,
		TT1_TILDE,
		TT2_ID,
		TT2_STRING,
		TT2_DOUBLE,
		TT2_INTEGER,
		TT2_HEXINTEGER
	};

	struct LexerToken
	{
		TokenType type;

		size_t start;
		size_t length;
		char *cptr;
	};

	struct LexerState
	{
		StringType buffer;
		vector<LexerToken> tokens;

		LexerToken tmptoken;
		LexerToken *lasttoken;
		bool eatChar;
	};

	struct Token
	{
		TokenType type;
		string sval;
		int ival;
		double dval;

		bool IsInteger() const { return type == TokenType::TT2_INTEGER; }
		bool IsDouble() const { return type == TokenType::TT2_DOUBLE; }
		bool IsString() const { return type == TokenType::TT2_STRING; }
		bool IsIdentifier() const { return type == TokenType::TT2_ID; }
		bool IsStringOrIdentifier() const { return type == TokenType::TT2_STRING || type == TokenType::TT2_ID; }
		bool IsIntegerOrDouble() const { return type == TokenType::TT2_INTEGER || type == TokenType::TT2_DOUBLE; }
		bool IsType(TokenType which) const { return type == which; }
	};

	using LexReplacementType = tuple<TokenType, TokenType, StringType::value_type>;
	using TokenVector = vector<Token>;

	ostream & operator << (ostream & ostr, const TokenType & type);
	size_t lex_init(LexerState &ls);
	size_t lex(LexerState &ls, const StringType &inputStr, int level = 0);
	void lex_print(LexerState &ls);
	void lex_replace(LexerState &ls, LexerState &output, const vector<LexReplacementType> &replacements);
	size_t lex_scan_number(StringType::value_type *cptr, LexerToken &token);
	size_t lex_scan_string(StringType::value_type *cptr, LexerToken &token);
	size_t lex_tokens(LexerState &ls, vector<Token> & symbols);
	void lex_tokens_print(vector<Token> &tokens);
	size_t lex_quick_parse(const StringType &inputStr, int level, const vector<LexReplacementType> &replacements, TokenVector &tokens);
	size_t lex_quick_parse(const StringType &inputStr, TokenVector &tokens);
	size_t lex_quick_l2_parse(const StringType &inputStr, TokenVector &tokens);
	size_t lex_quick_l3_parse(const StringType &inputStr, TokenVector &tokens);
	string TokenVectorJoin(const TokenVector tokens, const string &separator);

	class VariableList
	{
	private:
		string blankString;
	public:
		VariableList();
		~VariableList();

		map<string, KASL::Token> variables;
		double get_var_double(const string &name) const;
		int get_var_integer(const string &name) const;
		const string &get_var_string(const string &name) const;
		void set_var(const string &name, double dval);
		void set_var(const string &name, int ival);
		void set_var(const string &name, const string &sval);
		bool is_var(const string &name) const;
		map<string, KASL::Token>::const_iterator get_var(const string &name) const;
		map<string, KASL::Token>::const_iterator get_var_end() const;
	};
}

#endif