#include "expression.hpp"
#include "parser.hpp"
#include "print.h"
#include "syntaxer.hpp"
#include <stack>
#include <vector>

namespace Syntax {

static void highlight_issue(const std::vector<Expression::Token>& tv, const int location)
{
	int start = location - 7 < 0 ? 0 : location - 7;
	int finish = location + 7 > tv.size() - 1 ? tv.size() - 1 : location + 7;

	std::cout << " >>>  ";

	for (int i = start; i <= finish; i++)
	{
		if (i == location)
		{
			std::cout << "\033[31m" << *tv[i].to_math_str() << "\033[0m ";
		}
		else
		{
			std::cout << *tv[i].to_math_str() << " ";
		}
	}

	std::cout << "\n";
}

int check_syntax(std::vector<Expression::Token>& tv)
{
	int problem_cnt = 0;

	// check token type sequence
	{
		for (int i = 0, l = tv.size() - 1, pc; pc = problem_cnt, i < l; i++)
		{
			switch (tv[i].t)
			{
			case Expression::Token::VAR:
			case Expression::Token::CONST:
				switch (tv[i+1].t)
				{
				case Expression::Token::OPERATOR:
					switch (tv[i+1].v.o)
					{
					case Expression::Token::OPA:
						pr_warn("Expected operator at token " << i << ", got opening bracket");
						problem_cnt++;
						break;
					case Expression::Token::CPA:
						break;
					default:
						break;
					}
					break;
				case Expression::Token::VAR:
					pr_warn("Expected operator at token " << i << ", got variable");
					problem_cnt++;
					break;
				case Expression::Token::CONST:
					pr_warn("Expected operator at token " << i << ", got constant");
					problem_cnt++;
					break;
				default:
					pr_warn("Impossible token type, this is a bug!");
					break;
				}
				break;
			case Expression::Token::OPERATOR:
				switch (tv[i].v.o)
				{
				case Expression::Token::OPA:
					switch (tv[i+1].t)
					{
					case Expression::Token::OPERATOR:
						switch (tv[i+1].v.o)
						{
						case Expression::Token::OPA:
							break;
						case Expression::Token::CPA:
							pr_warn("Expected value at token " << i << ", got closing bracket");
							problem_cnt++;
							break;
						default:
							pr_warn("Expected value at token " << i << ", got operator");
							problem_cnt++;
							break;
						}
						break;
					case Expression::Token::CONST:
					case Expression::Token::VAR:
						break;
					default:
						pr_warn("Impossible token type, this is a bug!");
						break;
					}
					break;
				case Expression::Token::CPA:
					switch (tv[i+1].t)
					{
					case Expression::Token::OPERATOR:
						switch (tv[i+1].v.o)
						{
						case Expression::Token::CPA:
							break;
						case Expression::Token::OPA:
							pr_warn("Expected operator at token " << i << ", got opening bracket");
							problem_cnt++;
							break;
						default:
							break;
						}
						break;
					case Expression::Token::CONST:
						pr_warn("Expected operator at token " << i << ", got constant");
						problem_cnt++;
						break;
					case Expression::Token::VAR:
						pr_warn("Expected operator at token " << i << ", got variable");
						problem_cnt++;
						break;
					default:
						pr_warn("Impossible token type, this is a bug!");
						break;
					}
					break;
				default:
					switch (tv[i+1].t)
					{
					case Expression::Token::OPERATOR:
						switch (tv[i+1].v.o)
						{
						case Expression::Token::CPA:
							pr_warn("Expected value at token " << i << ", got closing bracket");
							problem_cnt++;
							break;
						case Expression::Token::OPA:
							break;
						default:
							pr_warn("Expected value at token " << i << ", got operator");
							problem_cnt++;
							break;
						}
						break;
					case Expression::Token::CONST:
						break;
					case Expression::Token::VAR:
						break;
					default:
						pr_warn("Impossible token type, this is a bug!");
						break;
					}
					break;
				}
				break;
			default:
				pr_warn("Impossible token type, this is a bug!");
				break;
			}

			if (pc != problem_cnt)
			{
				highlight_issue(tv, i + 1);
			}
		}
	}

	// check bracket matching
	{
		std::stack<int> s;

		for (int i = 0, l = tv.size(); i < l; i++)
		{
			if (tv[i].t == Expression::Token::OPERATOR)
			{
				switch (tv[i].v.o)
				{
				case Expression::Token::OPA:
					s.push(i);
					break;
				case Expression::Token::CPA:
					if (s.size())
					{
						s.pop();
					}
					else
					{
						pr_warn("Missing opening bracket at token " << i);
						problem_cnt++;
						highlight_issue(tv, i);
					}
					break;
				default:
					break;
				}
			}
		}

		for (int i = 0, l = s.size(); i < l; i++)
		{
			problem_cnt++;
			pr_warn("Opening bracket at token " << s.top() << " expected a closing bracket, but none found");
			highlight_issue(tv, s.top());
			s.pop();
		}
	}

	return problem_cnt;
}

// get mop = Math OPerator location (=absolute index in std::vector<Expression::Token>)
// mapper of 'priority vector index' -> 'token vector index'
static int get_mop_location(const std::vector<Expression::Token>& v, int position)
{
	int i = 0, l = v.size(), p = -1;
	for (; p += v[i].t == Expression::Token::OPERATOR
			&& v[i].v.o != Expression::Token::OPA
			&& v[i].v.o != Expression::Token::CPA, p != position; i++);
	return i;
}

static int get_left_location(const std::vector<Expression::Token>& v, int location)
{
	for (int i = location - 1; i >= 0; i--)
	{
		if (v[i].t != Expression::Token::OPERATOR && v[i].t != Expression::Token::NAT)
		{
			return i;
		}
	}

	return -1;
}

static int get_right_location(const std::vector<Expression::Token>& v, int location)
{
	for (int i = location + 1, l = v.size(); i < l; i++)
	{
		if (v[i].t != Expression::Token::OPERATOR && v[i].t != Expression::Token::NAT)
		{
			return i;
		}
	}

	return -1;
}

static int get_operator_weight(const std::vector<Expression::Token>& v, int location)
{
	int weight = 0;

	switch (const Expression::Token &p = v[get_left_location(v, location)]; p.t)
	{
	case Expression::Token::VAR:
	case Expression::Token::CONST:
		break;
	case Expression::Token::CV:
		weight += p.v.cv.w;
		break;
	default:
		pr_warn("Invalid token found to the left of operator");
		break;
	}

	switch (const Expression::Token &p = v[get_right_location(v, location)]; p.t)
	{
	case Expression::Token::VAR:
	case Expression::Token::CONST:
		break;
	case Expression::Token::CV:
		weight += p.v.cv.w;
		break;
	default:
		pr_warn("Invalid token found to the left of operator");
		break;
	}

	return weight;
}

static int get_min_index(const std::vector<int>& v)
{
	int idx = 0;

	for (int i = 1, l = v.size(); i < l; i++)
	{
		if (v[i] < v[idx])
		{
			idx = i;
		}
	}

	return idx;
}

static int get_max_index(const std::vector<int>& v)
{
	int idx = 0;

	for (int i = 1, l = v.size(); i < l; i++)
	{
		if (v[i] > v[idx])
		{
			idx = i;
		}
	}

	return idx;
}

static void write_operation(
		std::vector<Expression::Operation>& ov,
		const std::vector<Expression::Token>& tv,
		std::vector<Expression::Token>& mv,
		std::vector<int>& mp,
		int position)
{
	int location = get_mop_location(mv, position);
	int left_location = get_left_location(mv, location);
	int right_location = get_right_location(mv, location);

	Expression::Token &o = mv[location],
	      &l = mv[left_location],
	      &r = mv[right_location];

	int this_op_weight = get_operator_weight(mv, location) + 1;

	int il = l.t == Expression::Token::CV ? l.v.cv.i : left_location;
	int ir = r.t == Expression::Token::CV ? r.v.cv.i : right_location;

	// write new operation
	int this_ov_index = ov.size();
	ov.emplace_back(o.v.o,
			l.t == Expression::Token::CV ? Expression::Operation::DERIVED : Expression::Operation::NORMAL,
			il,
			r.t == Expression::Token::CV ? Expression::Operation::DERIVED : Expression::Operation::NORMAL,
			ir,
			this_op_weight);

	// update mv
	l.t = Expression::Token::NAT;
	r.t = Expression::Token::NAT;
	o.t = Expression::Token::CV;
	o.v.cv.w = this_op_weight;
	o.v.cv.i = this_ov_index;

	// update mp
	mp.erase(mp.begin() + position, mp.begin() + position + 1);
}

static void add_bracket_to(std::vector<Expression::Token>& tv, const int location, const int direction)
{
	int i = location + direction, l = tv.size(), lv = 0;

	if (direction == -1)
	{
		for (; i >= 0; i--)
		{
			if (tv[i].t == Expression::Token::OPERATOR)
			{
				switch (tv[i].v.o)
				{
				case Expression::Token::OPA:
					lv--;
					break;
				case Expression::Token::CPA:
					lv++;
					break;
				default:
					if (!lv)
					{
						tv.insert(tv.begin() + i + 1, Expression::Token(Expression::Token::OPA));
						return;
					}
					break;
				}
			}
		}

		tv.insert(tv.begin(), Expression::Token(Expression::Token::OPA));
	}
	else if (direction == 1)
	{
		for (; i < l; i++)
		{
			if (tv[i].t == Expression::Token::OPERATOR)
			{
				switch (tv[i].v.o)
				{
				case Expression::Token::OPA:
					lv++;
					break;
				case Expression::Token::CPA:
					lv--;
					break;
				default:
					if (!lv)
					{
						tv.insert(tv.begin() + i, Expression::Token(Expression::Token::CPA));
						return;
					}
					break;
				}
			}
		}

		tv.emplace_back(Expression::Token::CPA);
	}
}

static void create_prios_vector(const std::vector<Expression::Token>& tv, std::vector<int>& pv)
{
	for (int i = 0, cp = 0, l = tv.size(); i < l; i++)
	{
		if (tv[i].t == Expression::Token::OPERATOR)
		{
			switch (tv[i].v.o)
			{
			case Expression::Token::OPA:
				cp++;
				break;
			case Expression::Token::CPA:
				cp--;
				break;
			case Expression::Token::ADD:
			case Expression::Token::SUB:
			case Expression::Token::MUL:
			case Expression::Token::DIV:
			case Expression::Token::POW:
				pv.emplace_back(cp);
				break;
			default:
				pr_warn("Token vector has broken operator at " << i);
				break;
			}
		}
	}
}

static void find_top_prio_op_range(const std::vector<int>& mp, int& start, int& finish)
{
	for (int i = 0, l = mp.size(), prio = -1; i < l; i++)
	{
		if (mp[i] > prio)
		{
			prio = mp[i];
			start = finish = i;
		}
		else if (mp[i] == prio && finish == i - 1)
		{
			finish = i;
		}
	}
}

struct Range
{
	int start, finish;

	Range(int start, int finish)
		: start(start), finish(finish)
	{
	}
};

static void find_select_prio_op_ranges(const std::vector<int>& mp, std::vector<Range>& ranges, int target_prio)
{
	for (int i = 0, l = mp.size(), prio = 0, recording_range = 0; i < l; i++)
	{
		if (mp[i] == target_prio && !recording_range)
		{
			recording_range = 1;
			ranges.emplace_back(i, 0);
		}
		else if (mp[i] == target_prio && recording_range)
		{
			ranges.back().finish = i;
		}
		else if (mp[i] != target_prio && recording_range)
		{
			recording_range = 0;
		}
	}
}

static void rank_inner_ops_raw(std::vector<int>& inner_op_ranks, const std::vector<Expression::Token>& mv, const int start, const int finish)
{
	for (int i = 0, lvl = 0; i < finish - start + 1; i++)
	{
		int idx = get_mop_location(mv, start + i);

		switch (mv[idx].v.o)
		{
		case Expression::Token::ADD:
		case Expression::Token::SUB:
			inner_op_ranks.push_back(0);
			break;
		case Expression::Token::MUL:
		case Expression::Token::DIV:
			inner_op_ranks.push_back(1);
			break;
		case Expression::Token::POW:
			inner_op_ranks.push_back(2);
			break;
		default:
			pr_warn("Operator is unrankable");
			break;
		}
	}
}

static void rank_inner_ops(std::vector<int>& inner_top_ops, const std::vector<Expression::Token>& mv, const int start, const int finish)
{
	for (int i = 0, lvl = 0; i < finish - start + 1; i++)
	{
		int idx = get_mop_location(mv, start + i);

		switch (mv[idx].v.o)
		{
		case Expression::Token::ADD:
		case Expression::Token::SUB:
			if (lvl == 0)
				inner_top_ops.push_back(i);

			break;
		case Expression::Token::MUL:
		case Expression::Token::DIV:
			if (lvl < 1)
			{
				lvl = 1;
				inner_top_ops.clear();
			}

			if (lvl == 1)
				inner_top_ops.push_back(i);

			break;
		case Expression::Token::POW:
			if (lvl < 2)
			{
				lvl = 2;
				inner_top_ops.clear();
			}

			if (lvl == 2)
				inner_top_ops.push_back(i);

			break;
		default:
			pr_warn("Operator is unrankable");
			break;
		}
	}
}

static void weight_operators(std::vector<int>& operator_weights, const std::vector<Expression::Token>& mv, const std::vector<int>& inner_top_ops, const int start)
{
	for (int i = 0, l = inner_top_ops.size(); i < l; i++)
	{
		int operator_location = get_mop_location(mv, start + inner_top_ops[i]);
		operator_weights.push_back(get_operator_weight(mv, operator_location));
	}
}

void apply_corrections(std::vector<Expression::Token>& tv)
{
	pr_debug("Starting with vector:");
	Parser::print_math_vector(tv);

	// global prio evaluation
	std::vector<int> mp;
	create_prios_vector(tv, mp);

	if (mp.size() == 0)
	{
		return;
	}

	for (int current_prio_level = mp[get_max_index(mp)]; current_prio_level >= 0; current_prio_level--)
	{
		// calculate how many ranges need to be processed at this level
		std::vector<Range> rv;
		find_select_prio_op_ranges(mp, rv, current_prio_level);

		for (int current_range = rv.size() - 1; current_range >= 0; current_range--)
		{
			Range &outer_range = rv[current_range];

			std::vector<int> inner_prios;
			rank_inner_ops_raw(inner_prios, tv, outer_range.start, outer_range.finish);

			for (int inner_prio = inner_prios[get_max_index(inner_prios)]; inner_prio >= 0; inner_prio--)
			{
				std::vector<Range> inner_ranges;
				find_select_prio_op_ranges(inner_prios, inner_ranges, inner_prio);

				for (int inner_range = inner_ranges.size() - 1; inner_range >= 0; inner_range--)
				{
					int corrections = 1;

					Range &range = inner_ranges[inner_range];
					while (corrections)
					{
						corrections = 0;

						int same_op_cnt = -1;
						for (int i = outer_range.start + range.start; i < outer_range.start + range.finish + 1; i++)
						{
							int loc = get_mop_location(tv, i);
							Expression::Token& tok = tv[loc];

							if (tok.v.o == Expression::Token::SUB || tok.v.o == Expression::Token::DIV)
							{
								same_op_cnt++;

								if (same_op_cnt == 2)
								{
									same_op_cnt = 0;

									corrections++;

									switch (tok.v.o)
									{
									case Expression::Token::SUB:
										tok.v.o = Expression::Token::ADD;
										break;
									case Expression::Token::DIV:
										tok.v.o = Expression::Token::MUL;
										break;
									default:
										pr_warn("Impossible operator in this branch, this is a bug!");
										break;
									}

									// inverse order to keep location valid between calls
									add_bracket_to(tv, loc,  1);
									add_bracket_to(tv, loc, -1);

									pr_debug("Updated vector:");
									Parser::print_math_vector(tv);
								}
							}
						}
					}
				}
			}
		}
	}
}

std::vector<Expression::Operation> build_op_vector(const std::vector<Expression::Token>& tv)
{
	// define operator precedency
	std::vector<int> g_prios;
	create_prios_vector(tv, g_prios);

	for (int i = 0, l = g_prios.size(); i < l; i++)
	{
		pr_debug("prio=" << g_prios[i]);
	}

	// build operation vector
	std::vector<Expression::Operation> ov;
	{
		std::vector<Expression::Token> mv = tv;
		std::vector<int> mp = g_prios;

		while (mp.size())
		{
			int start, finish;
			find_top_prio_op_range(mp, start, finish);

			// --- process current range ---
			while (start != finish)
			{
				std::vector<int> inner_top_ops;
				rank_inner_ops(inner_top_ops, mv, start, finish);

				std::vector<int> operator_weights;
				weight_operators(operator_weights, mv, inner_top_ops, start);

				write_operation(ov, tv, mv, mp, start + inner_top_ops[get_min_index(operator_weights)]);
				finish--;
			}

			// process final operation w/out running selection algorithm
			write_operation(ov, tv, mv, mp, start);
		}
	}

	for (int i = 0, l = ov.size(); i < l; i++)
	{
		const Expression::Operation &o = ov[i];

		prs_debug("OP: ");

		if (o.tl == Expression::Operation::NORMAL)
		{
			const Expression::Token &real_value = tv[o.il];

			if (real_value.t == Expression::Token::VAR)
			{
				pri_debug(*real_value.v.s);
			}
			else
			{
				pri_debug(real_value.v.d);
			}
		}
		else
		{
			pri_debug("t" << o.il);
		}

		pri_debug(" " << o.o.op_math_str() << " ");

		if (o.tr == Expression::Operation::NORMAL)
		{
			const Expression::Token &real_value = tv[o.ir];

			if (real_value.t == Expression::Token::VAR)
			{
				pri_debug(*real_value.v.s);
			}
			else
			{
				pri_debug(real_value.v.d);
			}
		}
		else
		{
			pri_debug("t" << o.ir);
		}

		pri_debug(" = t" << i << "\n");
	}

	return ov;
}

}