/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set et sw=2 ts=2: */
/***************************************************************************
 *            macrotool_dump.cc
 *
 *  Mon Jul  6 08:37:22 CEST 2009
 *  Copyright 2009 Bent Bisballe Nyeng
 *  deva@aasimon.org
 ****************************************************************************/

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

#include "macrotool_util.h"

#include "debug.h"

#include "macroparser.h"
#include "templateparser.h"

#include <vector>
#include <map>
#include <set>

#include <config.h>

#include "configuration.h"

struct _macro {
  std::string name;
  std::string title;
  std::set<std::string>  templates;
  std::string file;
  std::string version;
};

struct _template {
  std::string name;
  std::string title;
  std::vector<std::string> macros;
  std::string file;
  std::string version;
};

static const char usage_str[] =
"  help        Prints this helptext.\n"
"  macros      Writes macro names, versions, filenames, titles and template references to stdout.\n"
"  templates   Writes template names, versions, filenames, titles and macro references to stdout.\n"
;

static std::map<std::string, struct _macro> macroList()
{
  std::map<std::string, struct _macro> macros;

  std::vector<std::string> macrofiles = getMacros();
  std::vector<std::string>::iterator mfs = macrofiles.begin();
  while(mfs != macrofiles.end()) {
    //std::string name = mfs->substr(0, mfs->length() - 4);

    MacroParser parser(Conf::xml_basedir + "/macros/" + *mfs);
    parser.parse();
    Macro *macro = parser.getMacro();

    std::string key = macro->attributes["name"];// + "-" + macro->attributes["version"];
    macros[key].name = macro->attributes["name"];
    macros[key].file = *mfs;
    macros[key].title = macro->widgets.attributes["caption"];
    macros[key].version = macro->attributes["version"];

    mfs++;
  }
  
  std::vector<std::string> templatefiles = getTemplates();
  std::vector<std::string>::iterator tfs = templatefiles.begin();
  while(tfs != templatefiles.end()) {
    std::string templ = tfs->substr(0, tfs->length() - 4);
    TemplateParser parser(Conf::xml_basedir + "/templates/" + *tfs);
    parser.parse();
    Template *t = parser.getTemplate();
    std::vector<Macro>::iterator ms = t->macros.begin();
    while(ms != t->macros.end()) {
      if(ms->attributes.find("header") == ms->attributes.end())
        macros[ms->attributes["name"]].templates.insert(templ);
      ms++;
    }
    tfs++;
  }

  return macros;
}

static void dump_macros()
{
  std::map<std::string, struct _macro> macros = macroList();
  macros[""].title = "Title:";
  macros[""].file = "File:";
  macros[""].version = "Version:";
  macros[""].name = "Macro:";
  macros[""].templates.insert("Templates:");

  size_t name_sz = 0;
  size_t version_sz = 0;
  size_t file_sz = 0;
  size_t title_sz = 0;

  std::map<std::string, struct _macro>::iterator ms = macros.begin();
  while(ms != macros.end()) {
    if(ms->second.name.length() > name_sz) name_sz = ms->second.name.length();
    if(ms->second.version.length() > version_sz) version_sz = ms->second.version.length();
    if(ms->second.file.length() > file_sz) file_sz = ms->second.file.length();
    if(ms->second.title.length() > title_sz) title_sz = ms->second.title.length();
    ms++;
  }

  ms = macros.begin();
  while(ms != macros.end()) {
    printcolumn(ms->second.name, name_sz);
    printcolumn(ms->second.version, version_sz);
    printcolumn(ms->second.file, file_sz);
    printcolumn(ms->second.title, title_sz);

    std::set<std::string>::iterator ts = ms->second.templates.begin();
    while(ts != ms->second.templates.end()) {
      if(ts != ms->second.templates.begin()) printf(", ");
      printf("%s", ts->c_str() );
      ts++;
    }

    printf("\n");
    ms++;
  }
}

static std::map<std::string, struct _template> templateList()
{
  std::map<std::string, struct _template> templates;
  
  std::vector<std::string> templatefiles = getTemplates();
  std::vector<std::string>::iterator tfs = templatefiles.begin();
  while(tfs != templatefiles.end()) {
    TemplateParser parser(Conf::xml_basedir + "/templates/" + *tfs);
    parser.parse();
    Template *t = parser.getTemplate();

    std::string key = t->attributes["name"];

    templates[key].file = *tfs;
    templates[key].name = t->attributes["name"];
    templates[key].title = t->attributes["title"];
    templates[key].version = t->attributes["version"];
    
    std::vector<Macro>::iterator ms = t->macros.begin();
    while(ms != t->macros.end()) {
      if(ms->attributes.find("header") == ms->attributes.end())
        templates[key].macros.push_back(ms->attributes["name"]);
      ms++;
    }

    tfs++;
  }

  return templates;
}

static void dump_templates()
{
  std::map<std::string, struct _template> templates = templateList();
  templates[""].title = "Title:";
  templates[""].file = "File:";
  templates[""].version = "Version:";
  templates[""].name = "Template:";

  size_t name_sz = 0;
  size_t version_sz = 0;
  size_t file_sz = 0;
  size_t title_sz = 0;

  std::map<std::string, struct _template>::iterator ts = templates.begin();
  while(ts != templates.end()) {
    if(ts->second.name.length() > name_sz) name_sz = ts->second.name.length();
    if(ts->second.version.length() > version_sz) version_sz = ts->second.version.length();
    if(ts->second.file.length() > file_sz) file_sz = ts->second.file.length();
    if(ts->second.title.length() > title_sz) title_sz = ts->second.title.length();
    ts++;
  }

  ts = templates.begin();
  while(ts != templates.end()) {
    printcolumn(ts->second.name, name_sz);
    printcolumn(ts->second.version, version_sz);
    printcolumn(ts->second.file, file_sz);
    printcolumn(ts->second.title, title_sz);

    printf("\n");
    std::vector<std::string>::iterator ms = ts->second.macros.begin();
    while(ms != ts->second.macros.end()) {
      printf("\t%s\n", ms->c_str() );
      ms++;
    }

    printf("\n");
    ts++;
  }
}

void macrotool_dump(std::vector<std::string> params)
{
  if(params.size() < 1) {
    printf(usage_str);
    return;
  }

  PRACRO_DEBUG(fieldnames, "dump: %s\n", params[0].c_str());

  if(params[0] == "macros") {
    if(params.size() != 1) {
      printf("The command 'macro' doen't take any parameters.\n");
      printf(usage_str);
      return;
    }
    dump_macros();
    return;
  }

  if(params[0] == "templates") {
    if(params.size() != 1) {
      printf("The command 'templates' doen't take any parameters.\n");
      printf(usage_str);
      return;
    }
    dump_templates();
    return;
  }

  if(params[0] == "help") {
    printf(usage_str);
    return;
  }

  printf("Unknown command '%s'\n", params[0].c_str());
  printf(usage_str);
  return;
}