#include "Variable.h"
#include "TokenStream.h"

#include <iostream>

VariablePtr constructString(const std::string& Val, bool c)
{
	return new Variable(String,Val,c); 
}

VariablePtr constructList(bool c)
{
	return new Variable(List, "", c);
}

VariablePtr constructVoid(bool IsConst)
{
	return new Variable(Void,"",IsConst);
}

VariablePtr constructBool(bool Value, bool IsConst)
{
	return new Variable(BoolType, Value?"t":"", IsConst);
}

Variable::Variable(VarType T, const std::string& aValue, bool aConst)
: Type(T), Value(aValue), IsConst(aConst)
{
}

void Variable::remove(const std::string& Key)
{
	std::string::size_type idx = Key.find(".");
	if (idx == std::string::npos)
	{
		for (unsigned int i=0; i<Vars.size(); ++i)
			if (Vars[i].first == Key)
			{
				Vars.erase(Vars.begin() + i);
				return;
			}
	}
	else
	{
		std::string Part(Key.substr(0,idx));
		for (unsigned int i=0; i<Vars.size(); ++i)
			if (Vars[i].first == Part)
			{
				Vars[i].second->remove(Key.substr(idx+1,Key.length()));
				if (Vars[i].second->size() == 0)
					Vars.erase(Vars.begin() + i);
				return;
			}
	}
}

VarType Variable::type() const
{
	return Type;
}

std::string Variable::value() const
{
	return Value;
}

unsigned int Variable::size() const
{
	return Vars.size();
}

const VariablePtr& Variable::get(unsigned int idx) const
{
	return Vars[idx].second;
}

VariablePtr& Variable::get(unsigned int idx)
{
	return Vars[idx].second;
}

const std::string Variable::name(unsigned int idx) const
{
	return Vars[idx].first;
}

VariablePtr convertTo(VarType T, VariablePtr Src)
{
	if (Src->type() == T) return Src->deepCopy();
	switch (T)
	{
		case BoolType:
			if (Src->type() == String)
				return constructBool(Src->value().length() != 0,false);
			break;
	}
	return constructVoid(false);
}

VariablePtr Variable::deepCopy() const
{
	VariablePtr Copy(new Variable(Type,Value,IsConst));
	for (unsigned int i=0; i<Vars.size(); ++i)
		Copy->insert(Vars[i].first,Vars[i].second->deepCopy());
	return Copy;
}

void Variable::set(const std::string& Name, const VariablePtr& other)
{
	for (unsigned int i=0; i<Vars.size(); ++i)
		if (Vars[i].first == Name)
		{
			Vars[i].second = other->deepCopy();
			return;
		}
	Vars.push_back(std::make_pair(Name,other->deepCopy()));
}

void Variable::insert(const std::string& Name, const VariablePtr &other)
{
	if (Name == "")
		Type = List;
	Vars.push_back(std::make_pair(Name,other->deepCopy()));
}

VariablePtr Variable::find(const std::string& aName)
{
	for (unsigned int i=0; i<Vars.size(); ++i)
		if (Vars[i].first == aName)
			return Vars[i].second;
	return VariablePtr();
}

const VariablePtr Variable::find(const std::string& aName) const
{
	for (unsigned int i=0; i<Vars.size(); ++i)
		if (Vars[i].first == aName)
			return Vars[i].second;
	return VariablePtr();
}

VariablePtr Variable::findOrCreate(const std::string& aName)
{
	VariablePtr R = find(aName);
	if (!R.isNull()) return R;
	Vars.push_back(std::make_pair(aName,constructVoid(false)));
	return Vars[Vars.size()-1].second;
}


void print(const std::string& In, const VariablePtr& V)
{
	switch (V->type())
	{
	case String:
		std::cout << "String = " << V->value() << std::endl;
		break;
	case Void:
		std::cout << "Void" << std::endl;
		break;
	case List:
		std::cout << "List" << std::endl;
		break;
	case BoolType:
		std::cout << "Bool = ";
		if (isBoolTrue(V))
			std::cout << "{true}" << std::endl;
		else
			std::cout << "{false}" << std::endl;
		break;
	default:
		std::cout << "unkown" << std::endl;
	}
	std::string In2(In+"  ");
	for (unsigned int i=0; i<V->size(); ++i)
	{
		std::cout << In << V->name(i) << " : ";
		print(In2,V->get(i));
	}
}

bool isBoolTrue(VariablePtr T)
{
	return T->value().length() > 0;
}

std::string stringValue(const VariablePtr& T)
{
	if (T->type() == String)
		return T->value();
	return "";
}

VariablePtr parseFrom(TokenStream& s)
{
	if (s.literal("false"))
		return constructBool(false,false);
	else if (s.literal("true"))
		return constructBool(true,false);
	std::string V = s.cString();
	if (V.length())
		return constructString(V.substr(1,V.length()-1),false);
	return constructVoid(false);
}

const VariablePtr childOrVoid(const VariablePtr& Parent, const std::string& Name)
{
	std::string Key(Name);
	std::string Rest;

	std::string::size_type idx = Name.find(".");
	if (idx != std::string::npos)
	{
		Key = Name.substr(0,idx);
		Rest = Name.substr(idx+1,Name.length());
	}
	for (unsigned int i=0; i<Parent->size(); ++i)
		if (Parent->name(i) == Key)
		{
			if (Rest.length() == 0)
				return Parent->get(i);
			else
				return childOrVoid(Parent->get(i),Rest);
		}
	return constructVoid(true);
}