/******************************************************************************

 *

 *

 *

 *

 * Copyright (C) 1997-2015 by Dimitri van Heesch.

 * Authors: Dimitri van Heesch, Miguel Lobo.

 *

 * Permission to use, copy, modify, and distribute this software and its

 * documentation under the terms of the GNU General Public License is hereby

 * granted. No representations are made about the suitability of this software

 * for any purpose. It is provided "as is" without express or implied warranty.

 * See the GNU General Public License for more details.

 *

 * Documents produced by Doxygen are derivative works derived from the

 * input used in their production; they are not affected by this license.

 *

 */

#include <stdlib.h>

#include <qdir.h>

#include <qstack.h>

#include <qdict.h>

#include <qfile.h>

#include "perlmodgen.h"

#include "docparser.h"

#include "message.h"

#include "doxygen.h"

#include "pagedef.h"

#include "memberlist.h"

#include "ftextstream.h"

#include "arguments.h"

#include "config.h"

#include "groupdef.h"

#include "classdef.h"

#include "classlist.h"

#include "filename.h"

#include "membername.h"

#include "namespacedef.h"

#include "membergroup.h"

#include "section.h"

#include "util.h"

#include "htmlentity.h"

#define PERLOUTPUT_MAX_INDENTATION 40

class PerlModOutputStream

{

public:

  QCString m_s;

  FTextStream *m_t;

  PerlModOutputStream(FTextStream *t = 0) : m_t(t) { }

  void add(char c);

  void add(const char *s);

  void add(QCString &s);

  void add(int n);

  void add(unsigned int n);

};

void PerlModOutputStream::add(char c)

{

  if (m_t != 0)

    (*m_t) << c;

  else

    m_s += c;

}

void PerlModOutputStream::add(const char *s)

{

  if (m_t != 0)

    (*m_t) << s;

  else

    m_s += s;

}

void PerlModOutputStream::add(QCString &s)

{

  if (m_t != 0)

    (*m_t) << s;

  else

    m_s += s;

}

void PerlModOutputStream::add(int n)

{

  if (m_t != 0)

    (*m_t) << n;

  else

    m_s += n;

}

void PerlModOutputStream::add(unsigned int n)

{

  if (m_t != 0)

    (*m_t) << n;

  else

    m_s += n;

}

class PerlModOutput

{

public:

  bool m_pretty;

  inline PerlModOutput(bool pretty)

    : m_pretty(pretty), m_stream(0), m_indentation(false), m_blockstart(true)

  {

    m_spaces[0] = 0;

  }

  virtual ~PerlModOutput() { }

  inline void setPerlModOutputStream(PerlModOutputStream *os) { m_stream = os; }

  inline PerlModOutput &openSave() { iopenSave(); return *this; }

  inline PerlModOutput &closeSave(QCString &s) { icloseSave(s); return *this; }

  inline PerlModOutput &continueBlock()

  {

    if (m_blockstart)

      m_blockstart = false;

    else

      m_stream->add(',');

    indent();

    return *this;

  }

  inline PerlModOutput &add(char c) { m_stream->add(c); return *this; }

  inline PerlModOutput &add(const char *s) { m_stream->add(s); return *this; }

  inline PerlModOutput &add(QCString &s) { m_stream->add(s); return *this; }

  inline PerlModOutput &add(int n) { m_stream->add(n); return *this; }

  inline PerlModOutput &add(unsigned int n) { m_stream->add(n); return *this; }

  PerlModOutput &addQuoted(const char *s) { iaddQuoted(s); return *this; }

  inline PerlModOutput &indent()

  {

    if (m_pretty) {

      m_stream->add('\n');

      m_stream->add(m_spaces);

    }

    return *this;

  }

  inline PerlModOutput &open(char c, const char *s = 0) { iopen(c, s); return *this; }

  inline PerlModOutput &close(char c = 0) { iclose(c); return *this; }

  inline PerlModOutput &addField(const char *s) { iaddField(s); return *this; }

  inline PerlModOutput &addFieldQuotedChar(const char *field, char content)

  {

    iaddFieldQuotedChar(field, content); return *this;

  }

  inline PerlModOutput &addFieldQuotedString(const char *field, const char *content)

  {

    iaddFieldQuotedString(field, content); return *this;

  }

  inline PerlModOutput &addFieldBoolean(const char *field, bool content)

  {

    return addFieldQuotedString(field, content ? "yes" : "no");

  }

  inline PerlModOutput &openList(const char *s = 0) { open('[', s); return *this; }

  inline PerlModOutput &closeList() { close(']'); return *this; }

  inline PerlModOutput &openHash(const char *s = 0 ) { open('{', s); return *this; }

  inline PerlModOutput &closeHash() { close('}'); return *this; }

protected:

  void iopenSave();

  void icloseSave(QCString &);

  void incIndent();

  void decIndent();

  void iaddQuoted(const char *);

  void iaddFieldQuotedChar(const char *, char);

  void iaddFieldQuotedString(const char *, const char *);

  void iaddField(const char *);

  void iopen(char, const char *);

  void iclose(char);

private:

  PerlModOutputStream *m_stream;

  int m_indentation;

  bool m_blockstart;

  QStack<PerlModOutputStream> m_saved;

  char m_spaces[PERLOUTPUT_MAX_INDENTATION * 2 + 2];

};

void PerlModOutput::iopenSave()

{

  m_saved.push(m_stream);

  m_stream = new PerlModOutputStream();

}

void PerlModOutput::icloseSave(QCString &s)

{

  s = m_stream->m_s;

  delete m_stream;

  m_stream = m_saved.pop();

}

void PerlModOutput::incIndent()

{

  if (m_indentation < PERLOUTPUT_MAX_INDENTATION)

  {

    char *s = &m_spaces[m_indentation * 2];

    *s++ = ' '; *s++ = ' '; *s = 0;

  }

  m_indentation++;

}

void PerlModOutput::decIndent()

{

  m_indentation--;

  if (m_indentation < PERLOUTPUT_MAX_INDENTATION)

    m_spaces[m_indentation * 2] = 0;

}

void PerlModOutput::iaddQuoted(const char *s) 

{

  char c;

  while ((c = *s++) != 0) {

    if ((c == '\'') || (c == '\\'))

      m_stream->add('\\');

    m_stream->add(c);

  }

}

void PerlModOutput::iaddField(const char *s)

{

  continueBlock();

  m_stream->add(s);

  m_stream->add(m_pretty ? " => " : "=>");

}

void PerlModOutput::iaddFieldQuotedChar(const char *field, char content)

{

  iaddField(field);

  m_stream->add('\'');

  if ((content == '\'') || (content == '\\'))

    m_stream->add('\\');

  m_stream->add(content);

  m_stream->add('\'');

}

void PerlModOutput::iaddFieldQuotedString(const char *field, const char *content)

{

  if (content == 0)

    return;

  iaddField(field);

  m_stream->add('\'');

  iaddQuoted(content);

  m_stream->add('\'');

}

void PerlModOutput::iopen(char c, const char *s)

{

  if (s != 0)

    iaddField(s);

  else

    continueBlock();

  m_stream->add(c);

  incIndent();

  m_blockstart = true;

}

void PerlModOutput::iclose(char c)

{

  decIndent(); 

  indent();

  if (c != 0)

    m_stream->add(c); 

  m_blockstart = false;

}

/*! @brief Concrete visitor implementation for PerlMod output. */

class PerlModDocVisitor : public DocVisitor

{

public:

  PerlModDocVisitor(PerlModOutput &);

  virtual ~PerlModDocVisitor() { }

  void finish();

  //--------------------------------------

  // visitor functions for leaf nodes

  //--------------------------------------

  void visit(DocWord *);

  void visit(DocLinkedWord *);

  void visit(DocWhiteSpace *);

  void visit(DocSymbol *);

  void visit(DocURL *);

  void visit(DocLineBreak *);

  void visit(DocHorRuler *);

  void visit(DocStyleChange *);

  void visit(DocVerbatim *);

  void visit(DocAnchor *);

  void visit(DocInclude *);

  void visit(DocIncOperator *);

  void visit(DocFormula *);

  void visit(DocIndexEntry *);

  void visit(DocSimpleSectSep *);

  void visit(DocCite *);

  //--------------------------------------

  // visitor functions for compound nodes

  //--------------------------------------

  void visitPre(DocAutoList *);

  void visitPost(DocAutoList *);

  void visitPre(DocAutoListItem *);

  void visitPost(DocAutoListItem *);

  void visitPre(DocPara *) ;

  void visitPost(DocPara *);

  void visitPre(DocRoot *);

  void visitPost(DocRoot *);

  void visitPre(DocSimpleSect *);

  void visitPost(DocSimpleSect *);

  void visitPre(DocTitle *);

  void visitPost(DocTitle *);

  void visitPre(DocSimpleList *);

  void visitPost(DocSimpleList *);

  void visitPre(DocSimpleListItem *);

  void visitPost(DocSimpleListItem *);

  void visitPre(DocSection *);

  void visitPost(DocSection *);

  void visitPre(DocHtmlList *);

  void visitPost(DocHtmlList *) ;

  void visitPre(DocHtmlListItem *);

  void visitPost(DocHtmlListItem *);

  //void visitPre(DocHtmlPre *);

  //void visitPost(DocHtmlPre *);

  void visitPre(DocHtmlDescList *);

  void visitPost(DocHtmlDescList *);

  void visitPre(DocHtmlDescTitle *);

  void visitPost(DocHtmlDescTitle *);

  void visitPre(DocHtmlDescData *);

  void visitPost(DocHtmlDescData *);

  void visitPre(DocHtmlTable *);

  void visitPost(DocHtmlTable *);

  void visitPre(DocHtmlRow *);

  void visitPost(DocHtmlRow *) ;

  void visitPre(DocHtmlCell *);

  void visitPost(DocHtmlCell *);

  void visitPre(DocHtmlCaption *);

  void visitPost(DocHtmlCaption *);

  void visitPre(DocInternal *);

  void visitPost(DocInternal *);

  void visitPre(DocHRef *);

  void visitPost(DocHRef *);

  void visitPre(DocHtmlHeader *);

  void visitPost(DocHtmlHeader *);

  void visitPre(DocImage *);

  void visitPost(DocImage *);

  void visitPre(DocDotFile *);

  void visitPost(DocDotFile *);

  void visitPre(DocMscFile *);

  void visitPost(DocMscFile *);

  void visitPre(DocDiaFile *);

  void visitPost(DocDiaFile *);

  void visitPre(DocLink *);

  void visitPost(DocLink *);

  void visitPre(DocRef *);

  void visitPost(DocRef *);

  void visitPre(DocSecRefItem *);

  void visitPost(DocSecRefItem *);

  void visitPre(DocSecRefList *);

  void visitPost(DocSecRefList *);

  //void visitPre(DocLanguage *);

  //void visitPost(DocLanguage *);

  void visitPre(DocParamSect *);

  void visitPost(DocParamSect *);

  void visitPre(DocParamList *);

  void visitPost(DocParamList *);

  void visitPre(DocXRefItem *);

  void visitPost(DocXRefItem *);

  void visitPre(DocInternalRef *);

  void visitPost(DocInternalRef *);

  void visitPre(DocCopy *);

  void visitPost(DocCopy *);

  void visitPre(DocText *);

  void visitPost(DocText *);

  void visitPre(DocHtmlBlockQuote *);

  void visitPost(DocHtmlBlockQuote *);

  void visitPre(DocVhdlFlow *);

  void visitPost(DocVhdlFlow *);

  void visitPre(DocParBlock *);

  void visitPost(DocParBlock *);

private:

  //--------------------------------------

  // helper functions

  //--------------------------------------

  void addLink(const QCString &ref, const QCString &file,

	       const QCString &anchor);

  void enterText();

  void leaveText();

  void openItem(const char *);

  void closeItem();

  void singleItem(const char *);

  void openSubBlock(const char * = 0);

  void closeSubBlock();

  void openOther();

  void closeOther();

  //--------------------------------------

  // state variables

  //--------------------------------------

  PerlModOutput &m_output;

  bool m_textmode;

  bool m_textblockstart;

  QCString m_other;

};

PerlModDocVisitor::PerlModDocVisitor(PerlModOutput &output)

  : DocVisitor(DocVisitor_Other), m_output(output), m_textmode(false)

{

  m_output.openList("doc");

}

void PerlModDocVisitor::finish()

{

  leaveText();

  m_output.closeList()

    .add(m_other);

}

void PerlModDocVisitor::addLink(const QCString &,const QCString &file,const QCString &anchor)

{

  QCString link = file;

  if (!anchor.isEmpty())

    (link += "_1") += anchor;

  m_output.addFieldQuotedString("link", link);

}

void PerlModDocVisitor::openItem(const char *name)

{

  leaveText();

  m_output.openHash().addFieldQuotedString("type", name);

}

void PerlModDocVisitor::closeItem()

{

  leaveText();

  m_output.closeHash();

}

void PerlModDocVisitor::enterText()

{

  if (m_textmode)

    return;

  openItem("text");

  m_output.addField("content").add('\'');

  m_textmode = true;

}

void PerlModDocVisitor::leaveText()

{

  if (!m_textmode)

    return;

  m_textmode = false;

  m_output

    .add('\'')

    .closeHash();

}

void PerlModDocVisitor::singleItem(const char *name)

{

  openItem(name);

  closeItem();

}

void PerlModDocVisitor::openSubBlock(const char *s)

{

  leaveText();

  m_output.openList(s);

  m_textblockstart = true;

}

void PerlModDocVisitor::closeSubBlock()

{

  leaveText();

  m_output.closeList();

}

void PerlModDocVisitor::openOther()

{

  // Using a secondary text stream will corrupt the perl file. Instead of

  // printing doc => [ data => [] ], it will print doc => [] data => [].

  /*

  leaveText();

  m_output.openSave();

  */

}

void PerlModDocVisitor::closeOther()

{

  // Using a secondary text stream will corrupt the perl file. Instead of

  // printing doc => [ data => [] ], it will print doc => [] data => [].

  /*

  QCString other;

  leaveText();

  m_output.closeSave(other);

  m_other += other;

  */

}

void PerlModDocVisitor::visit(DocWord *w)

{

  enterText();

  m_output.addQuoted(w->word());

}

void PerlModDocVisitor::visit(DocLinkedWord *w)

{

  openItem("url");

  addLink(w->ref(), w->file(), w->anchor());

  m_output.addFieldQuotedString("content", w->word());

  closeItem();

}

void PerlModDocVisitor::visit(DocWhiteSpace *)

{

  enterText();

  m_output.add(' ');

}

void PerlModDocVisitor::visit(DocSymbol *sy)

{

  const DocSymbol::PerlSymb *res = HtmlEntityMapper::instance()->perl(sy->symbol());

  const char *accent=0;

  if (res-> symb)

  {

    switch (res->type)

    {

      case DocSymbol::Perl_string:

        enterText();

        m_output.add(res->symb);

        break;

      case DocSymbol::Perl_char:

        enterText();

        m_output.add(res->symb[0]);

        break;

      case DocSymbol::Perl_symbol:

        leaveText();

        openItem("symbol");

        m_output.addFieldQuotedString("symbol", res->symb);

        closeItem();

        break;

      default:

        switch(res->type)

        {

          case DocSymbol::Perl_umlaut:

            accent = "umlaut";

            break;

          case DocSymbol::Perl_acute:

            accent = "acute";

            break;

          case DocSymbol::Perl_grave:

            accent = "grave";

            break;

          case DocSymbol::Perl_circ:

            accent = "circ";

            break;

          case DocSymbol::Perl_slash:

            accent = "slash";

            break;

          case DocSymbol::Perl_tilde:

            accent = "tilde";

            break;

          case DocSymbol::Perl_cedilla:

            accent = "cedilla";

            break;

          case DocSymbol::Perl_ring:

            accent = "ring";

            break;

          default:

            break;

        }

        leaveText();

        if (accent)

        {

          openItem("accent");

          m_output

            .addFieldQuotedString("accent", accent)

            .addFieldQuotedChar("letter", res->symb[0]);

          closeItem();

        }

        break;

    }

  }

  else

  {

    err("perl: non supported HTML-entity found: %s\n",HtmlEntityMapper::instance()->html(sy->symbol(),TRUE));

  }

}

void PerlModDocVisitor::visit(DocURL *u)

{

  openItem("url");

  m_output.addFieldQuotedString("content", u->url());

  closeItem();

}

void PerlModDocVisitor::visit(DocLineBreak *) { singleItem("linebreak"); }

void PerlModDocVisitor::visit(DocHorRuler *) { singleItem("hruler"); }

void PerlModDocVisitor::visit(DocStyleChange *s)

{

  const char *style = 0;

  switch (s->style())

  {

    case DocStyleChange::Bold:          style = "bold"; break;

    case DocStyleChange::Italic:        style = "italic"; break;

    case DocStyleChange::Code:          style = "code"; break;

    case DocStyleChange::Subscript:     style = "subscript"; break;

    case DocStyleChange::Superscript:   style = "superscript"; break;

    case DocStyleChange::Center:        style = "center"; break;

    case DocStyleChange::Small:         style = "small"; break;

    case DocStyleChange::Preformatted:  style = "preformatted"; break;

    case DocStyleChange::Div:           style = "div"; break;

    case DocStyleChange::Span:          style = "span"; break;

  }

  openItem("style");

  m_output.addFieldQuotedString("style", style)

    .addFieldBoolean("enable", s->enable());

  closeItem();

}

void PerlModDocVisitor::visit(DocVerbatim *s)

{

  const char *type = 0;

  switch (s->type())

  {

    case DocVerbatim::Code:

#if 0

      m_output.add("<programlisting>");

      parseCode(m_ci,s->context(),s->text(),FALSE,0);

      m_output.add("</programlisting>");

      return;

#endif

    case DocVerbatim::Verbatim:  type = "preformatted"; break;

    case DocVerbatim::HtmlOnly:  type = "htmlonly";     break;

    case DocVerbatim::RtfOnly:   type = "rtfonly";      break;

    case DocVerbatim::ManOnly:   type = "manonly";      break;

    case DocVerbatim::LatexOnly: type = "latexonly";    break;

    case DocVerbatim::XmlOnly:   type = "xmlonly";      break;

    case DocVerbatim::DocbookOnly: type = "docbookonly"; break;

    case DocVerbatim::Dot:       type = "dot";          break;

    case DocVerbatim::Msc:       type = "msc";          break;

    case DocVerbatim::PlantUML:  type = "plantuml";     break;

  }

  openItem(type);

  if (s->hasCaption())

  {

     openSubBlock("caption");

     QListIterator<DocNode> cli(s->children());

     DocNode *n;

     for (cli.toFirst();(n=cli.current());++cli) n->accept(this);

     closeSubBlock();

  }

  m_output.addFieldQuotedString("content", s->text());

  closeItem();

}

void PerlModDocVisitor::visit(DocAnchor *anc)

{

  QCString anchor = anc->file() + "_1" + anc->anchor();

  openItem("anchor");

  m_output.addFieldQuotedString("id", anchor);

  closeItem();

}

void PerlModDocVisitor::visit(DocInclude *inc)

{

  const char *type = 0;

  switch(inc->type())

  {

  case DocInclude::IncWithLines:

  #if 0

      { 

         m_t << "
";

         QFileInfo cfi( inc->file() );

         FileDef fd( cfi.dirPath(), cfi.fileName() );

         parseCode(m_ci,inc->context(),inc->text().latin1(),inc->isExample(),inc->exampleFile(), &fd;;

         m_t << ""; 

      }

      break;

  #endif

    return;

  case DocInclude::Include:

#if 0

    m_output.add("<programlisting>");

    parseCode(m_ci,inc->context(),inc->text(),FALSE,0);

    m_output.add("</programlisting>");

#endif

    return;

  case DocInclude::DontInclude:	return;

  case DocInclude::HtmlInclude:	type = "htmlonly"; break;

  case DocInclude::LatexInclude: type = "latexonly"; break;

  case DocInclude::VerbInclude:	type = "preformatted"; break;

  case DocInclude::Snippet: return;

  case DocInclude::SnipWithLines: return;

  case DocInclude::SnippetDoc: 

  case DocInclude::IncludeDoc: 

    err("Internal inconsistency: found switch SnippetDoc / IncludeDoc in file: %s"

        "Please create a bug report\n",__FILE__);

    break;

  }

  openItem(type);

  m_output.addFieldQuotedString("content", inc->text());

  closeItem();

}

void PerlModDocVisitor::visit(DocIncOperator *)

{

#if 0

  //printf("DocIncOperator: type=%d first=%d, last=%d text=`%s'\n",

  //    op->type(),op->isFirst(),op->isLast(),op->text().data());

  if (op->isFirst())

  {

    m_output.add("<programlisting>");

  }

  if (op->type()!=DocIncOperator::Skip)

  {

    parseCode(m_ci,op->context(),op->text(),FALSE,0);

  }

  if (op->isLast()) 

  {

    m_output.add("</programlisting>");

  }

  else

  {

    m_output.add('\n');

  }

#endif

}

void PerlModDocVisitor::visit(DocFormula *f)

{

  openItem("formula");

  QCString id;

  id += f->id();

  m_output.addFieldQuotedString("id", id).addFieldQuotedString("content", f->text());

  closeItem();

}

void PerlModDocVisitor::visit(DocIndexEntry *)

{

#if 0

  m_output.add("<indexentry>"

	       "<primaryie>");

  m_output.addQuoted(ie->entry());

  m_output.add("</primaryie>"

	       "<secondaryie></secondaryie>"

	       "</indexentry>");

#endif

}

void PerlModDocVisitor::visit(DocSimpleSectSep *)

{

}

void PerlModDocVisitor::visit(DocCite *cite)

{

  openItem("cite");

  m_output.addFieldQuotedString("text", cite->text());

  closeItem();

}

//--------------------------------------

// visitor functions for compound nodes

//--------------------------------------

void PerlModDocVisitor::visitPre(DocAutoList *l)

{

  openItem("list");

  m_output.addFieldQuotedString("style", l->isEnumList() ? "ordered" : "itemized");

  openSubBlock("content");

}

void PerlModDocVisitor::visitPost(DocAutoList *)

{

  closeSubBlock();

  closeItem();

}

void PerlModDocVisitor::visitPre(DocAutoListItem *)

{

  openSubBlock();

}

void PerlModDocVisitor::visitPost(DocAutoListItem *)

{

  closeSubBlock();

}

void PerlModDocVisitor::visitPre(DocPara *)

{

  if (m_textblockstart)

    m_textblockstart = false;

  else

    singleItem("parbreak");

  /*

  openItem("para");

  openSubBlock("content");

  */

}

void PerlModDocVisitor::visitPost(DocPara *)

{

  /*

  closeSubBlock();

  closeItem();

  */

}

void PerlModDocVisitor::visitPre(DocRoot *)

{

}

void PerlModDocVisitor::visitPost(DocRoot *)

{

}

void PerlModDocVisitor::visitPre(DocSimpleSect *s)

{

  const char *type = 0;

  switch (s->type())

  {

  case DocSimpleSect::See:		type = "see"; break;

  case DocSimpleSect::Return:		type = "return"; break;

  case DocSimpleSect::Author:		type = "author"; break;

  case DocSimpleSect::Authors:		type = "authors"; break;

  case DocSimpleSect::Version:		type = "version"; break;

  case DocSimpleSect::Since:		type = "since"; break;

  case DocSimpleSect::Date:		type = "date"; break;

  case DocSimpleSect::Note:		type = "note"; break;

  case DocSimpleSect::Warning:		type = "warning"; break;

  case DocSimpleSect::Pre:		type = "pre"; break;

  case DocSimpleSect::Post:		type = "post"; break;

  case DocSimpleSect::Copyright:	type = "copyright"; break;

  case DocSimpleSect::Invar:		type = "invariant"; break;

  case DocSimpleSect::Remark:		type = "remark"; break;

  case DocSimpleSect::Attention:	type = "attention"; break;

  case DocSimpleSect::User:		type = "par"; break;

  case DocSimpleSect::Rcs:		type = "rcs"; break;

  case DocSimpleSect::Unknown:

    err("unknown simple section found\n");

    break;

  }

  leaveText();

  m_output.openHash();

  openOther();

  openSubBlock(type);

}

void PerlModDocVisitor::visitPost(DocSimpleSect *)

{

  closeSubBlock();

  closeOther();

  m_output.closeHash();

}