#include "xmlditadocvisitor.h"

#include "docparser.h"

#include "language.h"

#include "doxygen.h"

#include "outputgen.h"

#include "xmlgen.h"

#include "dot.h"

#include "message.h"

#include "util.h"

#include <qfileinfo.h> 

#include "parserintf.h"

XmlDitaDocVisitor::XmlDitaDocVisitor(XmlStream &s,CodeOutputInterface &ci) 

  : DocVisitor(DocVisitor_XML), xmlStream(s), xmlElemStack(s), m_ci(ci), m_insidePre(FALSE), m_hide(FALSE), 

    m_insideParamlist(FALSE), paramMap(), paramDict(), currParam()

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

  // visitor functions for leaf nodes

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

void XmlDitaDocVisitor::visit(DocWord *w)

{

	if (m_hide) {

		return;

	}

	// Catches normal text (text outside of a tag or command)

	// and puts it in a "p"

	if (xmlElemStack.isEmpty()) {

		visitPreDefault("p");

	}	

	write(w->word());

}

void XmlDitaDocVisitor::visit(DocLinkedWord *w)

{

	if (m_hide) {

		return;

	}

	} else {

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

	}

	write(w->word());

	endLink();

}

void XmlDitaDocVisitor::visit(DocWhiteSpace *w)

{

	if (m_hide) {

		return;

	}

	if (m_insidePre) {

		write(w->chars());

	} else {

		write(" ");

	}

}

void XmlDitaDocVisitor::visit(DocSymbol *s)

{

  if (m_hide) {

	return;

  }

  switch(s->symbol())

  {

    case DocSymbol::BSlash:  write("\\"); break;

    case DocSymbol::At:      write("@"); break;

	// NOTE: The XMl stream will translate entities i.e. "&" to "&"

    case DocSymbol::Less:    write("<"); break;

    case DocSymbol::Greater: write(">"); break;

    case DocSymbol::Amp:     write("&"); break;

    case DocSymbol::Dollar:  write("$"); break;

    case DocSymbol::Hash:    write("#"); break;

    case DocSymbol::Percent: write("%"); break;

	case DocSymbol::Apos:    write("'"); break;

    case DocSymbol::Quot:    write("\""); break;

	case DocSymbol::Copy:    xmlStream.writeUnicode("copy");	break;

    case DocSymbol::Tm:      xmlStream.writeUnicode("trade");	break;

    case DocSymbol::Reg:     xmlStream.writeUnicode("reg");		break;

    case DocSymbol::Lsquo:   xmlStream.writeUnicode("lsquo");		break;

    case DocSymbol::Rsquo:	 xmlStream.writeUnicode("rsquo");		break;

    case DocSymbol::Ldquo:	 xmlStream.writeUnicode("ldquo");		break;

    case DocSymbol::Rdquo:	 xmlStream.writeUnicode("rdquo");		break;

    case DocSymbol::Ndash:	 xmlStream.writeUnicode("ndash");		break;

    case DocSymbol::Mdash:	 xmlStream.writeUnicode("mdash");		break;

	case DocSymbol::Uml:	 xmlStream.writeUnicode((const char*)(QString(QChar(s->letter()))+"uml")); break;

	case DocSymbol::Acute:	 xmlStream.writeUnicode((const char*)(QString(QChar(s->letter()))+"acute")); break;

	case DocSymbol::Grave:	 xmlStream.writeUnicode((const char*)(QString(QChar(s->letter()))+"grave")); break;

	case DocSymbol::Circ:	 xmlStream.writeUnicode((const char*)(QString(QChar(s->letter()))+"circ")); break;

	case DocSymbol::Tilde:	 xmlStream.writeUnicode((const char*)(QString(QChar(s->letter()))+"tilde")); break;

	case DocSymbol::Cedil:	 xmlStream.writeUnicode((const char*)(QString(QChar(s->letter()))+"cedil")); break;

	case DocSymbol::Ring:	 xmlStream.writeUnicode((const char*)(QString(QChar(s->letter()))+"ring")); break;

	case DocSymbol::Slash:	 xmlStream.writeUnicode((const char*)(QString(QChar(s->letter()))+"slash")); break;

    case DocSymbol::Szlig:	 xmlStream.writeUnicode("szlig");					   break;

    case DocSymbol::Nbsp:    xmlStream.writeUnicode("nbsp");					   break;

    case DocSymbol::Aelig:	 xmlStream.writeUnicode("aelig");					   break;

    case DocSymbol::AElig:   xmlStream.writeUnicode("AElig");					   break;

    default:

		err("Error: unknown symbol found\n");

  }

}

void XmlDitaDocVisitor::visit(DocURL *u)

{

	if (m_hide) {

	  return;

	}

	if (u->isEmail()) {

		startXref(QString("mailto:")+QString(u->url()), u->url());

	} else {

	}

	endXref();

}

void XmlDitaDocVisitor::visit(DocLineBreak *lb)

{

	if (m_hide){

	  return;

	}

	//pushpop("linebreak");

	//if (lb->parent()->kind() == lb->Kind_Verbatim) {

	if (m_insidePre) {

		write("\n");

	}

}

void XmlDitaDocVisitor::visit(DocHorRuler *)

{

	if (m_hide) {

	  return;

	}

	//pushpop("hruler");

	xmlStream.comment("hruler not supported by DITA 1.1");

}

void XmlDitaDocVisitor::visit(DocStyleChange *s)

{

	if (m_hide) {

	  return;

	}

	switch (s->style())

	{

	case DocStyleChange::Bold:

		if (s->enable()) {

			push("b");

		} else { 

			pop("b");

		}

		break;

	case DocStyleChange::Italic:

		if (s->enable()) {

			push("i");

		} else {

			pop("i");

		}

		break;

	case DocStyleChange::Code:

		if (s->enable()) {

			push("tt");

		} else {

			pop("tt");

		}

		break;

	case DocStyleChange::Subscript:

		if (s->enable()) {

			push("sub");

		} else {

			pop("sub");

		}

		break;

	case DocStyleChange::Superscript:

		if (s->enable()) {

			push("sup");

		} else {

			pop("sup");

		}

		break;

	case DocStyleChange::Center:

		if (s->enable()) {

			xmlStream.comment("center not supported by DITA 1.1");

			//push("center");

		} else {

			//pop("center");

		}

		break;

	case DocStyleChange::Small:

		if (s->enable()) {

			xmlStream.comment("small not supported by DITA 1.1");

			//push("small");

		} else {

			//pop("small");

		}

		break;

	case DocStyleChange::Preformatted:

		if (s->enable()) 

		{

			push("pre");  

			m_insidePre = TRUE;

		} else {

			pop("pre");

			m_insidePre = FALSE;

		}

		break;

	case DocStyleChange::Div:  /* HTML only */ break;

	case DocStyleChange::Span: /* HTML only */ break;

	}

}

void XmlDitaDocVisitor::visit(DocVerbatim *s)

{

	if (m_hide) {

	  return;

	}

	switch(s->type())

	{

		case DocVerbatim::Code:

			push("codeblock");

			write(s->text());

			pop("codeblock");

			break;

		case DocVerbatim::Verbatim:

			pushpop("pre", s->text());

			break;

		case DocVerbatim::HtmlOnly: 

			//pushpop("htmlonly", s->text());

			break;

		case DocVerbatim::ManOnly: 

			//pushpop("manonly", s->text());

			break;

		case DocVerbatim::LatexOnly: 

			//pushpop("latexonly", s->text());

			break;

		case DocVerbatim::XmlOnly: 

			write(s->text());

			break;

		case DocVerbatim::Dot: 

			//pushpop("dot", s->text());

			break;

		case DocVerbatim::Msc: 

			//pushpop("msc", s->text());

			break;

	}

}

void XmlDitaDocVisitor::visit(DocAnchor *anc)

{

	if (m_hide) {

	  return;

	}

	xmlElemStack.addAttribute("id", anc->file()+"_1"+anc->anchor());

	//push("anchor", "id", anc->file()+"_1"+anc->anchor());

	//pop("anchor");

}

void XmlDitaDocVisitor::visit(DocInclude *inc)

{

	if (m_hide) {

	  return;

	}

  switch(inc->type())

  {

    case DocInclude::IncWithLines:

      { 

         push("codeblock");

         QFileInfo cfi( inc->file() );

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

         Doxygen::parserManager->getParser(inc->extension())

                               ->parseCode(m_ci,inc->context(),

                                           inc->text().latin1(),

                                           inc->isExample(),

                                           inc->exampleFile(), &fd);

         pop("codeblock"); 

      }

      break;    

    case DocInclude::Include: 

      push("codeblock");

      Doxygen::parserManager->getParser(inc->extension())

                            ->parseCode(m_ci,inc->context(),

                                        inc->text().latin1(),

                                        inc->isExample(),

                                        inc->exampleFile());

      pop("codeblock"); 

      break;

    case DocInclude::DontInclude: 

      break;

    case DocInclude::HtmlInclude: 

	  //pushpop("htmlonly", inc->text());

      break;

    case DocInclude::VerbInclude: 

	  pushpop("pre", inc->text());

      break;

  }

}

void XmlDitaDocVisitor::visit(DocIncOperator *op)

{

  if (op->isFirst()) 

  {

    if (!m_hide) {

		push("codeblock");

    }

    pushEnabled();

    m_hide = TRUE;

  }

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

  {

    popEnabled();

    if (!m_hide) {

      Doxygen::parserManager->getParser(m_langExt)

                            ->parseCode(m_ci,op->context(),

                                        op->text().latin1(),op->isExample(),

                                        op->exampleFile());

    }

    pushEnabled();

    m_hide=TRUE;

  }

  if (op->isLast())  

  {

    popEnabled();

	if (!m_hide) {

		pop("codeblock"); 

	}

  }

}

void XmlDitaDocVisitor::visit(DocFormula *f)

{

	write(f->text());

#if 0

	if (m_hide) {

	  return;

	}

  QString s;

  s.setNum(f->id());

  push("formula", "id", s);

  write(f->text());

  pop("formula");

#endif

}

void XmlDitaDocVisitor::visit(DocIndexEntry *ie)

{

	if (m_hide) {

	  return;

	}

	push("indexterm");

	write(ie->entry());

	pop("indexterm");

#if 0

	push("indexentry");

	push("primaryie");

	write(ie->entry());

	pop("primaryie");

	pushpop("secondaryie");

	pop("indexentry");

#endif

}

void XmlDitaDocVisitor::visit(DocSimpleSectSep *)

{

  //pushpop("simplesectsep");

}

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

// visitor functions for compound nodes

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

void XmlDitaDocVisitor::visitPre(DocAutoList *l)

{

	if (m_hide) {

	  return;

	}

	if (l->isEnumList()) {

		push("ol");

	} else {

		push("ul");

	}

}

void XmlDitaDocVisitor::visitPost(DocAutoList *l)

{

	if (l->isEnumList()) {

		visitPostDefault("ol");

	} else {

		visitPostDefault("ul");

	}

}

void XmlDitaDocVisitor::visitPre(DocAutoListItem *)

{

	visitPreDefault("li");

}

void XmlDitaDocVisitor::visitPost(DocAutoListItem *) 

{

	visitPostDefault("li");

}

void XmlDitaDocVisitor::visitPre(DocPara *p) 

{

		visitPreDefault("p");

	}

}

void XmlDitaDocVisitor::visitPost(DocPara *)

{

		visitPostDefault("p");

	}

}

void XmlDitaDocVisitor::visitPre(DocRoot *)

void XmlDitaDocVisitor::visitPost(DocRoot *)

void XmlDitaDocVisitor::visitPre(DocSimpleSect *s)

{

	if (m_hide) {

	  return;

	}

	switch(s->type())

	{

		// Fall through

		case DocSimpleSect::See:		

		case DocSimpleSect::Return:		

		case DocSimpleSect::Author:		

		case DocSimpleSect::Authors:	

		case DocSimpleSect::Version:	

		case DocSimpleSect::Since:		

		case DocSimpleSect::Date:		

		case DocSimpleSect::Pre:		

		case DocSimpleSect::Post:		

		case DocSimpleSect::Invar:		

		case DocSimpleSect::User:		

		case DocSimpleSect::Rcs:		

				push("p"); 

			}

			break;

		case DocSimpleSect::Note:		

			push("note", "type", "note"); 

			break;

		case DocSimpleSect::Warning:	

			push("note", "type", "caution"); 

			break;

		case DocSimpleSect::Remark:		

			push("note", "type", "other"); 

			break;

		case DocSimpleSect::Attention: