/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set et sw=2 ts=2: */
/***************************************************************************
 *            messagehandler.cc
 *
 *  Mon Mar 26 15:35:24 CEST 2012
 *  Copyright 2012 Jonas Suhr Christensen
 *  jsc@umbraculum.org
 ****************************************************************************/

/*
 *  This file is part of Munia.
 *
 *  Munia 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.
 *
 *  Munia 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 Munia; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA.
 */
#include "messagehandler.h"

#include "hugin.hpp"

// Defines global task_manager object
#include "taskmanager.h"

#include "messageparser.h"

MessageList handle_msg(MessageList msgList, clientid_t wsi)
{

	MessageList outmsgs;

	MessageList::iterator it;
	for(it = msgList.begin(); it != msgList.end(); it++)
	{
		message_t &m = *it;

		if(m.cmd == cmd::login)
		{
			connection_handler.login(wsi, m.login.user, m.login.password);
		}

		// If client is not authenticated; do not continue beyond this point...
		if(!connection_handler.authenticated(wsi))
		{
			continue;
		}

		switch(m.cmd)
		{
		case cmd::login:
			// Already handled, before this switch ... case
			break;

		case cmd::logout:
			connection_handler.logout(wsi);
			break;

		case cmd::create:
			{
				INFO(messagehandler, "Handling create command\n");
				try
				{
					taskid_t id = m.create.id;
					m.nodes = task_manager.createTask(m.create.parentid, &id);
					m.create.id = id;
					outmsgs.push_back(m);
				}
				catch (std::exception& e)
				{
					DEBUG(messagehandler, "Error creating task\n");
				}
			}
			break;

		case cmd::remove:
			{
				INFO(messagehandler, "Handling remove command\n");
				try
				{
					TaskIdList ids = task_manager.subTasks(m.remove.id);
					TaskIdList::reverse_iterator id = ids.rbegin();
					while(id != ids.rend())
					{
						task_t task = task_manager.task(*id);

						message_t m = create_msg_remove(task);
						m.nodes = task_manager.removeTask(task.id);

						outmsgs.push_back(m);
						id++;
					}
				}
				catch (std::exception& e)
				{
					DEBUG(messagehandler, "Error remove task\n");
				}
			}
			break;

		case cmd::move:
			{
				INFO(messagehandler, "Handling move command\n");
				try
				{
					task_t removetask = task_manager.task(m.move.id);
					TaskIdListPair tilpair =
						task_manager.moveTask(m.move.id, m.move.parentid);
					task_t createtask = task_manager.task(m.move.id);

//					TaskIdList commonAncestors;
//					TaskIdList removeAncestors;
//					TaskIdList createAncestors;
//
//					// find command ancestors and fill ancestors for remove command
//					for(TaskIdList::iterator it_remove = tilpair.first.begin();
//					    it_remove != tilpair.first.end(); it_remove++)
//					{
//						taskid_t removeid = *it;
//						bool common = false;
//						for(TaskIdList::iterator it_create = tilpair.second.begin();
//						    it_create = != tilpair.second.end(); it_create++)
//						{
//							taskid_t createid = *id;
//							if(removeid == createid)
//							{
//								commandAncestors.push_back(removeid);
//								common = true;
//							}
//						}
//						if(!common)
//						{
//							removeAncestors.push_back(removeid);
//						}
//					}
//
//					// fill ancestors for create command
//					for(TaskIdList::iterator it_create = tilpair.second.begin();
//					    it_create = != tilpair.second.end(); it_create++)
//					{
//						taskid_t createid = *id;
//						if(removeid == createid)
//						{
//							commandAncestors.push_back(removeid);
//							common = true;
//						}
//					}

					message_t removemsg = create_msg_remove(removetask);
					removemsg.nodes = tilpair.first;
					message_t createmsg = create_msg_create(createtask);
					createmsg.nodes = tilpair.second;

					outmsgs.push_back(removemsg);
					outmsgs.push_back(createmsg);
				}
				catch (std::exception& e)
				{
					DEBUG(messagehandler, "Error moving task\n");
				}
			}
			break;

		case cmd::subscribe:
			{
				//connection_handler.subscribe(wsi, m.subscribe.id);
				outmsgs.push_back(m);
			}
			break;

		case cmd::unsubscribe:
			//connection_handler.unsubscribe(wsi, m.subscribe.id);
			outmsgs.push_back(m);
			DEBUG(handler, "unsubscribe: %d\n", m.unsubscribe.id);
			break;

		case cmd::update:
			{
				INFO(messagehandler, "Handling update command\n");
				try
				{
					m.nodes = task_manager.updateTask(m.update.id,
					                                  m.update.attribute, m.update.value);
					outmsgs.push_back(m);
				}
				catch (std::exception& e)
				{
					DEBUG(messagehandler, "Error updating task\n");
				}
			}
			break;

		case cmd::error:
			ERR(messagehandler, "An error occurred.\n");
			break;

		default:
			WARN(messagehandler, "!!! Unknown command %d\n", m.cmd);
			break;
		}
		task_manager.tree.toStdOut();
		DEBUG(messagehandler, "%d affected nodes registered\n",
		      (int)m.nodes.size());
	}

	return outmsgs;
}

#ifdef TEST_MSGHANDLER
//Additional dependency files
//deps:
//Required cflags (autoconf vars may be used)
//cflags:
//Required link options (autoconf vars may be used)
//libs:
#include "test.h"

TEST_BEGIN;

// TODO: Put some testcode here (see test.h for usable macros).
TEST_TRUE(false, "No tests yet!");

TEST_END;

#endif/*TEST_MSGHANDLER*/