/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set et sw=2 ts=2: */
/***************************************************************************
 *            tasktree.cc
 *
 *  Tue Mar 27 11:07:48 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 "tasktree.h"

#include "debug.h"


TaskTree::TaskTree() {
  root = NULL;
}

TaskTree::~TaskTree() {
  // cleanup tree
}

TaskIdList TaskTree::insertAsChild(taskid_t parentid, taskid_t id, task_t data) 
  throw (std::exception) {

  TaskIdList affectedNodes;

  // Initialize
  if(!root) {
    node_t* node = createNode(id);
    root = node;
    
    affectedNodes.push_back(id);
    
    goto finish;
  }

  try { 
    node_t* parent = id2node.at(parentid);
    node_t* child = createNode(id);
    child->data = data;
    insertChild(parent, child);

    affectedNodes.push_back(parentid);
    affectedNodes.push_back(id);
  
    goto finish;
  }
  catch(std::exception& e) {
    throw e;
  }
  
 finish: 
  return affectedNodes;
}

TaskIdList TaskTree::remove(taskid_t id) 
  throw (std::exception) {
  //todo: move all childrin to lost+found
  WARN(tasktree, "Feature not implemneted yet\n");
  TaskIdList affectedNodes;
  return affectedNodes;
}

TaskIdList TaskTree::move(taskid_t id, taskid_t toid) 
  throw (std::exception) {

  TaskIdList affectedNodes;

  try {
    node_t* child = id2node.at(id);
    node_t* newparent = id2node.at(toid);
    
    if(!child->parent) {
      throw std::exception();
    }

    child->parent->children.remove(child);
    newparent->children.push_back(child);

    affectedNodes.push_back(id);
    affectedNodes.push_back(child->parent->id);
    affectedNodes.push_back(toid);

    goto finish;
  }
  catch(std::exception& e) {
    throw e;
  }
  
 finish:
  return affectedNodes;
}
 
TaskIdList TaskTree::updateData(taskid_t id, task_t t) 
  throw (std::exception) {
  
  TaskIdList affectedNodes;

  try {
    node_t* node = id2node.at(id);
    node->data = t;

    affectedNodes.push_back(id);
    goto finish;
  }
  catch(std::exception& e) {
    throw e;
  }

 finish:
  return affectedNodes;
}

task_t TaskTree::getData(taskid_t id) 
  throw (std::exception) {

  task_t t;

  try {
    node_t* node = id2node.at(id);
    t = node->data;
    goto finish;
  }
  catch(std::exception& e) {
    throw e;
  }
  
 finish:
  return t;
}

TaskIdList TaskTree::ancestorList(taskid_t id)
  throw (std::exception) {
  
  TaskIdList ancestors;

  try {
    node_t* current = id2node.at(id);
    while(current->parent) {
      ancestors.push_back(current->parent->id);
      current = current->parent;
    }
    goto finish;
  }
  catch(std::exception& e) {
    throw e;
  }
  
 finish:
  return ancestors;
}

node_t* TaskTree::createNode(taskid_t id) {
  node_t* node = new node_t();
  node->parent = NULL;
  node->id = id;
  id2node[id] = node;
  return node;
}

void TaskTree::insertChild(node_t* parent, node_t* child) {
  parent->children.push_back(child);
  child->parent = parent;
}

static void printNode(node_t* node, std::string prefix) {
  if(!node) return;
  task_t t = node->data;
  printf("%s/%u - %s\n", prefix.c_str(), t.id, t.title.c_str());
  char buf[4096];
  sprintf(buf, "%s/%u - %s", prefix.c_str(), t.id, t.title.c_str());

  NodeList::iterator it;
  for(it = node->children.begin(); it != node->children.end(); it++) {
    node_t* child = *it;
    printNode(child, buf);
  }
}

void TaskTree::toStdOut() {
  printNode(root, "/");
}


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

TEST_BEGIN;

TaskTree tree;

task_t t;
try {
  tree.insertAsChild(-1, t);
 }
 catch(std::exeception& e) {
 }

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

TEST_END;

#endif/*TEST_TASKTREE*/