/***************************************************************************
                          doc_mod.cpp  -  description
                             -------------------
    begin                : Mon Nov 13 16:11:07 2006
    copyright            : (C) 2002 by Cavalli Andrea
    email                : cavalli@bioc.unizh.ch
**************************************************************************/
/***************************************************************************
 *                                                                         *
 *   This program 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.                                   *
 *                                                                         *
 ***************************************************************************/
#include <almost.h>
#include <module.h>
#include <class.h>
#include <zextclass.h>
#include <zobj.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <codegen.h>
#include <boost/regex.hpp>
#include <stdio.h>

#include <sqlite3.h>


class SQLDoc {
  sqlite3 *db;
public:
  SQLDoc(string dbname){
    int rc;
    rc = sqlite3_open("almdoc.sqlite", &db);
    if( rc ){
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      sqlite3_close(db);
      exit(1);
    }    
  }

  vector<string> update_modules_list(){
    vector<string> mod = SymbolTable::instance().modules_list();

    for(int i=0;i<mod.size();i++){
      char *zErrMsg = 0;
      int rc;
      string cmd = "insert into modules  (name) values ('"+mod[i]+"');"; 
      cout<<">> Exec "<<cmd.c_str()<<"\n";
      rc = sqlite3_exec(db, cmd.c_str(),0, 0, &zErrMsg);
      if( rc!=SQLITE_OK ){
	fprintf(stderr, "SQL error: %s\n", zErrMsg);
	sqlite3_free(zErrMsg);
      }
    }
    return mod;
  }

  void update_constants(){
   vector<string> mod = SymbolTable::instance().modules_list();

    for(int i=0;i<mod.size();i++){
      ZModule * zmod = zmod = (ZModule *)SymbolTable::current()[mod[i]];
      map<string,ZObj *>::iterator iter = zmod->module_map.begin(),
	end = zmod->module_map.end();
      while(iter!=end){
	if(dynamic_cast<ZExtClass*>(iter->second)){ ++iter; continue;}
	if(dynamic_cast<ZExtFunction*>(iter->second)){ ++iter; continue;}
	string cmd = "insert into constants (long_name,name,module) values ('"+mod[i]+"."+iter->first+"','"+iter->first +"','"+mod[i]+"');";
	cout<<">> Exec "<<cmd.c_str()<<"\n";
	char *zErrMsg = 0;
	int rc;
	rc = sqlite3_exec(db, cmd.c_str(),0, 0, &zErrMsg);
	if( rc!=SQLITE_OK ){
	  fprintf(stderr, "SQL error: %s\n", zErrMsg);
	  sqlite3_free(zErrMsg);
	}
	++iter;
      }
    }
  }


  void update_functions(){
   vector<string> mod = SymbolTable::instance().modules_list();

    for(int i=0;i<mod.size();i++){
      ZModule * zmod = zmod = (ZModule *)SymbolTable::current()[mod[i]];
      map<string,ZObj *>::iterator iter = zmod->module_map.begin(),
	end = zmod->module_map.end();
      while(iter!=end){
	if(dynamic_cast<ZExtFunction*>(iter->second)){
	  string cmd = "insert into functions (long_name,name,module,type,desc) values ('"+mod[i]+"."+iter->first
	    +"','"+iter->first 
	    +"','"+mod[i]
	    +"','"+zmod->module_desc[iter->first]
	    +"','"+zmod->module_doc[iter->first]
	    +"');"
	    ;
	  cout<<">> Exec "<<cmd.c_str()<<"\n";
	  char *zErrMsg = 0;
	  int rc;
	  rc = sqlite3_exec(db, cmd.c_str(),0, 0, &zErrMsg);
	  if( rc!=SQLITE_OK ){
	    fprintf(stderr, "SQL error: %s\n", zErrMsg);
	    sqlite3_free(zErrMsg);
	  }
	}
	++iter;
      }
    }
  }


  void update_classes(){
   vector<string> mod = SymbolTable::instance().modules_list();

    for(int i=0;i<mod.size();i++){
      ZModule * zmod = zmod = (ZModule *)SymbolTable::current()[mod[i]];
      map<string,ZObj *>::iterator iter = zmod->module_map.begin(),
	end = zmod->module_map.end();
      while(iter!=end){
	if(dynamic_cast<ZExtClass*>(iter->second)){
	  string cmd = "insert into classes (long_name,name,module) values ('"+mod[i]+"."+iter->first+"','"+iter->first +"','"+mod[i]+"');";
	  cout<<">> Exec "<<cmd.c_str()<<"\n";
	  char *zErrMsg = 0;
	  int rc;
	  rc = sqlite3_exec(db, cmd.c_str(),0, 0, &zErrMsg);
	  if( rc!=SQLITE_OK ){
	    fprintf(stderr, "SQL error: %s\n", zErrMsg);
	    sqlite3_free(zErrMsg);
	  }
	}
	++iter;
      }
    }
  }

  
  void set_module_title(string mod,
			string tit){
    char *zErrMsg = 0;
    int rc;
    string cmd = "update modules set title=\""+tit+"\" where name=\""+mod+"\";";
    rc = sqlite3_exec(db, cmd.c_str(),0, 0, &zErrMsg);
    if( rc!=SQLITE_OK ){
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
    }
  }

  void set_module_desc(string mod,
			string tit){
    char *zErrMsg = 0;
    int rc;
    string cmd = "update modules set desc=\""+tit+"\" where name=\""+mod+"\";";
    rc = sqlite3_exec(db, cmd.c_str(),0, 0, &zErrMsg);
    if( rc!=SQLITE_OK ){
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
    }
  }


  void set_function_desc(string mod, string fun,
			 string tit){
    char *zErrMsg = 0;
    int rc;
    string cmd = "update functions set desc=\""+tit+"\" where long_name=\""+mod+"."+fun+"\";";
    rc = sqlite3_exec(db, cmd.c_str(),0, 0, &zErrMsg);
    if( rc!=SQLITE_OK ){
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
    }
  }


  ~SQLDoc(){
    sqlite3_close(db);
  }
};

template<>
inline string to_string(const SQLDoc & sql){
  return "<SQLDoc>";
}
//additional docs
static int module_title_callback(void *res, 
				 int argc, char **argv, char **azColName){
  //  cout<<"DEB module_title_callback"<<endl;
  vector<string> * res_v = static_cast<vector<string> *>(res);
  int i;
  for(i=0; i<argc; i++){
    //    printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
    if(string(azColName[i])=="title"&&argv[i]){
      res_v->push_back(argv[i]);
      //      cout<<"DEB insert "<<argv[i]<<endl;
    }
    else {
      //      cout<<"DEB "<<azColName[i]<<"!=title"<<endl;
    }
  }
//  printf("\n");
  return 0;
}

string module_title(string mod){
  sqlite3 *db;
  char *zErrMsg = 0;
  int rc;
  rc = sqlite3_open("almdoc.sqlite", &db);
  if( rc ){
    fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
    sqlite3_close(db);
    exit(1);
  }
  string cmd = "select title from modules where name=\""+mod+"\";";
  vector<string> res;
  rc = sqlite3_exec(db, cmd.c_str(), module_title_callback, &res, &zErrMsg);
  if( rc!=SQLITE_OK ){
    fprintf(stderr, "SQL error: %s\n", zErrMsg);
    sqlite3_free(zErrMsg);
  }
  sqlite3_close(db);
  if(res.size()>0)
    return res[0];
  else {
    //  cout<<"DEB res "<<res.size()<<endl;
    return "none";
  }
}

void set_module_title(string mod,
		      string tit){
  sqlite3 *db;
  char *zErrMsg = 0;
  int rc;
  rc = sqlite3_open("almdoc.sqlite", &db);
  if( rc ){
    fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
    sqlite3_close(db);
    exit(1);
  }
  string cmd = "update modules set title=\""+tit+"\" where name=\""+mod+"\";";
  rc = sqlite3_exec(db, cmd.c_str(),0, 0, &zErrMsg);
  if( rc!=SQLITE_OK ){
    fprintf(stderr, "SQL error: %s\n", zErrMsg);
    sqlite3_free(zErrMsg);
  }
  sqlite3_close(db);
}

static int callback(void *NotUsed, int argc, char **argv, char **azColName){
  int i;
  for(i=0; i<argc; i++){
    printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
  }
  printf("\n");
  return 0;
}




map<string,string> mod_note;
map<string,string> mod_desc;
map<string,string> mod_title;
void navig(string href, string img, string alt, string & p){
  if(!href.size()){
    p += "<td class=\"online-navigation\"><img src=\"images/"+img+"\"";
    p += " border=\"0\" height=\"32\"  alt=\""+alt+"\" width=\"32\" /></td>\n";
  }
  else {
    p += "<td class=\"online-navigation\"><a href=\""+href+"\"><img src=\"images/"+img+"\"";
    p += " border=\"0\" height=\"32\"  alt=\""+alt+"\" width=\"32\" /></a></td>\n";
  }
}
bool inaqva = false;
struct DocPage {
  string title;
  string css;
  string logo;
  string save;
  string body;

  bool navigation;
    
  string prev;
  string up;
  string next;

  string toc;
  string mod;
  string idx;

  vector<string> ref;
  vector<string> desc;

  string backmatter;
  DocPage(){}
  DocPage(string t, string s,
	  string c="almost.css", string l ="almostlogo.png"){
    title = t;
    css = c;
    logo = l;
    save =s;

    //navi 
    navigation = true;
  }
  string page(){
    string p;
    front(*this,p);
    p += body;
    back(*this,p);
    return p;
  }

  void mkindex(){
    if(ref.size()&&ref.size()==desc.size()){
      body +=  "<h1>Contents</h1>\n";
      body += "<ul>\n";
      for(int i=0;i<ref.size();i++){
	body += "<li><a href=\""+ref[i]+"\">"+desc[i]+"</a></li>\n";
      }
      body += "</ul>\n";
    }
  }

  void savepage(){
    ofstream out; out.open(save.c_str());
    out << page();
  }
private:

  static void front(DocPage & html, string & p){
    //      p+="<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\n";
    p+="<html>\n";
    p+="<head>\n";
    p+="<title>"+html.title+"</title>\n";
    p+="<link href=\""+html.css+"\" REL=\"stylesheet\" TYPE=\"text/css\"/>\n";
    p+="</head>\n";
    p+="\n";
    p+="<body>\n";
    p+="<div id=\"page\">\n";
    //Navigation
    if(html.navigation){
      p += "<table  cellpadding=\"10\" cellspacing=\"0\" border=\"0\" width=\"100%\">\n";
      p += "<tr>\n";
      p += "<td class=\"main\">\n";
      // 	p += "<div class=\"navigation\">\n";
      // 	p += "<div id=\"top-navigation-panel\">\n";
      p += "<table align=\"center\" width=\"100%\" cellpadding=\"0\" cellspacing=\"2\">\n";
      p += "<tr>\n";
      navig(html.prev,"previous.png","Previous Page",p);
      navig(html.up,"up.png","Up",p);
      navig(html.next,"next.png","Next",p);
      if(!inaqva){
	p += "<td align=\"center\" width=\"100%\"><b>almost documentation</b></td>\n";
      }
      else {
	p += "<td align=\"center\"><b>almost documentation</b></td>\n";
      }
      navig(html.toc,"toc.png","Table Of Contents",p);
      navig(html.mod,"modules.png","Modules Index",p);
      navig(html.idx,"index.png","Index",p);
      p += "<td></td>\n";
      p += "</tr></table>\n";
      // 	p += "</div>\n";
      // 	p += "</div>\n";
      p += "</td>\n";
      p += "</tr>\n";
      p += "</table>\n";
      p += "<hr/>\n";
    }

    p+="<table>\n";
    p+="<tbody>\n";
    p+="<tr>\n";
    p+="<td></td>\n";
    p+="</tr>\n";
    p+="</tbody>\n";
    p+="</table>\n";
    p+="<center>\n";
    p+="<table width=\"100%\">\n";
    p+="<tbody>\n";
    p+="<tr>\n";
    p+="<td width=\"5\"></td>\n";
    p+="<td align=\"center\" width=\"90%\"><img src=\"images/"+html.logo+"\" alt=\"\"/></td>\n";
    p+="<td width=\"5\"></td>\n";
    p+="</tr>\n";
    p+="<tr>\n";
    p+="<td width=\"5\"></td>\n";
    p+="<td width=\"90%\">\n";
    p+="<!-- 	      domumentation here -->\n";
  }

  static void back(DocPage & html,string & p){
    p+="</td>\n";
    p+="<td width=\"5\"></td>\n";
    p+="</tr>\n";
    p+="</tbody>\n";
    p+="</table>\n";
    p+="</center>\n";
    p+="\n";
    if(html.backmatter.size())
      p+=html.backmatter;
    //Navigation
    if(html.navigation){
      p += "<hr/>\n";
      p += "<table  cellpadding=\"10\" cellspacing=\"0\" border=\"0\" width=\"100%\">\n";
      p += "<tr>\n";
      p += "<td class=\"main\">\n";
      // 	p += "<div class=\"navigation\">\n";
      // 	p += "<div id=\"top-navigation-panel\">\n";
      p += "<table align=\"center\" width=\"100%\" cellpadding=\"0\" cellspacing=\"2\">\n";
      p += "<tr>\n";
      navig(html.prev,"previous.png","Previous Page",p);
      navig(html.up,"up.png","Up",p);
      navig(html.next,"next.png","Next",p);
      if(!inaqva){
	p += "<td align=\"center\" width=\"100%\"><b>almost documentation</b></td>\n";
      }
      else {
	p += "<td align=\"center\"><b>almost documentation</b></td>\n";
      }
      navig(html.toc,"toc.png","Table Of Contents",p);
      navig(html.mod,"modules.png","Modules Index",p);
      navig(html.idx,"index.png","Index",p);
      p += "<td></td>\n";
      p += "</tr></table>\n";
      // 	p += "</div>\n";
      // 	p += "</div>\n";
      p += "</td>\n";
      p += "</tr>\n";
      p += "</table>\n";
      p += "<hr/>\n";
      time_t t = time(NULL);
      string tm = ctime(&t); 

      p += "<center><p><i>Release 1.0, documentation updated on "+tm+ ".</i></p></center>";
    }
    p+="</div>\n";
    p+="</body>\n";
    p+="</html>\n";
  }
};


void doctitle(DocPage &o,string s, string ref=""){
  if(ref==""){
    o.body += "<h2>"+s+"</h2>";
  }
  else {
    o.body +="<h2><a name=\""+ref+"\"> "+s+"</a></h2>";
  }
}

void docheader(DocPage &o,string s, string ref=""){
  if(ref==""){
    o.body += "<h1>"+s+"</h1>";
  }
  else {
    o.body +="<h1><a name=\""+ref+"\"> "+s+"</a></h1>";
  }
}

void docsubtitle(DocPage &o,string s, string ref=""){
  if(ref==""){
    o.body += "<h3>"+s+"</h3>";
  }
  else {
    o.body +="<h3><a name=\""+ref+"\"> "+s+"</a></h3>";
  }
}

void docsubsubtitle(DocPage &o,string s, string ref=""){
  if(ref==""){
    o.body += "<h4>"+s+"</h4>";
  }
  else {
    o.body +="<h4><a name=\""+ref+"\"> "+s+"</a></h4>";
  }
}

void docfunction(DocPage &o,string s,
		 string s2) { 
  o.body += "<p><dl><dt>"+ s +"</dt><dd>" +s2+ "</dd></dl></p>\n";
}

void mkclassdoc(DocPage & mod,ZExtClass * zc){
  string n = zc->val;
  docsubtitle(mod,"Class "+n);

  if(zc->class_doc.find("__class__")!=zc->class_doc.end()){
    string d = zc->class_doc["__class__"];
    boost::replace_all(d,"//","");
    mod.body += d;
    cout<<"DEBUG "<<n<<" yes \n";
  }
  else {
    cout<<"DEBUG "<<n<<" no \n";
  }

  if(zc->class_doc.find("__example__")!=zc->class_doc.end()){
    string d = zc->class_doc["__example__"];
    boost::replace_all(d,"//","");
    docsubsubtitle(mod,"Example:");
    mod.body += d;
    cout<<"DEBUG "<<n<<" yes \n";
  }
  else {
    cout<<"DEBUG "<<n<<" no \n";
  }


  map<string, string>::iterator iter = zc->class_desc.begin(),
    end = zc->class_desc.end();

  while(iter!=end){
    string tok = iter->first;
    if(zc->class_doc.find(tok)!=zc->class_doc.end()){
      string dstr = iter->second;
      boost::replace_first(dstr,iter->first,"<b><tt>"+iter->first+"</tt></b>");
      string docstr = zc->class_doc[tok];
      boost::replace_all(docstr,"<","&lt;");
      docfunction(mod,dstr,docstr);
    }
    ++iter;
  }
}

void mkmoddoc(string m,
	      string prev,string up, string next){
  DocPage mod(m+" Documentation",m+".html");
  mod.navigation = true;
  //Next up bla bla
  mod.prev = prev;
  mod.up = up;
  mod.next = next;
  mod.toc = "docindex.html";
  mod.mod = "docindex.html";
  mod.idx = "idx.html";
  ZModule * zmod;
  if(SymbolTable::instance().is_modulename(m)){
    zmod = (ZModule *)SymbolTable::current()[m];
  }
  else {
    cout<<m<<" isn't a module\n";
    return;
  }

  //classes
  {
    map<string,ZObj *>::iterator iter = zmod->module_map.begin(),
      end = zmod->module_map.end();
    vector<string> c;
    while(iter!=end){
      ZExtClass * zclass = dynamic_cast<ZExtClass*>(iter->second);
      if(zclass) c.push_back(iter->first);
      ++iter;
    }
    if(c.size()){
      doctitle(mod,"Module <tt>"+m+"</tt> classes");
      mod.body +="<ul>\n";
      for(int i=0;i<c.size();i++){
	mod.body +="<li>class "+ c[i] +"</li>\n";
      }
      mod.body +="</ul>\n";
    }
  }



  //functions
  {
    map<string,ZObj *>::iterator iter = zmod->module_map.begin(),
      end = zmod->module_map.end();
    vector<string> c;
    while(iter!=end){
      ZExtFunction * zclass = dynamic_cast<ZExtFunction*>(iter->second);
      if(zclass) c.push_back(iter->first);
      ++iter;
    }
    if(c.size()){
      doctitle(mod,"Module <tt>"+m+"</tt> functions");
      mod.body +="<ul>\n";
      for(int i=0;i<c.size();i++){
	mod.body +="<li>function "+ c[i] +"</li>\n";
      }
      mod.body +="</ul>\n";
    }
  }

  //classes doc
  {
    map<string,ZObj *>::iterator iter = zmod->module_map.begin(),
      end = zmod->module_map.end();
    vector<string> c;
    vector<ZExtClass *> zcl;
    while(iter!=end){
      ZExtClass * zclass = dynamic_cast<ZExtClass*>(iter->second);
      if(zclass){
	c.push_back(iter->first);
	zcl.push_back(zclass);
      }
      ++iter;
    }
    if(c.size()){
      doctitle(mod,"Classes Usage");
      for(int i=0;i<c.size();i++)
	mkclassdoc(mod,zcl[i]);
    }
  }


  //Functions doc
  {
    map<string,ZObj *>::iterator iter = zmod->module_map.begin(),
      end = zmod->module_map.end();
    vector<string> c;
    vector<ZExtFunction *> fun;
    while(iter!=end){
      ZExtFunction * zclass = dynamic_cast<ZExtFunction*>(iter->second);
      if(zclass) c.push_back(iter->first);
      ++iter;
    }
    if(c.size()){
      doctitle(mod,"Functions Usage");
      for(int i=0;i<c.size();i++){
	map<string,string>::const_iterator desc = 
	  zmod->module_desc.find(c[i]);
	if(desc!=zmod->module_desc.end()){ 
	  // 	  Almost::aout<<desc->second<<"\t"
	  // 		      <<iter->first
	  // 		      <<"\n";
	  
	  map<string,string>::const_iterator doc = 
	    zmod->module_doc.find(c[i]);
	  if(doc!=zmod->module_doc.end()){
	    // 	    Almost::aout<<"\t"<<doc->second
	    // 			<<"\n\n";
	    string des = desc->second;
	    boost::replace_first(des,c[i],"<b><tt>"+c[i]+"</tt></b>");
	    docfunction(mod,des,doc->second);
	  }
	}
	// 	else {
	// 	  Almost::aout<<"unknown \t"
	// 		      <<iter->first
	// 		      <<"\n";
	// 	}
      }
    }
  }

  //add note if existe
  if(mod_note.find(m)!=mod_note.end()){
    mod.backmatter = mod_note[m];
  }

  mod.savepage();
}


void mkhowtomd(string f){
  //howtobanner
  DocPage howtomd("HOWTO run a molecular dynamic simulation",f);
  howtomd.navigation = true;
  howtomd.prev = "docindex.html";
  howtomd.up = "docindex.html";
  howtomd.next = "docindex.html";
  howtomd.toc = "docindex.html";
  howtomd.mod = "docindex.html";
  howtomd.idx = "idx.html";
  docheader(howtomd,"HOWTO run a molecular dynamic simulation");
  string comment;
  string code;
  code = Almost::mdbload("all19_eef1.mdb",comment);
  howtomd.body += Almost::mkhowtostr(comment,code);

  code = Almost::pdbload("1ubq.pdb",comment);
  howtomd.body += Almost::mkhowtostr(comment,code);

  code = Almost::buildmols_and_prot("UBQ",comment);  
  howtomd.body += Almost::mkhowtostr(comment,code);

  code = Almost::setupmdoptions(comment);
  howtomd.body += Almost::mkhowtostr(comment,code);

  code = Almost::runmd(comment);
  howtomd.body += Almost::mkhowtostr(comment,code);

  howtomd.savepage();
}

void mkhowtomini(string f){
  //howtobanner
  DocPage howtomini("HOWTO minimize a PDB",f);
  howtomini.navigation = true;
  howtomini.prev = "docindex.html";
  howtomini.up = "docindex.html";
  howtomini.next = "docindex.html";
  howtomini.toc = "docindex.html";
  howtomini.mod = "docindex.html";
  howtomini.idx = "idx.html";
  docheader(howtomini,"HOWTO minimize a PDB");
  string comment;
  string code;
  code = Almost::mdbload("all19_eef1.mdb",comment);
  howtomini.body += Almost::mkhowtostr(comment,code);

  code = Almost::pdbload("1ubq.pdb",comment);
  howtomini.body += Almost::mkhowtostr(comment,code);

  code = Almost::build_missingmols_and_prot("UBQ",comment);  
  howtomini.body += Almost::mkhowtostr(comment,code);

  code = Almost::setupenergyoptions(comment);
  howtomini.body += Almost::mkhowtostr(comment,code);

  code = Almost::runmini(comment);
  howtomini.body += Almost::mkhowtostr(comment,code);

  howtomini.savepage();
}


void mkhowtoene(string f){
  //howtobanner
  DocPage howtoene("HOWTO compute the energy of a PDB",f);
  howtoene.navigation = true;
  howtoene.prev = "docindex.html";
  howtoene.up = "docindex.html";
  howtoene.next = "docindex.html";
  howtoene.toc = "docindex.html";
  howtoene.mod = "docindex.html";
  howtoene.idx = "idx.html";
  docheader(howtoene,"HOWTO compute the energy of a PDB");
  string comment;
  string code;
  code = Almost::mdbload("all19_eef1.mdb",comment);
  howtoene.body += Almost::mkhowtostr(comment,code);

  code =Almost::pdbload("1ubq.pdb",comment);
  howtoene.body += Almost::mkhowtostr(comment,code);

  code =Almost::build_missingmols_and_prot("UBQ",comment);  
  howtoene.body += Almost::mkhowtostr(comment,code);

  code =Almost::setupenergyoptions(comment);
  howtoene.body += Almost::mkhowtostr(comment,code);

  code =Almost::calcene(comment);
  howtoene.body += Almost::mkhowtostr(comment,code);


  howtoene.savepage();
}


void mkmodule_index(){
  DocPage index("almost doc","docindex.html");
  index.navigation = true;
  //Next up bla bla
  index.body += "<center><h1>almost documentation<h1></center>\n";
  index.body += "<center><h2>Andrea Cavalli<h2></center>\n";
  index.body += "<center><h3>amc82@cam.ac.uk<h3></center>\n";
  index.body += "<center><h3><b>Release 1.0</b><h3></center>\n";
  time_t t = time(NULL);
  string tm = ctime(&t); 
  index.body += "<center><h3><b>"+tm+"</b><h3></center>\n";
  index.body += "<hr>\n";

  //Tutorial
  docheader(index,"Tutorial");
  index.body +="<ul>\n";
  index.body +="<li><a href=\"howtomd.html\">HOWTO run a molecular dynamics simulation</a></li>\n";
  mkhowtomd("howtomd.html");

  index.body +="<li><a href=\"howtomini.html\">HOWTO minimize a PDB</a></li>\n";
  mkhowtomini("howtomini.html");

  index.body +="<li><a href=\"howtoene.html\">HOWTO compute the energy of a PDB</a></li>\n";
  mkhowtoene("howtoene.html");

  index.body +="</ul>\n";
  index.body +="<hr>\n";

  index.prev = "docindex.html";
  index.up = "docindex.html";
  index.next = "docindex.html";
  index.toc = "docindex.html";
  index.mod = "docindex.html";
  index.idx = "idx.html";

  vector<string> mod = SymbolTable::instance().modules_list();
  for(int i=0;i<mod.size();i++){
    index.ref.push_back(mod[i]+".html");
    string desc = "<tt>"+mod[i]+"</tt>";
    if(mod_title.find(mod[i])!=mod_title.end()){
      desc +=" -- "+mod_title[mod[i]];
    }
    else {
      desc += " -- module";
    }
    index.desc.push_back(desc);

    //
    string prev,up,next;
    if(i!=0) prev = mod[i-1]+".html";
    else prev = "docindex.html";
    up = "docindex.html";
    if(i!=mod.size()-1) next = mod[i+1]+".html";
    else next = mod[i]+".html";
      mkmoddoc(mod[i],prev,up,next);
  }
  index.mkindex();
  index.savepage();
}


ZExtClass * find_class(string m, string c){
   //Energy additions
    ZModule * zmod;
    ZExtClass * zclass = NULL;
    if(SymbolTable::instance().is_modulename(m)){
      zmod = (ZModule *)SymbolTable::current()[m];
      
      if(zmod->module_map.find(c)!=zmod->module_map.end()){
	zclass = (ZExtClass*)zmod->module_map[c];
	return zclass;
      }
    }

    return NULL;
}

ZModule * find_function(string m, string c){
    ZModule * zmod;
    ZExtFunction * zclass;
    //    ZExtFunction * zclass = NULL;
    if(SymbolTable::instance().is_modulename(m)){
      zmod = (ZModule *)SymbolTable::current()[m];
      
      if(zmod->module_map.find(c)!=zmod->module_map.end()){
	zclass = (ZExtFunction*)zmod->module_map[c];
	if(zclass) return zmod;
      }
    }
    return NULL;
}

int mkdoc__(){
  {
    //Module almost
    ZModule *f;
    f = find_function("almost","banner");
    if(f){
      f->module_doc["banner"] +=
	"<pre>\n"
	">>> almost.banner();\n"
	"almost 0.99.2 GNU C++ version 4.0.1 (Apple Computer, Inc. build 5363)\n"
	"Copyright (c) 2001-2004, Andrea Cavalli.\n"
	"This program is free software; you can redistribute it and/or\n"
	"modify it under the terms of the GNU General Public License\n"
	"as published by the Free Software Foundation; either version 2\n"
	"of the License, or (at your option) any later version.\n"
	"</pre>\n"
	;
    }


  }
  {
    //Module MDB
    ZExtClass * zclass = find_class("mdb","MDB");
    zclass->class_doc["__class__"] = 
      "// In <b><tt>almost</tt></b> the topology, i.e. the information about bonds, angles, etc., of molecules and the\n"
      "// parameters to build force fields are stored in a unique, plain text <b>molecular database</b> file.<br>"
      "// A MDB object is created using the class constructor  mdb.MDB(<em>file</em>) that parses the file.<br>\n"
      ;
  }
  {
    ZExtClass * zclass = find_class("pdb","pdb");
    zclass->class_doc["__class__"] = 
      "// <p>The pdb module provides an (almost) complete interface to <em>Protein databank</em> files.<br></p>\n"
      "// <p>A pdb object  is created by invoking the class constructor with the path to the pdb file as unique argument:\n"
      "// pdb.pdb(\"file\"). Note that <b><tt>almost</b></tt> is able to read compressed (with gzip or bzip2) files on the fly.<br></p>\n"
      "// <p>A pdb object is organized as a tree. A pdb can contain one or more models. Each model contains one or more chains (segments).\n"
      "// Chains are made of fragments and fragment of atoms.<br></p>\n"
      "// <p>In other words, if 'PDB' is an object of type PDB, then PDB[0] is the first model, PDB[0][0] the first segment of the first model,\n"
      "// and so on.<br></p>\n"
      ;

    zclass->class_doc["__example__"] = 
      "<pre>\n"
      ">> PDB = pdb.pdb(\"1ubq.pdb\");\n"
      ">> PDB = pdb.pdb(\"1ubq.pdb.bz2\");\n"
      ">> PDB = pdb.pdb(\"1ubq.pdb.gz\");\n"
      "</pre>\n"
      ;
  }
  {
    //module Molecules
    ZExtClass * zclass = find_class("molecules","protein");
    zclass->class_doc["__class__"] = 
      "// <p>The class protein is one of the four molecular classes implemented in <b><tt>almost</tt></b>. (The other are\n"
      "// lipid, nucleicacid and solvent). It stores chemical and geometric information about proteins.<br>\n"
      "// A protein object is constructed by creating first an empty \"protein container\" using\n"
      "// the class constructor molecules.protein(\"name\"). The name can be any string, but we suggest \n"
      "// that only string of length 3 are used, and this to follow the PDB convention that reserves\n"
      "// three letters for the chain name.<br>\n"
      "// An empty protein can then be filled using the build(), build_missing() or build_sequ() methods.<br>\n"
      "// The first two methods build a protein by taking the necessary information from the PDB segemt passed as first argument,\n"
      "// that last one (build_sequ()) will create a linear molecule using the default amino-acid geometry, as defined\n"
      "// in the molecular database file.<br></p>\n"
      ;
  }

  {
    //Module energy
    ZExtClass * zclass = find_class("energy","data");
    if(zclass){
      zclass->class_doc["__class__"] = 
	"// <p>The class data stores the result of an energy calculation.\n"
	"// The energy of the molecules is divided in components which can be accessed\n"
	"// with the \"e[\"component\"]\" function. So, as an example, e[\"energy\"] is equal to the total\n"
	"// energy of the molecules and e[\"vdw\"] to its van der Waals component.</p>\n"
	"// <p>Available terms are: energy, bond, angle, dihe, imph, vdw, elec, solv, ub and const.</p>\n"
	;		    
    }
  }

  return 1;
}


void mkdoc(){
  static int init = mkdoc__();

  //Sql
  {
    sqlite3 *db;
    char *zErrMsg = 0;
    int rc;

//     if( argc!=3 ){
//       fprintf(stderr, "Usage: %s DATABASE SQL-STATEMENT\n", argv[0]);
//       exit(1);
//     }
    rc = sqlite3_open("almdoc.sqlite", &db);
    if( rc ){
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      sqlite3_close(db);
      exit(1);
    }
    string cmd = "select * from modules;";
    rc = sqlite3_exec(db, cmd.c_str(), callback, 0, &zErrMsg);
    if( rc!=SQLITE_OK ){
      fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
    }
    sqlite3_close(db);
  }

  mkmodule_index();
}


void mkdoc_template_header(ofstream & out){
  out<<"<info>\n";
  out<<"<program name=\"almost\" version=\"1.0.0\" date=\"Tue Nov 14 13:01:47 CET 2006\"/>\n";
  out<<"<author name=\"Andrea Cavalli\" contact=\"amc82@bioc.unizh.ch\"/>\n";
  out<<"<docversion version=\"1.0.0\" date=\"Tue Nov 14 13:02:11 CET 2006\"></docversion>\n";
  out<<"</info>\n";
}


void mkdoc_template_class(ofstream & out,
			  ZExtClass * zc){

  map<string, string>::iterator iter = zc->class_desc.begin(),
    end = zc->class_desc.end();

  while(iter!=end){
    string tok = iter->first;
    if(zc->class_desc.size()>0){
      out<<"<member>\n";
      string dstr = iter->second;
      boost::replace_first(dstr,iter->first,"<b><tt>"+iter->first+"</tt></b>");
      string docstr;
      if(zc->class_doc.find(tok)!=zc->class_doc.end()){
	docstr = zc->class_doc[tok];
      }
      boost::replace_all(dstr,"&","&amp;");

      boost::replace_all(docstr,"<","&lt;");
      boost::replace_all(docstr,"&","&amp;");
      out<<"<type>"<<dstr<<"</type>\n";
      out<<"<desc>"<<docstr<<"</desc>\n";
      //      docfunction(mod,dstr,zc->class_doc[tok]);
      out<<"</member>\n";
    }
    ++iter;
  }

}

void mkdoc_template_modc(ofstream &out, string m){
  ZModule * zmod;
  if(SymbolTable::instance().is_modulename(m)){
    zmod = (ZModule *)SymbolTable::current()[m];
  }
  else {
    cout<<m<<" isn't a module\n";
    return;
  }

  //contants
  {
    map<string,ZObj *>::iterator iter = zmod->module_map.begin(),
      end = zmod->module_map.end();
    vector<string> c;
    while(iter!=end){
      if(zmod->module_desc.find(iter->first)!=zmod->module_desc.end()&&
	 zmod->module_desc[iter->first]=="symbolic constant")
	c.push_back(iter->first);
      ++iter;
    }
    if(c.size()){
      out<<"<constantlist>\n";
      for(int i=0;i<c.size();i++){
	out<<"<constant>\n";
	//format class
	out<<"<name>"<<c[i]<<"</name>\n";
	out<<"</constant>\n";
      }
      out<<"</constantlist>\n"; 
    } 
  }   

  //classes
  {
    map<string,ZObj *>::iterator iter = zmod->module_map.begin(),
      end = zmod->module_map.end();
    vector<string> c;
    while(iter!=end){
      ZExtClass * zclass = dynamic_cast<ZExtClass*>(iter->second);
      if(zclass) c.push_back(iter->first);
      ++iter;
    }
    if(c.size()){
      out<<"<classlist>\n";
      for(int i=0;i<c.size();i++){
	out<<"<class name=\""<<c[i]<<"\">\n";
	//format class
	mkdoc_template_class(out,
			     dynamic_cast<ZExtClass*>(zmod->module_map[c[i]]));
	out<<"</class>\n";
      }
      out<<"</classlist>\n"; 
    } 
  }   

  //functions
  {
    map<string,ZObj *>::iterator iter = zmod->module_map.begin(),
      end = zmod->module_map.end();
    vector<string> c;
    while(iter!=end){
      ZExtFunction * zfunction = dynamic_cast<ZExtFunction*>(iter->second);
      if(zfunction) c.push_back(iter->first);
      ++iter;
    }
    if(c.size()){
      out<<"<functionlist>\n";
      for(int i=0;i<c.size();i++){
	out<<"<function>\n";
	//format function
	out<<"<name>"<<c[i]<<"</name>\n";
	map<string,string>::const_iterator desc = 
	  zmod->module_desc.find(c[i]);
	if(desc!=zmod->module_desc.end()){ 
	  string d = desc->second;
	  boost::replace_all(d,"&","&amp;");
	  out<<"<desc>"<<d<<"</desc>\n";
	  {
	  //Find out return value
	    boost::regex expression("[^[:space:]]+");
	    boost::match_results<std::string::const_iterator> what;
	    boost::match_flag_type flags = boost::match_default; 
	    if(regex_search(desc->second.begin(), 
			    desc->second.end(),
			    what, expression, flags)){
	      cout<<"Rerun val: "<<string(what[0].first,
					  what[0].second)
		  <<endl;
	    }
	  }
	}
	map<string,string>::const_iterator doc = 
	  zmod->module_doc.find(c[i]);
	if(doc!=zmod->module_doc.end()){ 
	  out<<"<doc>"<<doc->second<<"</doc>\n";
	}
	
	out<<"</function>\n";
      }
      out<<"</functionlist>\n"; 
    } 
  }   

}


void mkdoc_template_modulelist(ofstream & out){
  out<<"<modulelist>\n";
  vector<string> mod = SymbolTable::instance().modules_list();
  for(int i=0;i<mod.size();i++){
    out<<"<module>\n";
    out<<"<name>"<<mod[i]<<"</name>\n";
    out<<"<title>";
    if(mod_title.find(mod[i])!=mod_title.end()){
      out<<mod_title[mod[i]];
    }
//     else {
//       out<<"##MISSING##";
//       cout<<"Warning title of module: "<<mod[i]<<" missing\n";
//     }
    out<<"</title>\n";
    out<<"<desc>\n";
    out<<"</desc>\n";
    //    mkmoddoc(mod[i],prev,up,next);
    mkdoc_template_modc(out,mod[i]);
    out<<"</module>\n";
  }

  out<<"</modulelist>\n";
}

void mkdoc_template(string name){
  ofstream out; out.open(name.c_str());

  if(!out){
    Almost::aout<<"Unable to open: "<<name<<endl;
    throw "almost ioerror.";
  }

  out<<"<?xml version=\"1.0\" encoding=\"ISO-Latin-1\"?>\n";
  out<<"<doc>\n";
  mkdoc_template_header(out);
  mkdoc_template_modulelist(out);


  out<<"</doc>\n";
}



using namespace Almost;

extern "C" {
  void init_doc(){
    //declarations here
    //Modules titles
    {
      mod_title["aggresign"] = "Aggregation propensity tools";
      mod_title["almost"] = "Environment";
      mod_title["analysis"] = "Analysis tools";
      mod_title["blast"] = "Interface to ncbi blast";
      mod_title["const"] = "Molecular dynamics and Monte Carlo restraints";
      mod_title["dcd"] = "Trajectory tools";
      mod_title["dyna"] = "Monte Carlo simulations";
      mod_title["dynamip"] = "Replica Monte Carlo simulations";
      mod_title["energy"] = "Energy computation";
      mod_title["fragments"] = "Fragment replacement tools";
      mod_title["math"] = "Mathematical functions";
      mod_title["mbmd"] = "Multi-Berendsen molecular dyanmics";
      mod_title["md"] = "Molecular dynamics";
      mod_title["mdb"] = "Molecular database";
      mod_title["mdx"] = "Replica molecular dynamics";
      mod_title["minimize"] = "Energy minimization";
      mod_title["modeler"] = "Homoogy modeler";
      mod_title["molecules"] = "Build and modify molecules";
      mod_title["moveset"] = "Monte Carlo moveset";
      mod_title["os"] = "Operating system functions";
      mod_title["pdb"] = "Protein Databank parser";
      mod_title["pdbstat"] = "Compute statistics on sets of PDBs";
      mod_title["regex"] = "boost regular expression engine";
      mod_title["rose"] = "Molecular fragment replacement";
      mod_title["secstruct"] = "Compute secondary structure of proteins";
      mod_title["select"] = "Select atoms in molecules";
      mod_title["shx"] = "All about chemical shifts ";
      mod_title["sys"] = "System functions";
      mod_title["zeta"] = "Script language functions";
    }
    //add notes
    mod_note["math"] =
      "<div class=\"note\"><b class=\"label\">Note: </b>"
      "The <tt class=\"module\">math</tt> module consists mostly of thin wrappers around "
      "the platform C math library functions.  Behavior in exceptional cases is "
      "loosely specified by the C standards, and <tt>almost</tt> inherits much of its "
      "math-function error-reporting behavior from the platform C "
      "implementation.  As a result, "
      "the specific exceptions raised in error cases (and even whether some "
      "arguments are considered to be exceptional at all) are not defined in any "
      "useful cross-platform or cross-release way.  For example, whether "
      "<code>math.log(0)</code> returns <code>-Inf</code> or raises <tt class=\"exception\">ValueError</tt> or "
      "<tt class=\"exception\">OverflowError</tt> isn't defined, and in "
      "cases where <code>math.log(0)</code> raises <tt class=\"exception\">OverflowError</tt>, "
      "<code>math.log(0L)</code> may raise <tt class=\"exception\">ValueError</tt> instead. "
      "</div>"
      ;

    mod_desc["math"] =
      "<p>This module provides access to the mathematical functions and constants defined by the C standard.</p>"
      "<h2>Example</h2>"
      "<p><pre>print math.sin(1.2);</pre>"
      "Should print 0.932039 to your console.</p>";
    
    mod_desc["mdb"] = 
      "<p>The mdb module implements classes an functions to parse and edit MDB files.<br>"
      "<b><tt>almost</tt></b> uses mdb files to store informations about the topology of molecules and to store the parameters\n"
      "needed to build firce fields.</p>\n"
      ;
    mod_desc["pdb"] = "<p>This module provides an (almost) complete access to <em>Protein databank</em> files.</p>"; 

    Module mod = Module("doc","Generate doc")
      .def_function("mkdoc","Generates almost documentation",mkdoc)
      .def_function("mkdoc_template","Generates almost documentation template in XML format.",mkdoc_template)
      .def_function("module_title","",module_title)
      .def_function("set_module_title","",set_module_title)
      ;

    Class<SQLDoc,ArgList1<string> >(mod.self(),"sqldoc")
      .def_method("update_modules_list",&SQLDoc::update_modules_list)
      .def_method("set_module_title",&SQLDoc::set_module_title)
      .def_method("set_module_desc",&SQLDoc::set_module_desc)
      .def_method("set_function_desc",&SQLDoc::set_function_desc)
      .def_method("update_constants",&SQLDoc::update_constants)
      .def_method("update_functions",&SQLDoc::update_functions)
      .def_method("update_classes",&SQLDoc::update_classes)
      ;
  }
}