/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set et sw=2 ts=2: */
/***************************************************************************
 *            nodemanager.h
 *
 *  Fri Feb 24 08:16:29 CET 2012
 *  Copyright 2012 Bent Bisballe Nyeng & Jonas Suhr Christensen
 *  deva@aasimon.org & 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.
 */
#pragma once

#include <list>
#include <string>
#include <stdio.h>
#include <exception>

#include "node.h"
#include "nodetree.h"

typedef std::pair<NodeIdList, NodeIdList> NodeIdListPair;

class NodeManager
{
public:
	NodeManager();
	~NodeManager();

	void init(std::string filename);

	NodeIdList createNode(nodeid_t parentid, nodeid_t id, nodeid_t insertbeforeid) throw (std::exception);
	NodeIdList updateNode(nodeid_t id, const std::string &name,
	                      const std::string &value) throw (std::exception);
	NodeIdList removeNode(nodeid_t id) throw (std::exception);

	NodeIdListPair moveNode(nodeid_t id, nodeid_t newParent, nodeid_t beforeId) throw (std::exception);

	NodeIdList subNodes(nodeid_t) throw (std::exception);

	NodeTree tree;

	node_t node(nodeid_t t);

	void flushNodes();

	nodeid_t createId();
	bool hasId(nodeid_t id);

private:
	//  NodeIdList ancestorList(nodeid_t node);
	nodeid_t idCount;
	node_t nextNode();

	std::string file;
};

#ifndef FOOBAR
extern NodeManager node_manager;
#endif


#if 0

/*
Node:
  id
  subnodes
//  tags
  title
  description
//  primary_assignment
//  secondary_assignment


Protocol:

Server -> client:
 update [id] [title] [description];
 move [id] [x] [y];
 add [id] [title] [description] [x] [y];
 del [id]

Client -> server:
 update [id] [title] [description];
 move [id] [x] [y];
 add [title] [description] [x] [y];
 del [id]

title and description are " encapsulated utf-8 string with " escaped with a backslash.
x and y are integers as strings
id are an integer as a string
 */

/*
typedef struct {
  int x, y;
  int id;
  std::string title;
  std::string desc;
} node_t;
*/
/*
protocol:
  add_node title description parent_id
  del_node id
  update_node id title description
  move_node id parent
  copy_node id parent
*/



//typedef std::list<node_t> NodeList;

class CompareByParentid
{
public:
	bool operator()(const node_t &a, const node_t &b) const
	{
		return a.parent_id < b.parent_id;
	}
};

class NodeList
	: public std::list<node_t>
{
public:
	NodeList() {}
	~NodeList(){}

	void insert(node_t t)
	{
		if(t.id == t.parent_id)
		{
			return;
		}
		printf("inserting node %d with parent %d\n", t.id, t.parent_id);

		if(t.parent_id == -1)
		{
			std::list<node_t>::push_front(t);
			return;
		}

		std::list<node_t>::iterator it;
		for(it = begin(); it != end(); ++it)
		{
			printf("\tcomparing %d and %d\n", t.parent_id, it->id);
			if(t.parent_id == it->id)
			{
				break;
			}
		}
		assert(it != end());

		std::list<node_t>::insert(++it, t);

		//std::list<node_t>::push_back(t);
		//std::list<node_t>::sort(CompareByParentid());
	}

	void move(node_t t)
	{
		std::list<node_t>::iterator it;
		for(it = begin(); it != end(); it++)
		{
			if(t.id == it->id)
			{
				break;
			}
		}
		assert(it != end());
		//if(it != end())
		//{
		std::list<node_t>::erase(it);
		//}
		insert(t);
	}

	void push_back(node_t t)
	{
		insert(t);
	}

private:
	std::list<node_t> list;
};


extern NodeList nodelist;

//typedef std::priority_queue<node_t, std::vector<node_t>, CompareByParentid> NodeList;

node_t create_node(std::string title, std::string desc, /*int x, int y*/ int parent_id);

NodeList load_nodelist_from_file(std::string file);
bool save_nodelist_to_file(NodeList t, std::string file);
#endif/*0*/