#include <algorithm>
#include <fstream>
#include "client.h"
#include "Config.h"
#include "Proxy.h"

using namespace std;


Config* Config::self = NULL;

Config *Config::CurrentConfig()
{
	if (self == NULL)
		self = new Config();
	return self;
}

Config::Config(): configValid(0)
{
}

void Config::AcquireConfig()
{
	configValid = false;
	if (ReadGenericProxy())
		return ;
	if (ReadStaticProxy())
		return ;
	configValid = true;
}

bool Config::IsConfigValid()
{
	return configValid;
}

vector<string> Config::GetCountries()
{
	vector<string> countries;
	for (unsigned i = 0; i < genericProxy.size(); i++)
	{
		countries.push_back(genericProxy[i].country);
	}
	sort(countries.begin(), countries.end());
	vector<string>::iterator end = unique(countries.begin(), countries.end());
	countries.resize(end - countries.begin());
	return countries;
}

vector<string> Config::GetStates(string &country)
{
	vector<string> states;
	for (unsigned i = 0; i < genericProxy.size(); i++)
	{
		if ((genericProxy[i].state != "-") &&
			(genericProxy[i].country == country))
		{
			states.push_back(genericProxy[i].state);			
		}
	}
	if (!states.empty())
	{
		sort(states.begin(), states.end());
		vector<string>::iterator end = unique(states.begin(), states.end());
		states.resize(end - states.begin());
	}
	return states;
}

vector<string> Config::GetCities(string &country)
{
	string defState = "-";
	return GetCities(country, defState);
}

vector<string> Config::GetCities(string &country, string &state)
{
	vector<string> cities;
	for (unsigned i = 0; i < genericProxy.size(); i++)
	{
		if ((genericProxy[i].state == state) &&
			(genericProxy[i].country == country))
		{
			cities.push_back(genericProxy[i].city);			
		}
	}
	sort(cities.begin(), cities.end());
	vector<string>::iterator end = unique(cities.begin(), cities.end());
	cities.resize(end - cities.begin());
	return cities;
}

vector<string> Config::GetProxies(string &country, string &city)
{
	string defState = "-";
	return GetProxies(country, defState, city);
}

vector<string> Config::GetProxies(string &country, string &state, string &city)
{
	vector<string> proxies;
	for (unsigned i = 0; i < genericProxy.size(); i++)
	{
		if ((genericProxy[i].state == state) &&
			(genericProxy[i].country == country) &&
			(genericProxy[i].city == city))
		{
			proxies.push_back(genericProxy[i].host);			
		}
	}
	sort(proxies.begin(), proxies.end());
	return proxies;
}

int Config::ReadGenericProxy()
{
	Logger::Info("Parsing generic proxy list\n");
	
	ifstream proxyFile("./config/proxy_list.cfg", std::ios::in);
	if (!proxyFile)
	{
		Logger::Error("Can't open file ./config/proxy_list.cfg");
		return -1;
	}

	const int str_size = 512;
	char str[str_size] = {0};
	while (!proxyFile.eof())
	{
		proxyFile.getline(str, str_size, ';');
		if (proxyFile.eof())
			break;
		string entry = str;
		ProxyEntryGeneric *proxy = new ProxyEntryGeneric;
		proxy->Parse(entry);
		genericProxy.push_back(*proxy);
	}
	proxyFile.close();
	return 0;
}

int Config::ReadStaticProxy()
{
	Logger::Info("Parsing static proxy list\n");
	
	ifstream proxyFile("./config/static_proxy_list.cfg", std::ios::in);
	if (!proxyFile)
	{
		Logger::Error("Can't open file ./config/static_proxy_list.cfg\n");
		return -1;
	}
	
	const int str_size = 512;
	char str[str_size] = {0};
	while (!proxyFile.eof())
	{
		proxyFile.getline(str, str_size, ';');
		if (proxyFile.eof())
			break;
		string entry = str;
		ProxyEntryStatic *proxy = new ProxyEntryStatic;
		proxy->Parse(entry);
		staticProxy.push_back(*proxy);
	}
	proxyFile.close();
	return 0;
}