/*
 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:   ParseLibraryDef.cpp
 * Author: alain
 * 
 * Created on January 27, 2018, 5:05 PM
 */
#include "../Utils/StringUtils.h"
#include "../CommandLine/CommandLineParser.hpp"
#include "../SourceCompile/CompilationUnit.h"
#include "../SourceCompile/PreprocessFile.h"
#include "../SourceCompile/CompileSourceFile.h"
#include "../SourceCompile/Compiler.h"
#include "../SourceCompile/ParseFile.h"
#include "ParseLibraryDef.h"
#include "../Utils/FileUtils.h"
#include "antlr4-runtime.h"
#include "atn/ParserATNSimulator.h"
using namespace antlr4;
using namespace SURELOG;
#include "../parser/SV3_1aLexer.h"
#include "../parser/SV3_1aParser.h"
#include "SVLibShapeListener.h"
#include "AntlrLibParserErrorListener.h"


ParseLibraryDef::ParseLibraryDef (CommandLineParser* commandLineParser, ErrorContainer* errors, SymbolTable* symbolTable,
                                  LibrarySet* librarySet, ConfigSet* configSet) : m_fileId(0),
  m_commandLineParser(commandLineParser), m_errors(errors), m_symbolTable(symbolTable), m_librarySet(librarySet), 
        m_configSet(configSet), m_fileContent(NULL) { 
}

ParseLibraryDef::ParseLibraryDef (const ParseLibraryDef& orig) {
}

ParseLibraryDef::~ParseLibraryDef () { 
}

bool ParseLibraryDef::parseLibrariesDefinition() 
{

  // Get .map files from command line 
  std::vector<SymbolId> libraryMapFiles = m_commandLineParser->getLibraryMapFiles ();
  if (libraryMapFiles.empty ())
    {
      // or scan local dir
      libraryMapFiles = FileUtils::collectFiles ("./", ".map", m_symbolTable);
    }

  // If "work" library is not yet declared from command line, create it
  std::string workN = "work";
  if (m_librarySet->getLibrary (workN) == NULL)
    {
      Library work (workN, m_symbolTable);
      m_librarySet->addLibrary (work);
    }
  
  //Config files are parsed using the library top rule
  std::vector<SymbolId> cfgFiles = m_commandLineParser->getConfigFiles ();
  for (auto file : cfgFiles)
    {
      libraryMapFiles.push_back (file);
    }
  
  for (auto fileId : libraryMapFiles)
    {
      parseLibraryDefinition(fileId);
    }
  
  for (auto file : cfgFiles)
    {
      std::string fullPath = FileUtils::getFullPath (m_symbolTable->getSymbol (file));
      m_librarySet->getLibrary (m_symbolTable->registerSymbol (fullPath)); // Register configuration files in "work" library
    }
  
  unsigned int size = m_commandLineParser->getSourceFiles ().size ();
  for (unsigned int i = 0; i < size; i++)
    {
      SymbolId id = m_commandLineParser->getSourceFiles ()[i];
      std::string fullPath = FileUtils::getFullPath (m_symbolTable->getSymbol (id));
      m_librarySet->getLibrary (m_symbolTable->registerSymbol (fullPath)); // Register files in "work" library
    } 
  
  m_librarySet->checkErrors (m_symbolTable, m_errors);
  
   if (m_commandLineParser->getDebugLibraryDef ())
     {
       std::cout << m_librarySet->report (m_symbolTable) << std::endl;
     }
  return true;
}

bool ParseLibraryDef::parseLibraryDefinition(SymbolId fileId, Library* lib)
{
  m_fileId = fileId;
  std::string fileName = m_symbolTable->getSymbol (fileId);
  std::string relativePath = FileUtils::getPathName (fileName);
  std::ifstream stream;
  stream.open (fileName);
  
  if (!stream.good ())
    {
      Location ppfile (fileId);
      Error err (ErrorDefinition::PA_CANNOT_OPEN_FILE, ppfile);
      m_errors->addError (err);
      return false;
    }
  
  Location ppfile (fileId);
  Error err (ErrorDefinition::PP_PROCESSING_SOURCE_FILE, ppfile);
  m_errors->addError (err);
  m_errors->printMessage (err, m_commandLineParser->muteStdout ());
  
  AntlrLibParserErrorListener* errorListener = new AntlrLibParserErrorListener (this);
  antlr4::ANTLRInputStream* m_inputStream = new ANTLRInputStream (stream);
  SV3_1aLexer* m_lexer = new SV3_1aLexer (m_inputStream);
  m_lexer->removeErrorListeners ();
  m_lexer->addErrorListener (errorListener);
  antlr4::CommonTokenStream* m_tokens = new CommonTokenStream (m_lexer);
  m_tokens->fill ();
  SV3_1aParser* m_parser = new SV3_1aParser (m_tokens);
  m_parser->removeErrorListeners ();
  m_parser->addErrorListener (errorListener);
  antlr4::tree::ParseTree* m_tree = m_parser->top_level_library_rule ();

  SVLibShapeListener* m_listener = new SVLibShapeListener (this, m_tokens, relativePath);
  tree::ParseTreeWalker::DEFAULT.walk (m_listener, m_tree);
  m_fileContent = m_listener->getFileContent();

  if (m_fileContent->getLibrary () == NULL)
    {
      if (lib)
        {
          m_fileContent->setLibrary(lib);
        }
      else 
        {
          std::string fullPath = FileUtils::getFullPath (m_symbolTable->getSymbol (m_fileId));
          m_fileContent->setLibrary (m_librarySet->getLibrary (m_symbolTable->registerSymbol (fullPath)));
        }
    }
  
  if (m_commandLineParser->getDebugAstModel ())
    {
      std::cout << m_fileContent->printObjects ();
    }
  
  //delete m_tree;
  delete m_parser;
  delete m_tokens;
  delete m_lexer;
  delete m_inputStream;
  delete m_listener;
  return parseConfigDefinition();
}

bool
ParseLibraryDef::parseConfigDefinition ()
{
  FileContent* fC = m_fileContent;
  if (!fC)
    return false;

  std::vector<VObjectType> types = {VObjectType::slConfig_declaration};
  std::vector<NodeId> configs = fC->sl_collect_all (0, types);
  for (auto config : configs)
    {
      NodeId ident = fC->Child (config);
      std::string name = fC->getLibrary ()->getName () + "@" + fC->SymName (ident);
      m_symbolTable->registerSymbol (name);
      Config conf (name, fC, config);

      // Design clause
      std::vector<VObjectType> designStmt = {VObjectType::slDesign_statement};
      std::vector<NodeId> designs = fC->sl_collect_all (config, designStmt);
      if (designs.size () == 0)
        {
          // TODO: Error
        }
      else if (designs.size () > 1)
        {
          // TODO: Error
        }
      else
        {
          NodeId design = designs[0];
          NodeId libName = fC->Child (design);
          NodeId topName = fC->Sibling (libName);
          if (topName == 0)
            {
              conf.setDesignLib (fC->getLibrary ()->getName ());
              conf.setDesignTop (fC->SymName (libName));
            }
          else
            {
              conf.setDesignLib (fC->SymName (libName));
              conf.setDesignTop (fC->SymName (topName));
            }
        }

      // Default clause
      std::vector<VObjectType> defaultStmt = {VObjectType::slDefault_clause};
      std::vector<NodeId> defaults = fC->sl_collect_all (config, defaultStmt);
      if (defaults.size () > 0)
        {
          NodeId defaultClause = defaults[0];
          NodeId libList = fC->Sibling (defaultClause);
          if (fC->Type (libList) == VObjectType::slLiblist_clause)
            {
              NodeId lib = fC->Child (libList);
              while (lib)
                {
                  conf.addDefaultLib (fC->SymName (lib));
                  lib = fC->Sibling (lib);
                }
            }
        }

      // Instance and Cell clauses 
      std::vector<VObjectType> instanceStmt = {VObjectType::slInst_clause,
        VObjectType::slCell_clause};
      std::vector<NodeId> instances = fC->sl_collect_all (config, instanceStmt);
      for (auto inst : instances)
        {
          VObjectType type = fC->Type (inst);
          NodeId instName = fC->Child (inst);
          if (type == slInst_clause)
            instName = fC->Child (instName);
          std::string instNameS;
          while (instName)
            {
              if (instNameS == "")
                instNameS = fC->SymName (instName);
              else
                instNameS += "." + fC->SymName (instName);
              instName = fC->Sibling (instName);
            }
          NodeId instClause = fC->Sibling (inst);
          if (fC->Type (instClause) == VObjectType::slLiblist_clause)
            {
              NodeId libList = fC->Child (instClause);
              std::vector<std::string> libs;
              while (libList)
                {
                  libs.push_back(fC->SymName (libList));
                  libList = fC->Sibling(libList);
                }
              
              UseClause usec (UseClause::UseLib, libs, fC, instClause);
              if (type == slInst_clause)
                conf.addInstanceUseClause (instNameS, usec);
              else
                conf.addCellUseClause (instNameS, usec);
            }
          else if (fC->Type (instClause) == VObjectType::slUse_clause)
            {
              NodeId use = fC->Child (instClause);
              std::string useName;
              VObjectType useType = fC->Type (use);
              if (useType == slParameter_value_assignment)
                {
                  UseClause usec (UseClause::UseParam, fC, use);
                  conf.addInstanceUseClause (instNameS, usec);
                }
              else
                {
                  NodeId mem = use;
                  while (use)
                    {
                      if (useName == "")
                        useName = fC->SymName (use);
                      else
                        useName += "." + fC->SymName (use);
                      use = fC->Sibling (use);
                    }
                  useName = StringUtils::replaceAll (useName, ".", "@");
                  UseClause usec (UseClause::UseModule, useName, fC, mem);
                  if (type == slInst_clause)
                    conf.addInstanceUseClause (instNameS, usec);
                  else
                    conf.addCellUseClause (instNameS, usec);
                }
            }
          else if (fC->Type (instClause) == VObjectType::slUse_clause_config)
            {
              NodeId use = fC->Child (instClause);
              std::string useName;
              NodeId mem = use;
              while (use)
                {
                  if (useName == "")
                    useName = fC->SymName (use);
                  else
                    useName += "@" + fC->SymName (use);
                  use = fC->Sibling (use);
                }
              UseClause usec (UseClause::UseConfig, useName, fC, mem);
              if (type == slInst_clause)
                conf.addInstanceUseClause (instNameS, usec);
              else
                conf.addCellUseClause (instNameS, usec);

            }
        }


      m_configSet->addConfig (conf);
    }

  return true;
}