// Copyright © 2013 sss
// 
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// 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 General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

#include "headers.h"

namespace service
{

	std::list<service_info> installed_services;

bool service_info::operator==(const std::string &name)
{
	return name == this->name;
}

bool service_info::command::operator==(const std::string &command)
{
	return command == this->command;
}

bool handle_data(session *s, proto::packet &p)
{
	using namespace proto;
	if(!p.is_good())
		return false;
	if(!p.is_client_packet())
		return false;
	switch(p.get_type())
	{
		case TYPE_AUTH:
		{
			if(!packet::serv_validate_client_proto(p))
			{
				packet *r = packet::serv_make_status_packet(TYPE_AUTH, STATUS_FAILURE);
				s->write_w_close(r->raw());
				delete r;
				return false;
			}
			else
			{
				packet *r = packet::serv_make_status_packet(TYPE_AUTH, STATUS_SUCCESS);
				s->write_w_response(r->raw());
				delete r;
				return true;
			}
		}
		break;
		case TYPE_SERVICES:
		{ //TODO: rewrite
			std::list<service_s> svcs;
			for(std::list<service_info>::iterator i = installed_services.begin(), end = installed_services.end(); i != end; ++i)
			{
				service_s s;
				s.service = i->name;
				for(std::list<service_info::command>::iterator ii = i->predefined.begin(), eend = i->predefined.end(); ii != eend; ++ii)
				{
					service_s::cmd c;
					c.command = ii->command;
					c.description = ii->description;
					s.cmds.push_back(c);
				}
				svcs.push_back(s);
			}
			packet *r = packet::serv_make_services_packet(svcs);
			s->write_w_response(r->raw());
			delete r;
			return true;
		}
		break;
		case TYPE_COMMAND:
		{
			svc_cmd c = packet::serv_extract_command(p);
			if(c.service.empty())
				break;
			std::list<service_info>::iterator i = std::find(installed_services.begin(), installed_services.end(), c.service);
			if(!c.command.empty())
			{
				if(i != installed_services.end())
				{
					std::list<service_info::command>::iterator ii = std::find(i->predefined.begin(), i->predefined.end(), c.command);
					if(ii != i->predefined.end())
					{
						switch(i->acc)
						{
							case ACC_CHAR_PTR:
							{
								switch(i->ret)
								{
									case RET_CHAR_PTR:
									{
										char *arg = strdup(c.command.c_str());
										char *data = (char*)i->exec((void*)arg);
										std::string str(data);
										delete [] data;
										packet *p = packet::serv_make_command_reply_packet(str, STATUS_SUCCESS);
										s->write_w_response(p->raw());
										delete p;
										return true;
									}
									break;
									case RET_FLOAT_PTR:
									{
										char *arg = strdup(c.command.c_str());
										float *ret = (float*)i->exec((void*)arg);
										//todo pack float to unsigned char vector
										std::vector<unsigned char> v;
										packet *p = packet::serv_make_command_reply_packet(v, STATUS_SUCCESS);
										s->write_w_response(p->raw());
										delete p;
										delete ret;
										return true;
									}
									break;
									case RET_INT_PTR:
									{
										char *arg = strdup(c.command.c_str());
										int *ret = (int*)i->exec((void*)arg);
										//todo pack float to unsigned char vector
										std::vector<unsigned char> v;
										packet *p = packet::serv_make_command_reply_packet(v, STATUS_SUCCESS);
										s->write_w_response(p->raw());
										delete p;
										delete ret;
										return true;
									}
									break;
									case RET_NONE:
									{
										char *arg = strdup(c.command.c_str());
										i->exec((void*)arg);
										packet *p = packet::serv_make_status_packet(TYPE_COMMAND, STATUS_SUCCESS);
										s->write_w_response(p->raw());
										delete p;
										return true;
									}
									break;
									case RET_STD_STRING_PTR:
									{
										char *arg = strdup(c.command.c_str());
										std::string *str = (std::string*)i->exec((void*)arg);
										packet *p = packet::serv_make_command_reply_packet(*str, STATUS_SUCCESS);
										s->write_w_response(p->raw());
										delete p;
										delete str;
										return true;
									}
									break;
									case RET_VOID_PTR:
									{
										//TODO
									}
									break;
								};
							}
							break;
							case ACC_FLOAT_PTR:
							{
							}
							break;
							case ACC_INT_PTR:
							{
							}
							break;
							case ACC_STD_STRING_PTR:
							{
							}
							break;
							case ACC_VOID_PTR:
							{
							}
							break;
							default:
							break;
						}
					}
				}
			}
			else
			{
				if(i->acc == ACC_NONE)
				{
					switch(i->ret)
					{
						case RET_CHAR_PTR:
						{
							char *data = (char*)i->exec((void*)NULL);
							std::string str(data);
							delete [] data;
							packet *p = packet::serv_make_command_reply_packet(str, STATUS_SUCCESS);
							delete [] data;
							s->write_w_response(p->raw());
							delete p;
							return true;
						}
						break;
						case RET_FLOAT_PTR:
						{
							float *ret = (float*)i->exec((void*)NULL);
							//todo pack float to unsigned char vector
							std::vector<unsigned char> v;
							packet *p = packet::serv_make_command_reply_packet(v, STATUS_SUCCESS);
							s->write_w_response(p->raw());
							delete p;
							delete ret;
							return true;
						}
						break;
						case RET_INT_PTR:
						{
							int *ret = (int*)i->exec((void*)NULL);
							//todo pack float to unsigned char vector
							std::vector<unsigned char> v;
							packet *p = packet::serv_make_command_reply_packet(v, STATUS_SUCCESS);
							s->write_w_response(p->raw());
							delete p;
							delete ret;
							return true;
						}
						break;
						case RET_NONE:
						{
							i->exec((void*)NULL);
							packet *p = packet::serv_make_status_packet(TYPE_AUTH, STATUS_SUCCESS);
							s->write_w_response(p->raw());
							delete p;
							return true;
						}
						break;
						case RET_STD_STRING_PTR:
						{
							std::string *str = (std::string*)i->exec((void*)NULL);
							packet *p = packet::serv_make_command_reply_packet(*str, STATUS_SUCCESS);
							s->write_w_response(p->raw());
							delete p;
							delete str;
							return true;
						}
						break;
						case RET_VOID_PTR:
						{
							//TODO
						}
						break;
					};
				}
			}
		}
		break;
	}
	return false;
}

};