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

 *

 * 

 *

 *

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

 *

 * 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.

 *

 */

#ifdef _WIN32

#include <windows.h>

#define BITMAP W_BITMAP

#endif

#include <stdlib.h>

#include "dot.h"

#include "doxygen.h"

#include "message.h"

#include "util.h"

#include "config.h"

#include "language.h"

#include "defargs.h"

#include "docparser.h"

#include "debug.h"

#include "pagedef.h"

#include "portable.h"

#include "dirdef.h"

#include <qdir.h>

#include <qfile.h>

#include <qtextstream.h>

#include <md5.h>

#define MAP_CMD "cmapx"

//#define FONTNAME "FreeSans"

#define FONTNAME getDotFontName()

#define FONTSIZE getDotFontSize()

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

static const int maxCmdLine = 40960;

/*! mapping from protection levels to color names */

static const char *edgeColorMap[] =

{

  "midnightblue",  // Public

  "darkgreen",     // Protected

  "firebrick4",    // Private

  "darkorchid3",   // "use" relation

  "grey75",        // Undocumented

  "orange"         // template relation

};

static const char *arrowStyle[] =

{

  "empty",         // Public

  "empty",         // Protected

  "empty",         // Private

  "open",          // "use" relation

  0,               // Undocumented

  0                // template relation

};

static const char *edgeStyleMap[] =

{

  "solid",         // inheritance

  "dashed"         // usage

};

static QCString getDotFontName()

{

  static QCString dotFontName = Config_getString("DOT_FONTNAME");

  if (dotFontName.isEmpty()) dotFontName="FreeSans";

  return dotFontName;

}

static int getDotFontSize()

{

  static int dotFontSize = Config_getInt("DOT_FONTSIZE");

  if (dotFontSize<4) dotFontSize=4;

  return dotFontSize;

}

static void writeGraphHeader(QTextStream &t)

{

  t << "digraph G" << endl;

  t << "{" << endl;

  if (Config_getBool("DOT_TRANSPARENT"))

  {

    t << "  bgcolor=\"transparent\";" << endl;

  }

  t << "  edge [fontname=\"" << FONTNAME << "\","

       "fontsize=\"" << FONTSIZE << "\","

       "labelfontname=\"" << FONTNAME << "\","

       "labelfontsize=\"" << FONTSIZE << "\"];\n";

  t << "  node [fontname=\"" << FONTNAME << "\","

       "fontsize=\"" << FONTSIZE << "\",shape=record];\n";

}

static void writeGraphFooter(QTextStream &t)

{

  t << "}" << endl;

}

/*! converts the rectangles in a client site image map into a stream

 *  \param t the stream to which the result is written.

 *  \param mapName the name of the map file.

 *  \param relPath the relative path to the root of the output directory

 *                 (used in case CREATE_SUBDIRS is enabled).

 *  \param urlOnly if FALSE the url field in the map contains an external

 *                 references followed by a $ and then the URL.

 *  \param context the context (file, class, or namespace) in which the

 *                 map file was found

 *  \returns TRUE if succesful.

 */

static bool convertMapFile(QTextStream &t,const char *mapName,

                           const QCString relPath, bool urlOnly=FALSE,

                           const QString &context=QString())

{

  QFile f(mapName);

  if (!f.open(IO_ReadOnly)) 

  {

    err("Error opening map file %s for inclusion in the docs!\n"

        "If you installed Graphviz/dot after a previous failing run, \n"

        "try deleting the output directory and rerun doxygen.\n",mapName);

    return FALSE;

  }

  const int maxLineLen=10240;

  while (!f.atEnd()) // foreach line

  {

    QCString buf(maxLineLen);

    int numBytes = f.readLine(buf.data(),maxLineLen);

    buf[numBytes-1]='\0';

    if (buf.left(5)=="<area")

    {

      // search for href="...", store ... part in link

      int indexS = buf.find("href=\""), indexE;

      if (indexS!=-1 && (indexE=buf.find('"',indexS+6))!=-1)

      {

        QCString link = buf.mid(indexS+6,indexE-indexS-6);

        QCString result;

        QCString *dest;

        if (urlOnly) // for user defined dot graphs

        {

          if (link.left(5)=="\\ref ") // \ref url

          {

            result="href=\"";

            // fake ref node to resolve the url

            DocRef *df = new DocRef( (DocNode*) 0, link.mid(5), context );

            if (!df->ref().isEmpty())

            {

              if ((dest=Doxygen::tagDestinationDict[df->ref()])) 

                result += *dest + "/";

            }

            else if (!relPath.isEmpty())

            {

              result += relPath;

            }

            if (!df->file().isEmpty())  

              result += df->file().data() + Doxygen::htmlFileExtension;

            if (!df->anchor().isEmpty()) 

              result += "#" + df->anchor();

            delete df;

            result += "\"";

          }

          else

          {

            result = "href=\"" + link + "\"";

          }

        }

        else // ref$url (external ref via tag file), or $url (local ref)

        {

          int marker = link.find('$');

          if (marker!=-1)

          {

            QCString ref = link.left(marker);

            QCString url = link.mid(marker+1);

            if (!ref.isEmpty())

            {

              result = "doxygen=\"" + ref + ":";

              if ((dest=Doxygen::tagDestinationDict[ref])) result += *dest + "/";

              result += "\" ";

            }

            result+= "href=\"";

            if (!ref.isEmpty())

            {

              if ((dest=Doxygen::tagDestinationDict[ref])) result += *dest + "/";

            }

            else if (!relPath.isEmpty())

            {

              result += relPath;

            }

            result+= url + "\"";

          }

          else // should not happen, but handle properly anyway

          {

            result = "href=\"" + link + "\"";

          }

        }

        QCString leftPart = buf.left(indexS);

        QCString rightPart = buf.mid(indexE+1);

        buf = leftPart + result + rightPart;

      }

      t << buf;

    }

  }

  return TRUE;

}

static QArray<int> s_newNumber;

static int s_max_newNumber=0;

inline int reNumberNode(int number, bool doReNumbering)

{

  if (!doReNumbering) 

  {

    return number;

  } 

  else 

  {

    int s = s_newNumber.size();

    if (number>=s) 

    {

      int ns=0;

      ns = s * 3 / 2 + 5; // new size

      if (number>=ns) // number still doesn't fit

      {

        ns = number * 3 / 2 + 5;

      }

      s_newNumber.resize(ns);

      for (int i=s;i<ns;i++) // clear new part of the array

      {

        s_newNumber.at(i)=0;

      }

    }

    int i = s_newNumber.at(number);

    if (i == 0) // not yet mapped

    {

      i = ++s_max_newNumber; // start from 1

      s_newNumber.at(number) = i;

    }

    return i;

  }

}

static void resetReNumbering() 

{

  s_max_newNumber=0;

  s_newNumber.resize(s_max_newNumber);

}

static QCString g_dotFontPath;

static void setDotFontPath(const char *path)

{

  ASSERT(g_dotFontPath.isEmpty());

  g_dotFontPath = portable_getenv("DOTFONTPATH");

  QCString newFontPath = Config_getString("DOT_FONTPATH");

  if (!newFontPath.isEmpty() && path)

  {

    newFontPath.prepend(path+portable_pathListSeparator());

  }

  else if (newFontPath.isEmpty() && path)

  {

    newFontPath=path;

  }

  else

  {

    portable_unsetenv("DOTFONTPATH");

    return;

  }

  portable_setenv("DOTFONTPATH",newFontPath);

}

static void unsetDotFontPath()

{

  portable_setenv("DOTFONTPATH",g_dotFontPath);

  g_dotFontPath="";

}

static bool readBoundingBoxEPS(const char *fileName,int *width,int *height)

{

  QCString bb("%%PageBoundingBox:");

  QFile f(fileName);

  if (!f.open(IO_ReadOnly)) return FALSE;

  const int maxLineLen=1024;

  char buf[maxLineLen];

  while (!f.atEnd())

  {

    int numBytes = f.readLine(buf,maxLineLen-1); // read line

    buf[numBytes]='\0';

    if (strncmp(buf,bb.data(),bb.length()-1)==0) // found PageBoundingBox string

    {

      int x,y;

      if (sscanf(buf+bb.length(),"%d %d %d %d",&x,&y,width,height)!=4)

      {

        return FALSE;

      }

      return TRUE;

    }

  }

  return FALSE;

}

// since dot silently reproduces the input file when it does not

// support the PNG format, we need to check the result.

static void checkDotResult(const QCString &imgName)

{

  if (Config_getEnum("DOT_IMAGE_FORMAT")=="png")

  {

    QFile f(imgName);

    if (f.open(IO_ReadOnly))

    {

      char data[4];

      if (f.readBlock(data,4)==4)

      {

        if (!(data[1]=='P' && data[2]=='N' && data[3]=='G'))

        {

          err("Error! Image `%s' produced by dot is not a valid PNG!\n"

              "You should either select a different format "

              "(DOT_IMAGE_FORMAT in the config file) or install a more "

              "recent version of graphviz (1.7+)\n",imgName.data()

             );

        }

      }

      else

      {

        err("Error: Could not read image `%s' generated by dot!\n",imgName.data());

      }

    }

    else

    {

      err("Error: Could not open image `%s' generated by dot!\n",imgName.data());

    }

  }

}

/*! Checks if a file "baseName".md5 exists. If so the contents

 *  are compared with \a md5. If equal FALSE is returned. If the .md5

 *  file does not exist or its contents are not equal to \a md5, 

 *  a new .md5 is generated with the \a md5 string as contents.

 */

static bool checkAndUpdateMd5Signature(const QCString &baseName,const QCString &md5)

{

  QFile f(baseName+".md5");

  if (f.open(IO_ReadOnly))

  {

    // read checksum

    QCString md5stored(33);

    int bytesRead=f.readBlock(md5stored.data(),32);

    md5stored[32]='\0';

    // compare checksum

    if (bytesRead==32 && md5==md5stored)

    {

      // bail out if equal

      return FALSE;

    }

  }

  f.close();

  // create checksum file

  if (f.open(IO_WriteOnly))

  {

    f.writeBlock(md5.data(),32); 

    f.close();

  }

  return TRUE;

}

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

class DotNodeList : public QList<DotNode>

{

  public:

    DotNodeList() : QList<DotNode>() {}

   ~DotNodeList() {}

   int compareItems(GCI item1,GCI item2)

   {

     return stricmp(((DotNode *)item1)->m_label,((DotNode *)item2)->m_label);

   }

};

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

DotRunner::DotRunner(const char *file) : m_file(file)

{

  m_jobs.setAutoDelete(TRUE);

}

void DotRunner::addJob(const char *format,const char *output)

{

  QCString args = QCString("-T")+format+" -o \""+output+"\"";

  m_jobs.append(new QCString(args));

}

void DotRunner::addPostProcessing(const char *cmd,const char *args)

{

  m_postCmd = cmd;

  m_postArgs = args;

}

bool DotRunner::run()

{

  int exitCode=0;

  static QCString dotExe = Config_getString("DOT_PATH")+"dot";

  QCString dotArgs;

  QListIterator<QCString> li(m_jobs);

  QCString *s;

  if (Config_getBool("DOT_MULTI_TARGETS"))

  {

    dotArgs="\""+m_file+"\"";

    for (li.toFirst();(s=li.current());++li)

    {

      dotArgs+=' ';

      dotArgs+=*s;

    }

    if ((exitCode=portable_system(dotExe,dotArgs,FALSE))!=0)

    {

      goto error;

    }

  }

  else

  {

    for (li.toFirst();(s=li.current());++li)

    {

      dotArgs="\""+m_file+"\" "+*s;

      if ((exitCode=portable_system(dotExe,dotArgs,FALSE))!=0)

      {

        goto error;

      }

    }

  }

  if (!m_postCmd.isEmpty() && portable_system(m_postCmd,m_postArgs)!=0)

  {

    err("Error: Problems running '%s' as a post-processing step for dot output\n",m_postCmd.data());

    return FALSE;

  }

  return TRUE;

error:

  err("Problems running dot: exit code=%d, command='%s', arguments='%s'\n",

      exitCode,dotExe.data(),dotArgs.data());

  return FALSE;

}

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

/*! helper function that deletes all nodes in a connected graph, given

 *  one of the graph's nodes

 */

static void deleteNodes(DotNode *node,SDict<DotNode> *skipNodes=0)

{

  //printf("deleteNodes skipNodes=%p\n",skipNodes);

  static DotNodeList deletedNodes;

  deletedNodes.setAutoDelete(TRUE);

  node->deleteNode(deletedNodes,skipNodes); // collect nodes to be deleted.

  deletedNodes.clear(); // actually remove the nodes.

}

DotNode::DotNode(int n,const char *lab,const char *tip, const char *url,

                 bool isRoot,ClassDef *cd)

  : m_subgraphId(-1)

  , m_number(n)

  , m_label(lab)

  , m_tooltip(tip)

  , m_url(url)

  , m_parents(0)

  , m_children(0)

  , m_edgeInfo(0)

  , m_deleted(FALSE)

  , m_written(FALSE)

  , m_hasDoc(FALSE)

  , m_isRoot(isRoot)

  , m_classDef(cd)

  , m_visible(FALSE)

  , m_truncated(Unknown)

  , m_distance(1000)

{

}

DotNode::~DotNode()

{

  delete m_children;

  delete m_parents;

  delete m_edgeInfo;

}

void DotNode::addChild(DotNode *n,

                       int edgeColor,

                       int edgeStyle,

                       const char *edgeLab,

                       const char *edgeURL,

                       int edgeLabCol

                      )

{

  if (m_children==0)

  {

    m_children = new QList<DotNode>;

    m_edgeInfo = new QList<EdgeInfo>;

    m_edgeInfo->setAutoDelete(TRUE);

  }

  m_children->append(n);

  EdgeInfo *ei = new EdgeInfo;

  ei->m_color = edgeColor;

  ei->m_style = edgeStyle; 

  ei->m_label = edgeLab;

  ei->m_url   = edgeURL;

  if (edgeLabCol==-1)

    ei->m_labColor=edgeColor;

  else

    ei->m_labColor=edgeLabCol;

  m_edgeInfo->append(ei);

}

void DotNode::addParent(DotNode *n)

{

  if (m_parents==0)