/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set et sw=2 ts=2: */
/***************************************************************************
 *            task.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 "taskmanager.h"

#include <stdio.h>

// Global TaskManager object.
TaskManager task_manager;

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

TaskManager::TaskManager() {
  idCount = FIRST_TASK_ID;

  task_t t;
  t.title = "root";
  t.id = ROOT_ID;
  tree.insertAsChild(0, ROOT_ID, t);

  t.title = "Finished";
  t.id = FINISHED_ID;
  tree.insertAsChild(ROOT_ID, FINISHED_ID, t);

  t.title = "Backlog";
  t.id = BACKLOG_ID;
  tree.insertAsChild(ROOT_ID, BACKLOG_ID, t);

  t.title = "Lost+Found";
  t.id = LOSTFOUND_ID;
  tree.insertAsChild(ROOT_ID, LOSTFOUND_ID, t);

  t.title = "Projects";
  t.id = PROJECTS_ID;
  tree.insertAsChild(ROOT_ID, PROJECTS_ID, t);

  tree.toStdOut();
}

TaskManager::~TaskManager() {
}

task_t TaskManager::task(taskid_t t) {
  return tree.data(t);
}

taskid_t TaskManager::createId() {
  return idCount++;
}

TaskIdList TaskManager::moveTask(taskid_t id, taskid_t to) 
  throw (std::exception) {
  TaskIdList affectedTasks;

  try {
    affectedTasks = tree.move(id, to);
  }
  catch (std::exception& e) {
    throw e;
  }

  return affectedTasks;
}

TaskIdList TaskManager::removeTask(taskid_t id) 
  throw (std::exception) {
  TaskIdList affectedTasks;
  
  try {
    affectedTasks = tree.remove(id);
  }
  catch(std::exception& e) {
    throw e;
  }

  return affectedTasks;
}

TaskIdList TaskManager::updateTask(taskid_t id, task_t t) 
  throw (std::exception) {

  TaskIdList affectedTasks;

  try {
    affectedTasks = tree.updateData(id, t);
  }
  catch (std::exception& e) {
    throw e;
  }

  return affectedTasks;
}

TaskIdList TaskManager::createTask(taskid_t parentid)
  throw (std::exception) {
  TaskIdList affectedTasks;

  task_t t;
  taskid_t id = createId();
  t.title = "";
  t.id = id;

  try {
    affectedTasks = tree.insertAsChild(parentid, id, t);
  }
  catch (std::exception& e) {
    throw e;
  }
  
  return affectedTasks;
}

TaskIdList TaskManager::subTasks(taskid_t t)
  throw (std::exception) {

  TaskIdList affectedTasks;

  try {
    affectedTasks = tree.bfs(t);
  }
  catch (std::exception& e) {
    throw e;
  }

  return affectedTasks;
}

/*
TaskIdList TaskManager::ancestorList(taskid_t id) 
  throw (std::exception) {
  TaskIdList ancestors;

  try {
    ancestors = tree.ancestorList(id);
    goto finish;
  }
  catch (std::exception& e) {
    throw e;
  }

 finish:
  return ancestors;
}
*/

#if 0
TaskList tasklist;

task_t create_task(std::string title, std::string desc) {

  task_t t;
  t.parent_id = current_id_count();
  t.title = title;
  t.desc = desc;
  t.id = id_count; id_count++;

  return t;
}

TaskList load_tasklist_from_file(std::string file) {
  TaskList list;
 
  // create MuniaDb class which handles tasks, db-flush and db-init. 

  return list;
}

bool save_tasklist_to_file(TaskList list, std::string file) {
  
  FILE* fp;

  if(! (fp = fopen(file.c_str(), "w"))) {
    return false;
  }

  if(!fprintf(fp, "<tasklist>\n")) {
    fclose(fp);
    return false;
  }

  TaskList::iterator it;
  for(it = tasklist.begin(); it != tasklist.end(); it++) {
    task_t t = *it;
    int r = 1;

//    printf("Flushing task %d\n", t.id);

    r |= fprintf(fp, "  <task id=\"%d\" parent_id=\"%d\">\n", t.id, t.parent_id);
    r |= fprintf(fp, "    <title>%s</title>\n", xml_encode(t.title).c_str());
    r |= fprintf(fp, "    <desc>%s</desc>\n", xml_encode(t.desc).c_str());
    r |= fprintf(fp, "  </task>)\n");

    if(!r) {
      fclose(fp);
      return false;
    }
  }

  if(!fprintf(fp, "</tasklist>\n")) {
    fclose(fp);
    return false;
  }

  fclose(fp);
  return true;
}

static void delete_task(task_t t, TaskList& graveyard);

static void delete_children(task_t t, TaskList& graveyard) {
  TaskList::iterator it;
  for(it = tasklist.begin(); it != tasklist.end(); it++) {
    if(it->parent_id == t.id) {
      delete_task(*it, graveyard);
    }
  }
}


static void delete_task(task_t t, TaskList& graveyard) {

  TaskList::iterator it;
  for(it = tasklist.begin(); it != tasklist.end(); it++) {
    if(it->id == t.id) {
      break;
    }
  }
  
  if(it != tasklist.end()) {
      graveyard.push_back(*it);
      delete_children(*it, graveyard);
  }

}

void delete_task(int id, TaskList& graveyard) {
  task_t t;
  t.id = id;
  delete_task(t, graveyard);
  
  for(TaskList::iterator it = graveyard.begin();
      it != graveyard.end(); it++) {

      for(TaskList::iterator it_tl = tasklist.begin();
          it_tl != tasklist.end(); it_tl++) {

        if(it_tl->id == it->id) {
          tasklist.erase(it_tl);
          break;
        }
      }
  }
}
#endif