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

 *

 * 

 *

 *

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

#include <qregexp.h>

#include "qtbc.h"

#include "groupdef.h"

#include "classdef.h"

#include "filedef.h"

#include "classlist.h"

#include "outputlist.h"

#include "namespacedef.h"

#include "language.h"

#include "util.h"

#include "memberlist.h"

#include "message.h"

#include "membergroup.h"

#include "doxygen.h"

#include "pagedef.h"

#include "docparser.h"

#include "searchindex.h"

#include "dot.h"

#include "vhdldocgen.h"

#include "layout.h"

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

GroupDef::GroupDef(const char *df,int dl,const char *na,const char *t,

                   const char *refFileName) : Definition(df,dl,na)

{

  fileList = new FileList;

  classSDict = new ClassSDict(17);

  groupList = new GroupList;

  namespaceSDict = new NamespaceSDict(17);

  pageDict = new PageSDict(17);

  exampleDict = new PageSDict(17);

  dirList = new DirList;

  allMemberNameInfoSDict = new MemberNameInfoSDict(17);

  if (refFileName)

  {

    fileName=stripExtension(refFileName);

  }

  else

  {

    fileName = (QCString)"group_"+na;

  }

  setGroupTitle( t );

  memberGroupSDict = new MemberGroupSDict;

  memberGroupSDict->setAutoDelete(TRUE);

  allMemberList = new MemberList(MemberList::allMembersList);

  visited = 0;

  groupScope = 0;

}

GroupDef::~GroupDef()

{

  delete fileList;

  delete classSDict;

  delete groupList;

  delete namespaceSDict;

  delete pageDict;

  delete exampleDict;

  delete allMemberList;

  delete allMemberNameInfoSDict;

  delete memberGroupSDict;

  delete dirList;

}

void GroupDef::setGroupTitle( const char *t )

{

  if ( t && strlen(t) )

  {

    title = t;

    titleSet = TRUE;

  }

  else

  {

    title = name();

    title.at(0)=toupper(title.at(0));

    titleSet = FALSE;

  }

}

void GroupDef::distributeMemberGroupDocumentation()

{

  MemberGroupSDict::Iterator mgli(*memberGroupSDict);

  MemberGroup *mg;

  for (;(mg=mgli.current());++mgli)

  {

    mg->distributeMemberGroupDocumentation();

  }

}

void GroupDef::findSectionsInDocumentation()

{

  docFindSections(documentation(),this,0,docFile());

  MemberGroupSDict::Iterator mgli(*memberGroupSDict);

  MemberGroup *mg;

  for (;(mg=mgli.current());++mgli)

  {

    mg->findSectionsInDocumentation();

  }

  QListIterator<MemberList> mli(m_memberLists);

  MemberList *ml;

  for (mli.toFirst();(ml=mli.current());++mli)

  {

    if (ml->listType()&MemberList::declarationLists)

    {

      ml->findSectionsInDocumentation();

    }

  }

}

void GroupDef::addFile(const FileDef *def)

{

  if (def->isHidden()) return;

  if (Config_getBool("SORT_BRIEF_DOCS"))

    fileList->inSort(def);

  else

    fileList->append(def);

}

bool GroupDef::addClass(const ClassDef *cd)

{

  if (cd->isHidden()) return FALSE;

  if (classSDict->find(cd->name())==0)

  {

    if (Config_getBool("SORT_BRIEF_DOCS"))

      classSDict->inSort(cd->name(),cd);

    else

      classSDict->append(cd->name(),cd);

    return TRUE;

  }

  return FALSE;

}

bool GroupDef::addNamespace(const NamespaceDef *def)

{

  if (def->isHidden()) return FALSE;

  if (namespaceSDict->find(def->name())==0)

  {

    if (Config_getBool("SORT_BRIEF_DOCS"))

      namespaceSDict->inSort(def->name(),def);  

    else

      namespaceSDict->append(def->name(),def);

    return TRUE;

  }

  return FALSE;

}

void GroupDef::addDir(const DirDef *def)

{

  if (def->isHidden()) return;

  if (Config_getBool("SORT_BRIEF_DOCS"))

    dirList->inSort(def);  

  else

    dirList->append(def);

}

void GroupDef::addPage(PageDef *def)

{

  if (def->isHidden()) return;

  //printf("Making page %s part of a group\n",def->name.data());

  pageDict->append(def->name(),def);

  def->makePartOfGroup(this);

}

void GroupDef::addExample(const PageDef *def)

{

  if (def->isHidden()) return;

  exampleDict->append(def->name(),def);

}

void GroupDef::addMembersToMemberGroup()

{

  QListIterator<MemberList> mli(m_memberLists);

  MemberList *ml;

  for (mli.toFirst();(ml=mli.current());++mli)

  {

    if (ml->listType()&MemberList::declarationLists)

    {

      ::addMembersToMemberGroup(ml,&memberGroupSDict,this);

    }

  }

  //printf("GroupDef::addMembersToMemberGroup() memberGroupList=%d\n",memberGroupList->count());

  MemberGroupSDict::Iterator mgli(*memberGroupSDict);

  MemberGroup *mg;

  for (;(mg=mgli.current());++mgli)

  {

    mg->setInGroup(TRUE);

  }

}

bool GroupDef::insertMember(MemberDef *md,bool docOnly)

{

  if (md->isHidden()) return FALSE;

  //printf("GroupDef(%s)::insertMember(%s)\n", title.data(), md->name().data());

  MemberNameInfo *mni=0;

  if ((mni=(*allMemberNameInfoSDict)[md->name()]))

  { // member with this name already found

    MemberNameInfoIterator srcMnii(*mni); 

    MemberInfo *srcMi;

    for ( ; (srcMi=srcMnii.current()) ; ++srcMnii )

    {

      MemberDef *srcMd = srcMi->memberDef;

      if (srcMd==md) return FALSE; // already added before!

      bool sameScope = srcMd->getOuterScope()==md->getOuterScope() || // same class or namespace

          // both inside a file => definition and declaration do not have to be in the same file

           (srcMd->getOuterScope()->definitionType()==Definition::TypeFile &&

            md->getOuterScope()->definitionType()==Definition::TypeFile); 

      LockingPtr<ArgumentList> srcMdAl = srcMd->argumentList();

      LockingPtr<ArgumentList> mdAl    = md->argumentList();

      if (srcMd->isFunction() && md->isFunction() && 

          matchArguments2(srcMd->getOuterScope(),srcMd->getFileDef(),srcMdAl.pointer(),

                          md->getOuterScope(),md->getFileDef(),mdAl.pointer(),

                          TRUE

                         ) &&

          sameScope

         )

      {

        if (srcMd->getGroupAlias()==0) 

        {

          md->setGroupAlias(srcMd); 

        }

        else

        {

          md->setGroupAlias(srcMd->getGroupAlias()); 

        }

        return FALSE; // member is the same as one that is already added

      }

    }

    mni->append(new MemberInfo(md,md->protection(),md->virtualness(),FALSE));

  }

  else

  {

    mni = new MemberNameInfo(md->name());

    mni->append(new MemberInfo(md,md->protection(),md->virtualness(),FALSE));

    allMemberNameInfoSDict->append(mni->memberName(),mni);

  }

  //printf("Added member!\n");

  allMemberList->append(md); 

  switch(md->memberType())

  {

    case MemberDef::Variable:     

      if (!docOnly)

      {

        addMemberToList(MemberList::decVarMembers,md);

      }

      addMemberToList(MemberList::docVarMembers,md);

      break;

    case MemberDef::Function: 

      if (!docOnly)

      {

        addMemberToList(MemberList::decFuncMembers,md);

      }

      addMemberToList(MemberList::docFuncMembers,md);

      break;

    case MemberDef::Typedef:      

      if (!docOnly)

      {

        addMemberToList(MemberList::decTypedefMembers,md);

      }

      addMemberToList(MemberList::docTypedefMembers,md);

      break;

    case MemberDef::Enumeration:  

      if (!docOnly)

      {

        addMemberToList(MemberList::decEnumMembers,md);

      }

      addMemberToList(MemberList::docEnumMembers,md);

      break;

    case MemberDef::EnumValue:    

      if (!docOnly)

      {

        addMemberToList(MemberList::decEnumValMembers,md);

      }

      addMemberToList(MemberList::docEnumValMembers,md);

      break;

    case MemberDef::Define:       

      if (!docOnly)

      {

        addMemberToList(MemberList::decDefineMembers,md);

      }

      addMemberToList(MemberList::docDefineMembers,md);

      break;

    case MemberDef::Signal:       

      if (!docOnly)

      {

        addMemberToList(MemberList::decSignalMembers,md);

      }

      addMemberToList(MemberList::docSignalMembers,md);

      break;

    case MemberDef::Slot:       

      if (md->protection()==Public)

      {

        if (!docOnly)

        {

          addMemberToList(MemberList::decPubSlotMembers,md);

        }

        addMemberToList(MemberList::docPubSlotMembers,md);

      }

      else if (md->protection()==Protected)

      {

        if (!docOnly)

        {

          addMemberToList(MemberList::decProSlotMembers,md);

        }

        addMemberToList(MemberList::docProSlotMembers,md);

      }

      else

      {

        if (!docOnly)

        {

          addMemberToList(MemberList::decPriSlotMembers,md);

        }

        addMemberToList(MemberList::docPriSlotMembers,md);

      }

      break;

    case MemberDef::Event:       

      if (!docOnly)

      {

        addMemberToList(MemberList::decEventMembers,md);

      }

      addMemberToList(MemberList::docEventMembers,md);

      break;

    case MemberDef::Property:       

      if (!docOnly)

      {

        addMemberToList(MemberList::decPropMembers,md);

      }

      addMemberToList(MemberList::docPropMembers,md);

      break;

    case MemberDef::Friend:       

      if (!docOnly)

      {

        addMemberToList(MemberList::decFriendMembers,md);

      }

      addMemberToList(MemberList::docFriendMembers,md);

      break;

    default:

      err("GroupDef::insertMembers(): "

           "member `%s' (typeid=%d) with scope `%s' inserted in group scope `%s'!\n",

           md->name().data(),md->memberType(),

           md->getClassDef() ? md->getClassDef()->name().data() : "",

           name().data());

  }

  return TRUE;

}

void GroupDef::removeMember(MemberDef *md)

{

  // fprintf(stderr, "GroupDef(%s)::removeMember( %s )\n", title.data(), md->name().data());

  MemberNameInfo *mni = allMemberNameInfoSDict->find(md->name());

  if (mni)

  {

    MemberNameInfoIterator mnii(*mni);

    while( mnii.current() )

    {

      if( mnii.current()->memberDef == md )

      {

	mni->remove(mnii.current());

        break;

      }

      ++mnii;

    }

    if( mni->isEmpty() )

    {

      allMemberNameInfoSDict->remove(md->name());

      delete mni;

    }

    removeMemberFromList(MemberList::allMembersList,md);

    switch(md->memberType())

    {

      case MemberDef::Variable:

	removeMemberFromList(MemberList::decVarMembers,md);

        removeMemberFromList(MemberList::docVarMembers,md);

        break;

      case MemberDef::Function: 

        removeMemberFromList(MemberList::decFuncMembers,md);

        removeMemberFromList(MemberList::docFuncMembers,md);

        break;

      case MemberDef::Typedef:      

        removeMemberFromList(MemberList::decTypedefMembers,md);

        removeMemberFromList(MemberList::docTypedefMembers,md);

        break;

      case MemberDef::Enumeration:  

        removeMemberFromList(MemberList::decEnumMembers,md);

        removeMemberFromList(MemberList::docEnumMembers,md);

        break;

      case MemberDef::EnumValue:    

        removeMemberFromList(MemberList::decEnumValMembers,md);

        removeMemberFromList(MemberList::docEnumValMembers,md);

        break;

      case MemberDef::Define:       

        removeMemberFromList(MemberList::decDefineMembers,md);

        removeMemberFromList(MemberList::docDefineMembers,md);

        break;

      case MemberDef::Signal:       

        removeMemberFromList(MemberList::decSignalMembers,md);

        removeMemberFromList(MemberList::docSignalMembers,md);

        break;

      case MemberDef::Slot:       

        if (md->protection()==Public)

        {

          removeMemberFromList(MemberList::decPubSlotMembers,md);

          removeMemberFromList(MemberList::docPubSlotMembers,md);

        }

        else if (md->protection()==Protected)

        {

          removeMemberFromList(MemberList::decProSlotMembers,md);

          removeMemberFromList(MemberList::docProSlotMembers,md);

        }

        else

        {

          removeMemberFromList(MemberList::decPriSlotMembers,md);

          removeMemberFromList(MemberList::docPriSlotMembers,md);

        }

        break;

      case MemberDef::Event:       

        removeMemberFromList(MemberList::decEventMembers,md);

        removeMemberFromList(MemberList::docEventMembers,md);

        break;

      case MemberDef::Property:       

        removeMemberFromList(MemberList::decPropMembers,md);

        removeMemberFromList(MemberList::docPropMembers,md);

        break;

      case MemberDef::Friend:       

        removeMemberFromList(MemberList::decFriendMembers,md);

        removeMemberFromList(MemberList::docFriendMembers,md);

        break;

      default:

        err("GroupDef::removeMember(): unexpected member remove in file!\n");

    }

  }

}

bool GroupDef::containsGroup(const GroupDef *def)

{

    return this==def || groupList->find(def) >= 0;

}

void GroupDef::addGroup(const GroupDef *def)

{

  //printf("adding group `%s' to group `%s'\n",def->name().data(),name().data());

  //if (Config_getBool("SORT_MEMBER_DOCS"))

  //  groupList->inSort(def);

  //else

  groupList->append(def);

}

bool GroupDef::isASubGroup() const

{

  LockingPtr<GroupList> groups = partOfGroups();

  return groups!=0 && groups->count()!=0;

}

int GroupDef::countMembers() const

{

  return fileList->count()+

         classSDict->count()+

         namespaceSDict->count()+

         groupList->count()+

         allMemberList->count()+

         pageDict->count()+

         exampleDict->count();

}

/*! Compute the HTML anchor names for all members in the group */ 

void GroupDef::computeAnchors()

{

  //printf("GroupDef::computeAnchors()\n");

  setAnchors(0,'a',allMemberList);

}

void GroupDef::writeDetailedDescription(OutputList &ol,const QCString &title)

{

  if ((!briefDescription().isEmpty() && Config_getBool("REPEAT_BRIEF")) 

      || !documentation().isEmpty() || !inbodyDocumentation().isEmpty()

     )

  {

    if (pageDict->count()!=countMembers()) // not only pages -> classical layout

    {

      ol.writeRuler();

      ol.pushGeneratorState();

      ol.disableAllBut(OutputGenerator::Html);

        ol.writeAnchor(0,"_details");

      ol.popGeneratorState();

      ol.startGroupHeader();

      ol.parseText(title);

      ol.endGroupHeader();

    }

    // repeat brief description

    if (!briefDescription().isEmpty() && Config_getBool("REPEAT_BRIEF"))

    {

      ol.parseDoc(briefFile(),briefLine(),this,0,briefDescription(),FALSE,FALSE);

    }

    // write separator between brief and details

    if (!briefDescription().isEmpty() && Config_getBool("REPEAT_BRIEF") &&

        !documentation().isEmpty())

    {

      ol.pushGeneratorState();

      ol.disable(OutputGenerator::Man);