/*
 Copyright 2019 Alain Dargelas

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 */

/*
 * File:   ResolveSymbols.cpp
 * Author: alain
 *
 * Created on July 1, 2017, 12:38 PM
 */
#include "SourceCompile/VObjectTypes.h"
#include "Design/VObject.h"
#include "Library/Library.h"
#include "Design/FileContent.h"
#include "SourceCompile/SymbolTable.h"
#include "ErrorReporting/Error.h"
#include "ErrorReporting/Location.h"
#include "ErrorReporting/Error.h"
#include "ErrorReporting/ErrorDefinition.h"
#include "ErrorReporting/ErrorContainer.h"
#include "SourceCompile/CompilationUnit.h"
#include "SourceCompile/PreprocessFile.h"
#include "SourceCompile/CompileSourceFile.h"
#include "SourceCompile/ParseFile.h"
#include "SourceCompile/Compiler.h"
#include "Testbench/Program.h"
#include "Testbench/ClassDefinition.h"
#include "DesignCompile/CompileDesign.h"
#include "DesignCompile/ResolveSymbols.h"

using namespace SURELOG;

ResolveSymbols::~ResolveSymbols() {}

int FunctorCreateLookup::operator()() const {
  ResolveSymbols* instance = new ResolveSymbols(
      m_compileDesign, m_fileData, m_symbolTable, m_errorContainer);
  instance->createFastLookup();
  delete instance;
  return true;
}

int FunctorResolve::operator()() const {
  ResolveSymbols* instance = new ResolveSymbols(
      m_compileDesign, m_fileData, m_symbolTable, m_errorContainer);
  instance->resolve();
  delete instance;
  return true;
}

std::string ResolveSymbols::SymName(NodeId index) {
  return m_fileData->getSymbolTable()->getSymbol(Name(index));
}

void ResolveSymbols::createFastLookup() {
  Library* lib = m_fileData->getLibrary();
  std::string libName = lib->getName();

  // std::string fileName =  "FILE: " + m_fileData->getFileName() + " " +
  // m_fileData->getChunkFileName () + "\n"; std::cout << fileName;

  std::vector<VObjectType> types = {
      VObjectType::slModule_declaration,    VObjectType::slPackage_declaration,
      VObjectType::slConfig_declaration,    VObjectType::slUdp_declaration,
      VObjectType::slInterface_declaration, VObjectType::slProgram_declaration,
      VObjectType::slClass_declaration};

  std::vector<VObjectType> stopPoints = {
      VObjectType::slModule_declaration, VObjectType::slPackage_declaration,
      VObjectType::slProgram_declaration, VObjectType::slClass_declaration};

  std::vector<NodeId> objects =
      m_fileData->sl_collect_all(m_fileData->getRootNode(), types, stopPoints);

  for (auto object : objects) {
    VObjectType type = m_fileData->Type(object);
    NodeId stId = m_fileData->sl_collect(object, VObjectType::slStringConst,
                                         VObjectType::slAttr_spec);
    if (stId != InvalidNodeId) {
      std::string name = SymName(stId);
      m_fileData->insertObjectLookup(name, object, m_errorContainer);
      std::string fullName = libName + "@" + name;

      switch (type) {
        case VObjectType::slPackage_declaration: {
          // Package names are not prefixed by Library names!
          std::string pkgname = name;
          Package* pdef = new Package(pkgname, lib, m_fileData, object);
          m_fileData->addPackageDefinition(pkgname, pdef);

          std::vector<VObjectType> subtypes = {
              VObjectType::slClass_declaration};
          std::vector<NodeId> subobjects =
              m_fileData->sl_collect_all(object, subtypes, subtypes);
          for (auto subobject : subobjects) {
            NodeId stId =
                m_fileData->sl_collect(subobject, VObjectType::slStringConst,
                                       VObjectType::slAttr_spec);
            if (stId != InvalidNodeId) {
              std::string name = SymName(stId);
              std::string fullSubName = pkgname + "::" + name;
              m_fileData->insertObjectLookup(fullSubName, subobject,
                                             m_errorContainer);

              ClassDefinition* def = new ClassDefinition(
                  fullSubName, lib, pdef, m_fileData, subobject, NULL);
              m_fileData->addClassDefinition(fullSubName, def);
              pdef->addClassDefinition(fullSubName, def);
            }
          }
          break;
        }
        case VObjectType::slProgram_declaration: {
          Program* mdef = new Program(fullName, lib, m_fileData, object);
          m_fileData->addProgramDefinition(fullName, mdef);

          std::vector<VObjectType> subtypes = {
              VObjectType::slClass_declaration};
          std::vector<NodeId> subobjects =
              m_fileData->sl_collect_all(object, subtypes, subtypes);
          for (auto subobject : subobjects) {
            NodeId stId =
                m_fileData->sl_collect(subobject, VObjectType::slStringConst,
                                       VObjectType::slAttr_spec);
            if (stId != InvalidNodeId) {
              std::string name = SymName(stId);
              std::string fullSubName = fullName + "::" + name;
              m_fileData->insertObjectLookup(fullSubName, subobject,
                                             m_errorContainer);
              ClassDefinition* def = new ClassDefinition(
                  fullSubName, lib, mdef, m_fileData, subobject, NULL);
              m_fileData->addClassDefinition(fullSubName, def);
              mdef->addClassDefinition(fullSubName, def);
            }
          }
          break;
        }
        case VObjectType::slClass_declaration: {
          ClassDefinition* def = new ClassDefinition(fullName, lib, NULL,
                                                     m_fileData, object, NULL);
          m_fileData->addClassDefinition(fullName, def);
          break;
        }
        case VObjectType::slModule_declaration: {
          ModuleDefinition* mdef =
              new ModuleDefinition(m_fileData, object, fullName);
          m_fileData->addModuleDefinition(fullName, mdef);

          std::vector<VObjectType> subtypes = {
              VObjectType::slClass_declaration,
              VObjectType::slModule_declaration};
          std::vector<NodeId> subobjects =
              m_fileData->sl_collect_all(object, subtypes, subtypes);
          for (auto subobject : subobjects) {
            NodeId stId =
                m_fileData->sl_collect(subobject, VObjectType::slStringConst,
                                       VObjectType::slAttr_spec);
            if (stId != InvalidNodeId) {
              std::string name = SymName(stId);
              std::string fullSubName = fullName + "::" + name;
              m_fileData->insertObjectLookup(fullSubName, subobject,
                                             m_errorContainer);

              if (m_fileData->Type(subobject) ==
                  VObjectType::slClass_declaration) {
                ClassDefinition* def = new ClassDefinition(
                    fullSubName, lib, mdef, m_fileData, subobject, NULL);
                m_fileData->addClassDefinition(fullSubName, def);
                mdef->addClassDefinition(fullSubName, def);
              } else {
                ModuleDefinition* def =
                    new ModuleDefinition(m_fileData, subobject, fullSubName);
                m_fileData->addModuleDefinition(fullSubName, def);
              }
            }
          }

          break;
        }
        case VObjectType::slConfig_declaration:
        case VObjectType::slUdp_declaration:
        case VObjectType::slInterface_declaration:
        default:
          ModuleDefinition* def =
              new ModuleDefinition(m_fileData, object, fullName);
          m_fileData->addModuleDefinition(fullName, def);
          break;
      }
    }
  }
}

VObject& ResolveSymbols::Object(NodeId index) {
  if (index == InvalidNodeId) return m_fileData->Object(0);
  return m_fileData->Object(index);
}

NodeId ResolveSymbols::UniqueId(NodeId index) { return index; }

SymbolId ResolveSymbols::Name(NodeId index) {
  if (index == InvalidNodeId) return 0;
  return Object(index).m_name;
}

NodeId ResolveSymbols::Child(NodeId index) {
  if (index == InvalidNodeId) return 0;
  return Object(index).m_child;
}

NodeId ResolveSymbols::Sibling(NodeId index) {
  if (index == InvalidNodeId) return 0;
  return Object(index).m_sibling;
}

static NodeId UndefinedObjectDefinition = 0;
NodeId& ResolveSymbols::Definition(NodeId index) {
  if (index == InvalidNodeId) return UndefinedObjectDefinition;
  return Object(index).m_definition;
}

NodeId ResolveSymbols::Parent(NodeId index) {
  if (index == InvalidNodeId) return 0;
  return Object(index).m_parent;
}

static unsigned short UndefinedObjectType = 0;
unsigned short& ResolveSymbols::Type(NodeId index) {
  if (index == InvalidNodeId) return UndefinedObjectType;
  return Object(index).m_type;
}

unsigned int ResolveSymbols::Line(NodeId index) {
  if (index == InvalidNodeId) return 0;
  return Object(index).m_line;
}

std::string ResolveSymbols::Symbol(SymbolId id) {
  return m_fileData->getSymbolTable()->getSymbol(id);
}

NodeId ResolveSymbols::sl_get(NodeId parent, VObjectType type) {
  return m_fileData->sl_get(parent, type);
}

NodeId ResolveSymbols::sl_parent(NodeId parent, VObjectType type) {
  return m_fileData->sl_parent(parent, type);
}

NodeId ResolveSymbols::sl_parent(NodeId parent, std::vector<VObjectType> types,
                                 VObjectType& actualType) {
  return m_fileData->sl_parent(parent, types, actualType);
}

std::vector<NodeId> ResolveSymbols::sl_get_all(NodeId parent,
                                               VObjectType type) {
  return m_fileData->sl_get_all(parent, type);
}

NodeId ResolveSymbols::sl_collect(NodeId parent, VObjectType type) {
  return m_fileData->sl_collect(parent, type);
}

std::vector<NodeId> ResolveSymbols::sl_collect_all(NodeId parent,
                                                   VObjectType type) {
  return m_fileData->sl_collect_all(parent, type);
}

bool ResolveSymbols::bindDefinition_(unsigned int objIndex,
                                     std::vector<VObjectType> bindTypes) {
  std::string modName =
      SymName(sl_collect(objIndex, VObjectType::slStringConst));
  std::string instName =
      SymName(Child(sl_collect(objIndex, slName_of_instance)));
  Design::FileIdDesignContentMap& all_files =
      this->m_compileDesign->getCompiler()->getDesign()->getAllFileContents();

  bool found = false;
  for (auto file : all_files) {
    SymbolId fileId = file.first;
    FileContent* fcontent = file.second;

    auto itr = fcontent->getObjectLookup().find(modName);
    if (itr != fcontent->getObjectLookup().end()) {
      VObjectType actualType;
      NodeId index = (*itr).second;
      NodeId mod = fcontent->sl_parent(index, bindTypes, actualType);
      if (mod != InvalidNodeId) {
        Definition(objIndex) = mod;
        fcontent->getReferencedObjects().insert(modName);
        m_fileData->SetDefinitionFile(objIndex, fileId);
        switch (actualType) {
          case VObjectType::slUdp_declaration:
            Type(objIndex) = VObjectType::slUdp_instantiation;
            break;
          case VObjectType::slModule_declaration:
            Type(objIndex) = VObjectType::slModule_instantiation;
            break;
          case VObjectType::slInterface_declaration:
            Type(objIndex) = VObjectType::slInterface_instantiation;
            break;
          case VObjectType::slProgram_declaration:
            Type(objIndex) = VObjectType::slProgram_instantiation;
            break;
          default:
            break;
        }
        found = true;
        // std::cout << "FOUND MODEL FOR " << modName << " " << instName <<
        // std::endl; std::cout << m_fileData->printSubTree (objIndex) <<
        // std::endl;
        break;
      }
    }
  }
  return found;
}

bool ResolveSymbols::resolve() {
  unsigned int size = m_fileData->getVObjects().size();
  for (unsigned int objIndex = 0; objIndex < size; objIndex++) {
    // ErrorDefinition::ErrorType errorType;
    bool bind = false;
    if (Type(objIndex) == VObjectType::slUdp_instantiation) {
      bind = true;
      // errorType = ErrorDefinition::ELAB_NO_UDP_DEFINITION;
    } else if (Type(objIndex) == VObjectType::slModule_instantiation) {
      bind = true;
      // errorType = ErrorDefinition::ELAB_NO_MODULE_DEFINITION;
    } else if (Type(objIndex) == VObjectType::slInterface_instantiation) {
      bind = true;
      // errorType = ErrorDefinition::ELAB_NO_INTERFACE_DEFINITION;
    } else if (Type(objIndex) == VObjectType::slProgram_instantiation) {
      bind = true;
      // errorType = ErrorDefinition::ELAB_NO_PROGRAM_DEFINITION;
    }
    if (bind) {
      /*bool found = */
      bindDefinition_(objIndex,
                      {slUdp_declaration, slModule_declaration,
                       slInterface_declaration, slProgram_declaration});
      /*
       * This warning is now treated in the elaboration to give the library
      information if (!found)
        {
          std::string modName = SymName (sl_collect (objIndex, slStringConst));
          Location loc (m_fileData->getFileId (), Line (objIndex), 0,
      m_symbolTable->registerSymbol (modName)); Error err (errorType, loc);
          m_errorContainer->addError (err, false, false);
        }
      */
    }
  }

  return true;
}