/*
 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:   AnalyzeFile.cpp
 * Author: alain
 *
 * Created on July 23, 2017, 11:05 PM
 */
#include "SourceCompile/SymbolTable.h"
#include "Design/TimeInfo.h"
#include "Design/DesignElement.h"
#include "CommandLine/CommandLineParser.h"
#include "ErrorReporting/Error.h"
#include "ErrorReporting/Location.h"
#include "ErrorReporting/ErrorDefinition.h"
#include "ErrorReporting/ErrorContainer.h"
#include "SourceCompile/IncludeFileInfo.h"
#include "Utils/StringUtils.h"
#include "SourceCompile/CompilationUnit.h"
#include "SourceCompile/PreprocessFile.h"
#include "SourceCompile/CompileSourceFile.h"
#include "SourceCompile/Compiler.h"
#include "Design/Design.h"
#include "SourceCompile/AnalyzeFile.h"
#include <fstream>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <iostream>
#include <sstream>
#include <stack>
#include <regex>
using namespace SURELOG;

void saveContent(std::string fileName, std::string& content) {
  std::ifstream ifs;
  ifs.open(fileName);
  bool save = true;
  if (ifs.good()) {
    std::string str((std::istreambuf_iterator<char>(ifs)),
                    std::istreambuf_iterator<char>());
    ifs.close();
    if (str == content) save = false;
  }
  if (save) {
    std::ofstream ofs(fileName);
    ofs << content;
    ofs.close();
  }
}

void AnalyzeFile::checkSLlineDirective_(std::string line, unsigned int lineNb) {
  std::stringstream ss;
  std::string keyword;
  /* Storing the whole string into string stream */
  ss << line;
  std::string tmp;
  ss >> tmp;
  std::stringstream(tmp) >> keyword;
  unsigned int type = 0;
  if (keyword == "SLline") {
    IncludeFileInfo info(0, 0, 0, 0);
    ss >> tmp;
    std::stringstream(tmp) >> info.m_sectionStartLine;
    ss >> tmp;
    std::string file;
    std::stringstream(tmp) >> file;
    StringUtils::ltrim(file, '\"');
    StringUtils::rtrim(file, '\"');
    info.m_sectionFile = m_clp->getSymbolTable()->registerSymbol(file);
    ss >> tmp;
    std::stringstream(tmp) >> type;

    if (type == 1) {
      // Push
      info.m_originalLine = lineNb;
      info.m_type = type;
      m_includeFileInfo.push(info);
    } else if (type == 2) {
      // Pop
      if (m_includeFileInfo.size()) m_includeFileInfo.pop();
      if (m_includeFileInfo.size()) {
        m_includeFileInfo.top().m_sectionFile = info.m_sectionFile;
        m_includeFileInfo.top().m_originalLine = lineNb;
        m_includeFileInfo.top().m_sectionStartLine =
            info.m_sectionStartLine - 1;
        m_includeFileInfo.top().m_type = type;
      }
    }
  }
}

std::string AnalyzeFile::setSLlineDirective_(unsigned int lineNb,
                                             unsigned int& origFromLine,
                                             std::string& origFile) {
  std::string result;
  if (m_includeFileInfo.size()) {
    result = "SLline ";
    origFile = m_clp->getSymbolTable()->getSymbol(
        m_includeFileInfo.top().m_sectionFile);
    unsigned int origLine = m_includeFileInfo.top().m_originalLine;
    unsigned int sectionStartLine = m_includeFileInfo.top().m_sectionStartLine;
    origFromLine = lineNb - origLine + sectionStartLine;
    result += std::to_string(origFromLine);
    result += " \"";
    result += origFile;
    result += "\" ";
    result += std::to_string(1);
    result += "\n";
  }
  result = "";
  return result;
}

void AnalyzeFile::analyze() {
  std::ifstream ifs;
  ifs.open(m_ppFileName);
  if (!ifs.good()) {
    return;
  }
  unsigned int minNbLineForPartitioning = m_clp->getNbLinesForFileSpliting();
  std::vector<FileChunk> fileChunks;
  std::string line;
  bool inPackage = false;
  int inClass = 0;
  int inModule = 0;
  bool inProgram = false;
  int inInterface = 0;
  bool inConfig = false;
  bool inChecker = false;
  bool inPrimitive = false;
  // int  inFunction  = false;
  // int  inTask      = false;
  bool inComment = false;
  bool inString = false;
  unsigned int lineNb = 0;
  unsigned int charNb = 0;
  unsigned int startLine = 0;
  unsigned int startChar = 0;
  unsigned int indexPackage = 0;
  unsigned int indexModule = 0;
  int nbPackage = 0, nbClass = 0, nbModule = 0, nbProgram = 0, nbInterface = 0,
      nbConfig = 0, nbChecker = 0,
      nbPrimitive = 0 /*./re   , nbFunction = 0, nbTask = 0*/;
  std::vector<std::string> allLines;
  std::string prev_keyword;
  std::string prev_prev_keyword;
  allLines.push_back("FILLER LINE");
  const std::regex import_regex("import[ ]+[a-zA-Z_0-9:\\*]+[ ]*;");
  std::smatch pieces_match;
  std::string fileLevelImportSection;
  // Parse the file
  while (std::getline(ifs, line)) {
    bool inLineComment = false;
    allLines.push_back(line);
    lineNb++;
    char c = 0;
    char cp = 0;
    std::string keyword;
    for (unsigned int i = 0; i < line.size(); i++) {
      charNb++;
      c = line[i];
      if (cp == '/' && c == '*') {
        if (!inLineComment) inComment = true;
      } else if (cp == '/' && c == '/') {
        if ((!inComment) && (!inString)) inLineComment = true;
      } else if (cp == '*' && c == '/') {
        inComment = false;
      } else if (cp != '\\' && c == '\"') {
        if ((!inLineComment) && (!inComment)) inString = !inString;
      }
      if ((!inComment) && (!inLineComment) && (!inString)) {
        if ((islower(c) || isupper(c) || c == '_') &&
            (i != (line.size() - 1))) {
          keyword += c;
        } else {
          if ((islower(c) || isupper(c) || c == '_') &&
              (i == (line.size() - 1))) {
            keyword += c;
          }

          if (keyword == "package") {
            std::string packageName;
            for (unsigned int j = i + 1; j < line.size(); j++) {
              if (line[j] == ';') break;
              if (line[j] != ' ') packageName += line[j];
            }
            m_design->addOrderedPackage(packageName);
            inPackage = true;
            startLine = lineNb;
            startChar = charNb;
            FileChunk chunk(DesignElement::ElemType::Package, startLine, 0,
                            startChar, 0);
            fileChunks.push_back(chunk);
            indexPackage = fileChunks.size() - 1;
          }
          if (keyword == "endpackage") {
            if (inPackage) {
              fileChunks[indexPackage].m_toLine = lineNb;
              fileChunks[indexPackage].m_endChar = charNb;
              nbPackage++;
            }
            inPackage = false;
            // std::cout << "PACKAGE:" <<
            // allLines[fileChunks[indexPackage].m_fromLine] << " f:" <<
            // fileChunks[indexPackage].m_fromLine
            //        << " t:" << fileChunks[indexPackage].m_toLine <<
            //        std::endl;
          }
          if (keyword == "module") {
            if (inModule == 0) {
              startLine = lineNb;
              startChar = charNb;
              FileChunk chunk(DesignElement::ElemType::Module, startLine, 0,
                              startChar, 0);
              fileChunks.push_back(chunk);
              indexModule = fileChunks.size() - 1;
            }
            inModule++;
          }
          if (keyword == "endmodule") {
            if (inModule == 1) {
              fileChunks[indexModule].m_toLine = lineNb;
              fileChunks[indexModule].m_endChar = charNb;
              nbModule++;
            }
            inModule--;
          }
          /*
          if (keyword == "function" && (prev_keyword != "context") &&
          (prev_prev_keyword != "import"))
            {
              if ((inClass == 0) && (inInterface == 0) && (inModule == 0))
                {
                  if (inFunction == false)
                    {
                      startLine = lineNb;
                      startChar = charNb;
                    }
                  inFunction = true;
                }
            }
          if (keyword == "endfunction")
            {
               if (inFunction == true)
                 {
                   FileChunk chunk (DesignElement::ElemType::Function,
          startLine, lineNb, startChar, charNb); fileChunks.push_back (chunk);
                   nbFunction++;
                 }
              inFunction = false;
            }
          if (keyword == "task")
            {
              if ((inClass == 0) && (inInterface == 0) && (inModule == 0))
                {
                  if (inTask == false)
                    {
                      startLine = lineNb;
                      startChar = charNb;
                    }
                  inTask = true;
                }
            }
          if (keyword == "endtask")
            {
               if (inTask == true)
                 {
                   FileChunk chunk (DesignElement::ElemType::Task, startLine,
          lineNb, startChar, charNb); fileChunks.push_back (chunk); nbTask++;
                 }
              inTask = false;
            }
           */
          if (keyword == "class" && (prev_keyword != "typedef")) {
            if (inClass == 0) {
              startLine = lineNb;
              startChar = charNb;
            }
            inClass++;
          }
          if (keyword == "endclass") {
            if (inClass == 1) {
              FileChunk chunk(DesignElement::ElemType::Class, startLine, lineNb,
                              startChar, charNb);
              fileChunks.push_back(chunk);
              nbClass++;
            }
            inClass--;
          }
          if (keyword == "interface") {
            if (inInterface == 0) {
              startLine = lineNb;
              startChar = charNb;
            }
            inInterface++;
          }
          if (keyword == "endinterface") {
            if (inInterface == 1) {
              FileChunk chunk(DesignElement::ElemType::Interface, startLine,
                              lineNb, startChar, charNb);
              fileChunks.push_back(chunk);
              nbInterface++;
            }
            inInterface--;
          }
          if (keyword == "config") {
            startLine = lineNb;
            startChar = charNb;
            inConfig = true;
          }
          if (keyword == "endconfig") {
            if (inConfig) {
              FileChunk chunk(DesignElement::ElemType::Config, startLine,
                              lineNb, startChar, charNb);
              fileChunks.push_back(chunk);
              nbConfig++;
            }
            inConfig = false;
          }
          if (keyword == "checker") {
            startLine = lineNb;
            startChar = charNb;
            inChecker = true;
          }
          if (keyword == "endchecker") {
            if (inChecker) {
              FileChunk chunk(DesignElement::ElemType::Checker, startLine,
                              lineNb, startChar, charNb);
              fileChunks.push_back(chunk);
              nbChecker++;
            }
            inChecker = false;
          }
          if (keyword == "program") {
            startLine = lineNb;
            startChar = charNb;
            inProgram = true;
          }
          if (keyword == "endprogram") {
            if (inProgram) {
              FileChunk chunk(DesignElement::ElemType::Program, startLine,
                              lineNb, startChar, charNb);
              fileChunks.push_back(chunk);
              nbProgram++;
            }
            inProgram = false;
          }
          if (keyword == "primitive") {
            startLine = lineNb;
            startChar = charNb;
            inPrimitive = true;
          }
          if (keyword == "endprimitive") {
            if (inPrimitive) {
              FileChunk chunk(DesignElement::ElemType::Primitive, startLine,
                              lineNb, startChar, charNb);
              fileChunks.push_back(chunk);
              nbPrimitive++;
            }
            inPrimitive = false;
          }
          if (keyword != "") {
            if (prev_keyword != "") {
              prev_prev_keyword = prev_keyword;
            }
            prev_keyword = keyword;
          }
          keyword = "";
        }
      }
      cp = c;
    }

    if ((!inPackage) && (!inClass) && (!inModule) && (!inProgram) &&
        (!inInterface) && (!inConfig) && (!inChecker) && (!inPrimitive) &&
        (!inComment) && (!inString)) {
      if (std::regex_search(line, pieces_match, import_regex)) {
        fileLevelImportSection += line;
      }
    }
  }
  ifs.close();

  unsigned int lineSize = lineNb;

  if (lineSize < minNbLineForPartitioning) {
    m_splitFiles.push_back(m_ppFileName);
    m_lineOffsets.push_back(0);
    return;
  }
  if (m_nbChunks < 2) {
    m_splitFiles.push_back(m_ppFileName);
    m_lineOffsets.push_back(0);
    return;
  }

  if (inComment || inString) {
    m_splitFiles.clear();
    m_lineOffsets.clear();
    Location loc(0, 0, 0, m_clp->getSymbolTable()->registerSymbol(m_fileName));
    Error err(ErrorDefinition::PA_CANNOT_SPLIT_FILE, loc);
    m_clp->getErrorContainer()->addError(err);
    m_clp->getErrorContainer()->printMessages();
    return;
  }

  // Split the file

  unsigned int chunkSize = lineSize / m_nbChunks;
  int chunkNb = 0;

  unsigned int fromLine = 1;
  unsigned int toIndex = 0;
  IncludeFileInfo info(1, m_clp->getSymbolTable()->registerSymbol(m_fileName),
                       1, 1);
  m_includeFileInfo.push(info);
  unsigned int linesWriten = 0;
  for (unsigned int i = 0; i < fileChunks.size(); i++) {
    DesignElement::ElemType chunkType = fileChunks[i].m_chunkType;

    // The case of a package or a module
    if (chunkType == DesignElement::ElemType::Package ||
        chunkType == DesignElement::ElemType::Module) {
      std::string packageDeclaration;
      std::string importSection;
      unsigned int packagelastLine = fileChunks[i].m_toLine;
      packageDeclaration = allLines[fileChunks[i].m_fromLine];
      for (unsigned hi = fileChunks[i].m_fromLine; hi < fileChunks[i].m_toLine;
           hi++) {
        std::string header = allLines[hi];
        if (std::regex_search(header, pieces_match, import_regex)) {
          importSection += header;
        }
      }
      // Break up package or module
      if ((fileChunks[i].m_toLine - fileChunks[i].m_fromLine) > chunkSize) {
        bool splitted = false;
        bool endPackageDetected = false;
        std::string sllineInfo;
        unsigned int origFromLine = 0;
        std::string origFile;
        // unsigned int baseFromLine = fromLine;
        while (!endPackageDetected) {
          std::string content;
          bool actualContent = false;
          bool finishPackage = false;
          bool hitLimit = true;
          for (unsigned int j = i + 1; j < fileChunks.size(); j++) {
            hitLimit = false;
            if (fileChunks[j].m_fromLine > packagelastLine) {
              finishPackage = true;
              toIndex = j - 1;
              break;
            }

            if ((fileChunks[j].m_toLine - fromLine) >= chunkSize) {
              toIndex = j;
              break;
            }
            if (j == (fileChunks.size() - 1)) {
              toIndex = j;
              break;
            }
            toIndex = j;
          }
          if (hitLimit) {
            toIndex = fileChunks.size() - 1;
          }
          unsigned int toLine = fileChunks[toIndex].m_toLine + 1;
          if (finishPackage) {
            toLine = packagelastLine + 1;
          }
          if (toIndex == fileChunks.size() - 1) {
            toLine = allLines.size();
          }

          if (splitted) {
            content += sllineInfo;
            content += packageDeclaration + "  " + importSection;
            // content += "SLline " + std::to_string(fromLine - baseFromLine +
            // origFromLine + 1) + " \"" + origFile + "\" 1";
          } else {
            sllineInfo = setSLlineDirective_(fromLine, origFromLine, origFile);
            content = sllineInfo;
          }

          bool inString = false;
          bool inComment = false;

          m_lineOffsets.push_back(linesWriten);

          // Detect end of package or end of module
          for (unsigned int l = fromLine; l < toLine; l++) {
            std::string line = allLines[l];
            checkSLlineDirective_(line, l);

            bool inLineComment = false;
            content += allLines[l];
            if (l == fileChunks[i].m_fromLine) {
              content += "  " + importSection;
            }
            if (l != (toLine - 1)) {
              content += "\n";
            }
            linesWriten++;

            actualContent = true;
            char c = 0;
            char cp = 0;
            std::string keyword;
            for (unsigned int ii = 0; ii < line.size(); ii++) {
              c = line[ii];
              if (cp == '/' && c == '*') {
                if (!inLineComment) inComment = true;
              } else if (cp == '/' && c == '/') {
                if (!inComment) inLineComment = true;
              } else if (cp == '*' && c == '/') {
                inComment = false;
              } else if (cp != '\\' && c == '\"') {
                if ((!inLineComment) && (!inComment)) inString = !inString;
              }
              if ((!inComment) && (!inLineComment) && (!inString)) {
                if ((islower(c) || isupper(c) || c == '_') &&
                    (ii != (line.size() - 1))) {
                  keyword += c;
                } else {
                  if ((islower(c) || isupper(c) || c == '_') &&
                      (ii == (line.size() - 1))) {
                    keyword += c;
                  }

                  if ((chunkType == DesignElement::Package) &&
                      (keyword == "endpackage"))
                    endPackageDetected = true;
                  if ((chunkType == DesignElement::Module) &&
                      (keyword == "endmodule"))
                    endPackageDetected = true;

                  keyword = "";
                }
              }
              cp = c;
            }
          }

          if (actualContent) {
            splitted = true;
            if ((chunkType == DesignElement::Package) &&
                endPackageDetected == false)
              content += "  endpackage  ";
            if ((chunkType == DesignElement::Module) &&
                endPackageDetected == false)
              content += "  endmodule  ";
          } else {
            splitted = false;
          }

          std::string splitFileName =
              m_ppFileName + ".ck" + std::to_string(chunkNb);
          if (chunkNb > 1000) {
            m_splitFiles.clear();
            m_lineOffsets.clear();
            Location loc(0, 0, 0,
                         m_clp->getSymbolTable()->registerSymbol(m_fileName));
            Error err(ErrorDefinition::PA_CANNOT_SPLIT_FILE, loc);
            m_clp->getErrorContainer()->addError(err);
            m_clp->getErrorContainer()->printMessages();
            return;
          }
          content += "  " + fileLevelImportSection;
          saveContent(splitFileName, content);

          m_splitFiles.push_back(splitFileName);

          // m_lineOffsets.push_back(fromLine - 1);

          chunkNb++;
          fromLine = fileChunks[toIndex].m_toLine + 1;

          i = toIndex;
          if (finishPackage) {
            fromLine = toLine;
          }
          if (i >= fileChunks.size() - 1) {
            break;
          }
        }
      } else {
        // Split the complete package/module in a file
        std::string content;
        unsigned int packagelastLine = fileChunks[i].m_toLine;
        unsigned int toLine = fileChunks[i].m_toLine + 1;
        if (i == fileChunks.size() - 1) {
          toLine = allLines.size() - 1;
        }
        const char* temp = allLines[toLine].c_str();
        if (strstr(temp, "/*") && (!strstr(temp, "*/"))) {
          m_splitFiles.clear();
          m_lineOffsets.clear();
          Location loc(0, 0, 0,
                       m_clp->getSymbolTable()->registerSymbol(m_fileName));
          Error err(ErrorDefinition::PA_CANNOT_SPLIT_FILE, loc);
          m_clp->getErrorContainer()->addError(err);
          m_clp->getErrorContainer()->printMessages();
          return;
        }

        if (i == fileChunks.size() - 1) {
          toLine = allLines.size();
        }

        unsigned int origFromLine = 0;
        std::string origFile;

        m_lineOffsets.push_back(linesWriten);

        content += setSLlineDirective_(fromLine, origFromLine, origFile);
        for (unsigned int l = fromLine; l < toLine; l++) {
          checkSLlineDirective_(allLines[l], l);
          content += allLines[l];
          if (l != (toLine - 1)) {
            content += "\n";
          }
          linesWriten++;
        }

        std::string splitFileName =
            m_ppFileName + ".ck" + std::to_string(chunkNb);
        if (chunkNb > 1000) {
          m_splitFiles.clear();
          m_lineOffsets.clear();
          Location loc(0, 0, 0,
                       m_clp->getSymbolTable()->registerSymbol(m_fileName));
          Error err(ErrorDefinition::PA_CANNOT_SPLIT_FILE, loc);
          m_clp->getErrorContainer()->addError(err);
          m_clp->getErrorContainer()->printMessages();
          return;
        }
        saveContent(splitFileName, content);

        m_splitFiles.push_back(splitFileName);

        // m_lineOffsets.push_back (fromLine-1);

        chunkNb++;
        for (unsigned int j = i; j < fileChunks.size(); j++) {
          if ((fileChunks[j].m_toLine > packagelastLine)) {
            break;
          }
          if (j == (fileChunks.size() - 1)) {
            toIndex = j;
            break;
          }
          toIndex = j;
        }

        fromLine = packagelastLine + 1;
        i = toIndex;
      }
    }
    // The case of classes and other chunks
    else {
      for (unsigned int j = i; j < fileChunks.size(); j++) {
        if (fileChunks[j].m_chunkType == DesignElement::ElemType::Package) {
          break;
        }
        if ((fileChunks[j].m_toLine - fromLine) >= chunkSize) {
          toIndex = j;
          break;
        }
        if (j == (fileChunks.size() - 1)) {
          toIndex = j;
          break;
        }
        toIndex = j;
      }

      std::string content;
      unsigned int toLine = fileChunks[toIndex].m_toLine + 1;
      if (toIndex == fileChunks.size() - 1) {
        toLine = allLines.size();
      }
      unsigned int origFromLine = 0;
      std::string origFile;

      m_lineOffsets.push_back(linesWriten);

      content += setSLlineDirective_(fromLine, origFromLine, origFile);
      content += "  " + fileLevelImportSection;
      for (unsigned int l = fromLine; l < toLine; l++) {
        checkSLlineDirective_(allLines[l], l);
        content += allLines[l];
        if (l != (toLine - 1)) {
          content += "\n";
        }
        linesWriten++;
      }

      std::string splitFileName =
          m_ppFileName + ".ck" + std::to_string(chunkNb);
      if (chunkNb > 1000) {
        m_splitFiles.clear();
        m_lineOffsets.clear();
        Location loc(0, 0, 0,
                     m_clp->getSymbolTable()->registerSymbol(m_fileName));
        Error err(ErrorDefinition::PA_CANNOT_SPLIT_FILE, loc);
        m_clp->getErrorContainer()->addError(err);
        m_clp->getErrorContainer()->printMessages();
        return;
      }
      saveContent(splitFileName, content);

      m_splitFiles.push_back(splitFileName);

      chunkNb++;

      fromLine = fileChunks[toIndex].m_toLine + 1;
      i = toIndex;
    }
  }
}