/*=========================================================================

  Program:   CMake - Cross-Platform Makefile Generator
  Module:    $RCSfile$
  Language:  C++
  Date:      $Date$
  Version:   $Revision$

  Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#include "cmVTKMakeInstantiatorCommand.h"

#include "cmCacheManager.h"
#include "cmGeneratedFileStream.h"
#include "cmSourceFile.h"

bool
cmVTKMakeInstantiatorCommand
::InitialPass(std::vector<std::string> const& argsIn)
{
  if(argsIn.size() < 3)
    {
    this->SetError("called with incorrect number of arguments");
    return false;
    }
  std::vector<std::string> args;
  this->Makefile->ExpandSourceListArguments(argsIn, args, 2);
  std::string sourceListValue;
  
  this->ClassName = args[0];
  
  std::vector<cmStdString> inSourceLists;
  this->ExportMacro = "-";
  bool includesMode = false;
  bool oldVersion = true;
  
  // Find the path of the files to be generated.
  std::string filePath = this->Makefile->GetCurrentOutputDirectory();
  std::string headerPath = filePath;
  
  // Check whether to use the old or new form.
  if(this->Makefile->GetDefinition("VTK_USE_INSTANTIATOR_NEW"))
    {
    oldVersion = false;
    }
  
  for(unsigned int i=2;i < args.size();++i)
    {
    if(args[i] == "HEADER_LOCATION")
      {
      includesMode = false;
      if(++i < args.size())
        {
        headerPath = args[i];
        }
      else
        {
        this->SetError("HEADER_LOCATION option used without value.");
        return false;
        }
      }
    else if(args[i] == "EXPORT_MACRO")
      {
      includesMode = false;
      if(++i < args.size())
        {
        this->ExportMacro = args[i];
        }
      else
        {
        this->SetError("EXPORT_MACRO option used without value.");
        return false;
        }
      }
    else if(args[i] == "INCLUDES")
      {
      includesMode = true;
      }
    // If not an option, it must be another input source list name or
    // an include file.
    else
      {
      if(!includesMode)
        {
        inSourceLists.push_back(args[i]);
        }
      else
        {
        this->Includes.push_back(args[i]);
        }
      }
    }
  
  if(this->ExportMacro == "-")
    {
    this->SetError("No EXPORT_MACRO option given.");
    return false;
    }
  
  for(std::vector<cmStdString>::const_iterator s = inSourceLists.begin();
      s != inSourceLists.end(); ++s)
    {
    std::string srcName = cmSystemTools::GetFilenameWithoutExtension(*s);
    cmSourceFile *sf = this->Makefile->GetSource(s->c_str());
    
    // Wrap-excluded and abstract classes do not have a New() method.
    // vtkIndent and vtkTimeStamp are special cases and are not
    // vtkObject subclasses.
    if(
      (!sf || (!sf->GetPropertyAsBool("WRAP_EXCLUDE") && 
               !sf->GetPropertyAsBool("ABSTRACT"))) &&
      ((srcName != "vtkIndent") && (srcName != "vtkTimeStamp")))
      {
      this->Classes.push_back(srcName);
      }
    }    
  
  // Generate the header with the class declaration.
  {
  std::string fileName = this->ClassName + ".h";
  std::string fullName = headerPath+"/"+fileName;
  
  // Generate the output file with copy-if-different.
  cmGeneratedFileStream fout(fullName.c_str());
  fout.SetCopyIfDifferent(true);
  
  // Actually generate the code in the file.
  if(!oldVersion)
    {
    this->GenerateHeaderFile(fout);
    }
  else
    {
    this->OldGenerateHeaderFile(fout);
    }
  }
  
  // Generate the implementation file.
  {
  std::string fileName = this->ClassName + ".cxx";
  std::string fullName = filePath+"/"+fileName;
  
  // Generate the output file with copy-if-different.
  {
  cmGeneratedFileStream fout(fullName.c_str());
  fout.SetCopyIfDifferent(true);
  
  // Actually generate the code in the file.
  if(!oldVersion)
    {
    this->GenerateImplementationFile(fout);
    }
  else
    {
    this->OldGenerateImplementationFile(fout);
    }
  }
  
  // Add the generated source file into the source list.
  cmSourceFile file;
  file.GetProperties().SetCMakeInstance
    (this->Makefile->GetCMakeInstance());
  file.SetProperty("WRAP_EXCLUDE","1");
  file.SetProperty("ABSTRACT","0");
  file.SetName(fileName.c_str(), filePath.c_str(),
               this->Makefile->GetSourceExtensions(),
               this->Makefile->GetHeaderExtensions());
  this->Makefile->AddSource(file);
  sourceListValue += file.GetSourceName() + ".cxx";
  }
  
  if(oldVersion)
    {
    int groupSize = 10;
    size_t numClasses = this->Classes.size();
    size_t numFullBlocks = numClasses / groupSize;
    size_t lastBlockSize = numClasses % groupSize;
    size_t numBlocks = numFullBlocks + ((lastBlockSize>0)? 1:0);
    
    // Generate the files with the ::New() calls to each class.  These
    // are done in groups to keep the translation unit size smaller.
    for(unsigned int block=0; block < numBlocks;++block)
      {
      std::string fileName = this->OldGenerateCreationFileName(block);    
      std::string fullName = filePath+"/"+fileName;
    
      // Generate the output file with copy-if-different.
      {
      cmGeneratedFileStream fout(fullName.c_str());
      fout.SetCopyIfDifferent(true);
    
      size_t thisBlockSize =
        (block < numFullBlocks)? groupSize:lastBlockSize;
    
      // Actually generate the code in the file.
      this->OldGenerateCreationFile(fout,
                                    block*groupSize, 
                                    static_cast<int>(thisBlockSize));
      }
      
      // Add the generated source file into the source list.
      cmSourceFile file;
      file.GetProperties().SetCMakeInstance
        (this->Makefile->GetCMakeInstance());
      file.SetProperty("WRAP_EXCLUDE","1");
      file.SetProperty("ABSTRACT","0");
      file.SetName(fileName.c_str(), filePath.c_str(),
                   this->Makefile->GetSourceExtensions(),
                   this->Makefile->GetHeaderExtensions());
      this->Makefile->AddSource(file);
      sourceListValue += ";";
      sourceListValue += file.GetSourceName() + ".cxx";
      }
    }
  
  this->Makefile->AddDefinition(args[1].c_str(), sourceListValue.c_str());  
  return true;
}

// Generates the class header file with the definition of the class
// and its initializer class.
void
cmVTKMakeInstantiatorCommand
::GenerateHeaderFile(std::ostream& os)
{
  os <<
    "#ifndef __" << this->ClassName.c_str() << "_h\n"
    "#define __" << this->ClassName.c_str() << "_h\n"
    "\n"
    "#include \"vtkInstantiator.h\"\n";
  for(unsigned int i=0;i < this->Includes.size();++i)
    {
    os << "#include \"" << this->Includes[i].c_str() << "\"\n";
    }
  
  // Write the instantiator class definition.
  os <<
    "\n"
    "class " << this->ExportMacro.c_str() 
     << " " << this->ClassName.c_str() << "\n"
    "{\n"
    "public:\n"
    "  " << this->ClassName.c_str() << "();\n"
    "  ~" << this->ClassName.c_str() << "();\n"
    "private:\n"
    "  static void ClassInitialize();\n"
    "  static void ClassFinalize();\n"
    "  static unsigned int Count;\n"
    "};\n"
    "\n";
  
  // Write the initialization instance to make sure the creation
  // functions get registered when this generated header is included.
  os <<
    "static "
     << this->ClassName.c_str() << " "
     << this->ClassName.c_str() << "Initializer;\n"
    "\n"
    "#endif\n";  
}

// Generates the file with the implementation of the class.  All
// methods except the actual object creation functions are generated
// here.
void
cmVTKMakeInstantiatorCommand
::GenerateImplementationFile(std::ostream& os)
{
  // Include the instantiator class header.
  os <<
    "#include \"" << this->ClassName.c_str() << ".h\"\n"
    "\n";
  
  // Write the extern declarations for all the creation functions.
  for(unsigned int i=0;i < this->Classes.size();++i)
    {
    os << "extern vtkObject* vtkInstantiator" << 
      this->Classes[i].c_str() << "New();\n";
    }
  
  // Write the ClassInitialize method to register all the creation functions.
  os <<
    "\n"
    "void " << this->ClassName.c_str() << "::ClassInitialize()\n"
    "{\n";
  
  for(unsigned int i=0;i < this->Classes.size();++i)
    {
    os << "  vtkInstantiator::RegisterInstantiator(\""
       << this->Classes[i].c_str() << "\", vtkInstantiator"
       << this->Classes[i].c_str() << "New);\n";
    }
  
  // Write the ClassFinalize method to unregister all the creation functions.
  os <<
    "}\n"
    "\n"
    "void " << this->ClassName.c_str() << "::ClassFinalize()\n"
    "{\n";
  
  for(unsigned int i=0;i < this->Classes.size();++i)
    {
    os << "  vtkInstantiator::UnRegisterInstantiator(\""
       << this->Classes[i].c_str() << "\", vtkInstantiator"
       << this->Classes[i].c_str() << "New);\n";
    }
  
  // Write the constructor and destructor of the initializer class to
  // call the ClassInitialize and ClassFinalize methods at the right
  // time.
  os <<
    "}\n"
    "\n" <<
    this->ClassName.c_str() << "::" << this->ClassName.c_str() << "()\n"
    "{\n"
    "  if(++" << this->ClassName.c_str() << "::Count == 1)\n"
    "    { " << this->ClassName.c_str() << "::ClassInitialize(); }\n"
    "}\n"
    "\n" <<
    this->ClassName.c_str() << "::~" << this->ClassName.c_str() << "()\n"
    "{\n"
    "  if(--" << this->ClassName.c_str() << "::Count == 0)\n"
    "    { " << this->ClassName.c_str() << "::ClassFinalize(); }\n"
    "}\n"
    "\n"
    "// Number of translation units that include this class's header.\n"
    "// Purposely not initialized.  Default is static initialization to 0.\n"
    "unsigned int " << this->ClassName.c_str() << "::Count;\n";
}

std::string
cmVTKMakeInstantiatorCommand::OldGenerateCreationFileName(unsigned int block)
{
  cmOStringStream nameStr;
  nameStr << this->ClassName.c_str() << block << ".cxx";
  std::string result = nameStr.str();
  return result;
}

// Generates a file that includes the headers of the classes it knows
// how to create and provides functions which create the classes with
// the New() method.
void
cmVTKMakeInstantiatorCommand
::OldGenerateCreationFile(std::ostream& os, unsigned int groupStart,
                       unsigned int groupSize)
{
  // Need to include header of generated class.
  os <<
    "#include \"" << this->ClassName.c_str() << ".h\"\n"
    "\n";
  
  // Include class files.
  for(unsigned int i=0;i < groupSize;++i)
    {
    os << "#include \"" << this->Classes[groupStart+i].c_str() << ".h\"\n";
    }

  os <<
    "\n";

  // Write the create function implementations.
  for(unsigned int i=0;i < groupSize;++i)
    {
    os << "vtkObject* " << this->ClassName.c_str() << "::Create_"
       << this->Classes[groupStart+i].c_str() << "() { return "
       << this->Classes[groupStart+i].c_str() << "::New(); }\n";
    }
}

// Generates the class header file with the definition of the class
// and its initializer class.
void
cmVTKMakeInstantiatorCommand
::OldGenerateHeaderFile(std::ostream& os)
{
  os <<
    "#ifndef __" << this->ClassName.c_str() << "_h\n"
    "#define __" << this->ClassName.c_str() << "_h\n"
    "\n"
    "#include \"vtkInstantiator.h\"\n";
  for(unsigned int i=0;i < this->Includes.size();++i)
    {
    os << "#include \"" << this->Includes[i].c_str() << "\"\n";
    }
  os <<
    "\n"
    "class " << this->ClassName.c_str() << "Initialize;\n"
    "\n"
    "class " << this->ExportMacro.c_str() << " " 
     << this->ClassName.c_str() << "\n"
    "{\n"
    "  friend class " << this->ClassName.c_str() << "Initialize;\n"
    "\n"
    "  static void ClassInitialize();\n"
    "  static void ClassFinalize();\n"
    "\n";
  
  for(unsigned int i=0;i < this->Classes.size();++i)
    {
    os << "  static vtkObject* Create_" 
       << this->Classes[i].c_str() << "();\n";
    }
  
  // Write the initializer class to make sure the creation functions
  // get registered when this generated header is included.
  os <<
    "};\n"
    "\n"
    "class " << this->ExportMacro.c_str() << " " 
     << this->ClassName.c_str() << "Initialize\n"
    "{\n"
    "public:\n"
    "  " << this->ClassName.c_str() << "Initialize();\n"
    "  ~" << this->ClassName.c_str() << "Initialize();\n"
    "private:\n"
    "  static unsigned int Count;\n"
    "};\n"
    "\n"
    "static " << this->ClassName.c_str() << "Initialize " 
     << this->ClassName.c_str() << "Initializer;\n"
    "\n"
    "#endif\n";  
}

// Generates the file with the implementation of the class.  All
// methods except the actual object creation functions are generated
// here.
void cmVTKMakeInstantiatorCommand
::OldGenerateImplementationFile(std::ostream& os)
{
  // Write the ClassInitialize method to register all the creation functions.
  os <<
    "#include \"" << this->ClassName.c_str() << ".h\"\n"
    "\n"
    "void " << this->ClassName.c_str() << "::ClassInitialize()\n"
    "{\n";
    
  for(unsigned int i=0;i < this->Classes.size();++i)
    {
    os << "  vtkInstantiator::RegisterInstantiator(\""
       << this->Classes[i].c_str() << "\", " 
       << this->ClassName.c_str() << "::Create_"
       << this->Classes[i].c_str() << ");\n";
    }
  
  // Write the ClassFinalize method to unregister all the creation functions.
  os <<
    "}\n"
    "\n"
    "void " << this->ClassName.c_str() << "::ClassFinalize()\n"
    "{\n";
  
  for(unsigned int i=0;i < this->Classes.size();++i)
    {
    os << "  vtkInstantiator::UnRegisterInstantiator(\""
       << this->Classes[i].c_str() << "\", " 
       << this->ClassName.c_str() << "::Create_"
       << this->Classes[i].c_str() << ");\n";
    }
  
  // Write the constructor and destructor of the initializer class to
  // call the ClassInitialize and ClassFinalize methods at the right
  // time.
  os <<
    "}\n"
    "\n" <<
    this->ClassName.c_str() << "Initialize::" << 
    this->ClassName.c_str() << "Initialize()\n"
    "{\n"
    "  if(++" << this->ClassName.c_str() << "Initialize::Count == 1)\n"
    "    { " << this->ClassName.c_str() << "::ClassInitialize(); }\n"
    "}\n"
    "\n" <<
    this->ClassName.c_str() << "Initialize::~" << 
    this->ClassName.c_str() << "Initialize()\n"
    "{\n"
    "  if(--" << this->ClassName.c_str() << "Initialize::Count == 0)\n"
    "    { " << this->ClassName.c_str() << "::ClassFinalize(); }\n"
    "}\n"
    "\n"
    "// Number of translation units that include this class's header.\n"
    "// Purposely not initialized.  Default is static initialization to 0.\n"
    "unsigned int " << this->ClassName.c_str() << "Initialize::Count;\n";
}