/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set et sw=2 ts=2: */
/***************************************************************************
 *            node.cc
 *
 *  Fri Feb 24 08:16:30 CET 2012
 *  Copyright 2012 Bent Bisballe Nyeng
 *  deva@aasimon.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 "nodemanager.h"

#include "hugin.hpp"

#include "exceptions.h"

// Global NodeManager object.
NodeManager node_manager;

#define ROOT_ID 0
#define FINISHED_ID 1
#define BACKLOG_ID 2
#define LOSTFOUND_ID 3
#define PROJECTS_ID 4
#define FIRST_NODE_ID 10

NodeManager::NodeManager()
{
}

NodeManager::~NodeManager()
{
}

void NodeManager::init(const std::string& filename)
{
	DEBUG(nodemgr, "Reading nodes from file: %s\n", filename.c_str());
	file = filename;

	FILE *fp = fopen(file.c_str(), "r");
	if(fp)
	{
		std::string xml;
		while(!feof(fp))
		{
			char buf[64];
			size_t sz = fread(buf, 1, sizeof(buf), fp);
			xml.append(buf, sz);
		}
		tree.fromXML(xml);
		fclose(fp);
	}
	else
	{

		// Create new basis config
		node_t t;

		t.attributes["title"] = "root";
		t.id = ROOT_ID;
		tree.insertAsChild(0, ROOT_ID, t, -1);

		t.attributes["title"] = "Finished";
		t.id = FINISHED_ID;
		tree.insertAsChild(ROOT_ID, FINISHED_ID, t, -1);

		t.attributes["title"] = "Backlog";
		t.id = BACKLOG_ID;
		tree.insertAsChild(ROOT_ID, BACKLOG_ID, t, -1);

		t.attributes["title"] = "Lost+Found";
		t.id = LOSTFOUND_ID;
		tree.insertAsChild(ROOT_ID, LOSTFOUND_ID, t, -1);

		t.attributes["title"] = "Projects";
		t.id = PROJECTS_ID;
		tree.insertAsChild(ROOT_ID, PROJECTS_ID, t, -1);
	}

	tree.toStdOut();
}

NodeIdList NodeManager::createNode(nodeid_t parentid, nodeid_t id,
                                   nodeid_t insertbeforeid)
{
	NodeIdList affectedNodes;

	node_t t;
	t.attributes["title"] = "";
	t.id = id;

	affectedNodes = tree.insertAsChild(parentid, id, t, insertbeforeid);
	flushNodes();

	return affectedNodes;
}

NodeIdList NodeManager::updateNode(nodeid_t id, const std::string &name,
                                   const std::string &value)
{
	if(isProtected(id))
	{
		throw Error::ProtectedNode();
	}

	NodeIdList affectedNodes;

	affectedNodes = tree.updateData(id, name, value);

	flushNodes();

	return affectedNodes;
}

NodeIdList NodeManager::removeNode(nodeid_t id)
{
	if(isProtected(id))
	{
		throw Error::ProtectedNode();
	}

	NodeIdList affectedNodes;
	affectedNodes = tree.remove(id);
	flushNodes();

	return affectedNodes;
}

NodeIdListPair NodeManager::moveNode(nodeid_t id, nodeid_t to,
                                     nodeid_t beforeId)
{
	if(isProtected(id))
	{
		throw Error::ProtectedNode();
	}

	NodeIdList tilremove;
	tilremove.push_back(id);
	NodeIdList ancestors = tree.ancestorList(id);
	tilremove.insert(tilremove.end(), ancestors.begin(), ancestors.end());

	NodeIdList tilcreate;
	tilcreate.push_back(to);
	ancestors = tree.ancestorList(to);
	tilcreate.insert(tilcreate.end(), ancestors.begin(), ancestors.end());

	tree.move(id, to, beforeId); // TODO: Use node list pair from return value

	flushNodes();

	return {tilremove, tilcreate};
}

NodeIdList NodeManager::subNodes(nodeid_t t)
{
	NodeIdList affectedNodes;
	affectedNodes = tree.bfs(t);
	return affectedNodes;
}

node_t NodeManager::node(nodeid_t t)
{
	return tree.data(t);
}

nodeid_t NodeManager::createId()
{
	return tree.createId();
}

void NodeManager::flushNodes()
{
	FILE *fp = fopen(file.c_str(), "w");
	if(!fp)
	{
		return;
	}
	std::string xml = tree.toXML();
	fwrite(xml.c_str(), xml.size(), 1, fp);
	fclose(fp);
}

bool NodeManager::hasId(nodeid_t id)
{
	return tree.hasId(id);
}

bool NodeManager::isProtected(nodeid_t id) const
{
	return id < FIRST_NODE_ID;
}