/*

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

  *

  * Copyright (c) 2017 Oracle and/or its affiliates. All rights reserved.

  *

  * Oracle and Java are registered trademarks of Oracle and/or its affiliates.

  * Other names may be trademarks of their respective owners.

  *

  * The contents of this file are subject to the terms of either the GNU

  * General Public License Version 2 only ("GPL") or the Common

  * Development and Distribution License("CDDL") (collectively, the

  * "License"). You may not use this file except in compliance with the

  * License. You can obtain a copy of the License at

  * http://www.netbeans.org/cddl-gplv2.html

  * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

  * specific language governing permissions and limitations under the

  * License.  When distributing the software, include this License Header

  * Notice in each file and include the License file at

  * nbbuild/licenses/CDDL-GPL-2-CP.  Oracle designates this

  * particular file as subject to the "Classpath" exception as provided

  * by Oracle in the GPL Version 2 section of the License file that

  * accompanied this code. If applicable, add the following below the

  * License Header, with the fields enclosed by brackets [] replaced by

  * your own identifying information:

  * "Portions Copyrighted [year] [name of copyright owner]"

  *

  * If you wish your version of this file to be governed by only the CDDL

  * or only the GPL Version 2, indicate your decision by adding

  * "[Contributor] elects to include this software in this distribution

  * under the [CDDL or GPL Version 2] license." If you do not indicate a

  * single choice of license, a recipient has the option to distribute

  * your version of this file under either the CDDL, the GPL Version 2 or

  * to extend the choice of license to its licensees as provided above.

  * However, if you add GPL Version 2 code and therefore, elected the GPL

  * Version 2 license, then the option applies only if the new code is

  * made subject to such option by the copyright holder.

  *

  * Contributor(s): Ilia Gromov

  */

 package com.sun.tools.ide.analysis.modernize.impl;

 import static com.sun.tools.ide.analysis.modernize.impl.YamlParser.Diagnostics.UNDEFINED;

 import java.util.ArrayList;

 import java.util.Collections;

 import java.util.List;

 import java.util.StringTokenizer;

 import java.util.logging.Level;

 /**

  *

  * @author Ilia Gromov

  */

 public class YamlParser {

     // TODO check for no-replacements case

     private static final YamlParser INSTANCE = new YamlParser();

     public static YamlParser getDefault() {

         return INSTANCE;

     }

     private static final String OPEN_TAG = "---"; //NOI18N

     private static final String CLOSE_TAG = "..."; //NOI18N

     private static final String MAIN_SOURCE_FILE = "MainSourceFile"; //NOI18N

     private static final String CHECK_NAME = "CheckName"; //NOI18N

     private static final String LEVEL = "Level"; //NOI18N

     private static final String MESSAGE_FILE_PATH = "MessageFilePath"; //NOI18N

     private static final String MESSAGE_FILE_OFFSET = "MessageFileOffset"; //NOI18N

     private static final String MESSAGE = "Message"; //NOI18N

     private static final String REPLACEMENTS = "Replacements"; //NOI18N

     private static final String DIAGNOSTICS = "Diagnostics"; //NOI18N

     private static final String FILE_PATH = "FilePath"; //NOI18N

     private static final String OFFSET = "Offset"; //NOI18N

     private static final String LENGTH = "Length"; //NOI18N

     private static final String REPLACEMENT_TEXT = "ReplacementText"; //NOI18N

     // clang-modernize:

 // ---

 // MainSourceFile:  /home/ilia/NetBeansProjects/CppApplication_46/main.cpp

 // Replacements:    

 //   - FilePath:        /home/ilia/NetBeansProjects/CppApplication_46/newfile.h

 //     Offset:          101

 //     Length:          1

 //     ReplacementText: nullptr

 //   - FilePath:        /home/ilia/NetBeansProjects/CppApplication_46/newfile1.h

 //     Offset:          380

 //     Length:          1

 //     ReplacementText: nullptr

 //   - FilePath:        /home/ilia/NetBeansProjects/CppApplication_46/main.cpp

 //     Offset:          152

 //     Length:          1

 //     ReplacementText: nullptr

 // ...

     // clang-tidy:

 // ---

 // MainSourceFile:  ''

 // Diagnostics:     

 //   CheckName:       misc-macro-parentheses

 //   Replacements:    

 //     - FilePath:        /media/SSD_/code/zdoom/main_1.cpp

 //       Offset:          1352

 //       Length:          0

 //       ReplacementText: '('

 //     - FilePath:        /media/SSD_/code/zdoom/main_1.cpp

 //       Offset:          1353

 //       Length:          0

 //       ReplacementText: ')'

 // Diagnostics:     

 //   CheckName:       misc-macro-parentheses

 //   Replacements:    

 //     - FilePath:        /media/SSD_/code/zdoom/main_1.cpp

 //       Offset:          1446

 //       Length:          0

 //       ReplacementText: '('

 //     - FilePath:        /media/SSD_/code/zdoom/main_1.cpp

 //       Offset:          1447

 //       Length:          0

 //       ReplacementText: ')'

 // ...

     public List<Diagnostics> parseYaml(String output) {

         try {

             if (output.isEmpty()) {

                 // No warnings in header = no 'Main Source File' element

                 return Collections.EMPTY_LIST;

             }

             StringTokenizer st = new StringTokenizer(output, "\n"); //NOI18N

             String line;

             // ---

             line = st.nextToken();

             line = st.nextToken();

             String mainSourceFile = getValue(MAIN_SOURCE_FILE, line);

             // Replacements:    

             line = st.nextToken();

             ClangTidyVersion version = line.contains(REPLACEMENTS)

                     ? ClangTidyVersion.OLD_FORMAT

                     : ClangTidyVersion.NEW_FORMAT;

             List<Diagnostics> list = version.parser.parse(st);

             return list;

         } catch (Exception ex) {

             ModernizeErrorProvider.LOG.log(Level.INFO, "Can't parse output line");

             return Collections.EMPTY_LIST;

         }

     }

     private static List<Replacement> parseReplacements(StringTokenizer st) {

         List<Replacement> replacements = new ArrayList<Replacement>();

         String line;

         // eat Replacements:

         line = st.nextToken();

         if (!line.contains(REPLACEMENTS)) {

             return replacements;

         }

         while (st.hasMoreTokens()) {

             line = st.nextToken();

             if (line.equals(CLOSE_TAG) || !line.contains(FILE_PATH)) {

                 break;

             }

             String filePath = getValue(FILE_PATH, line);

             line = st.nextToken();

             int offset = Integer.parseInt(getValue(OFFSET, line));

             line = st.nextToken();

             int length = Integer.parseInt(getValue(LENGTH, line));

             line = st.nextToken();

             String replacementText = getValue(REPLACEMENT_TEXT, line);

             while (replacementText == null && st.hasMoreElements()) {

                 line = line + "\n" + st.nextElement(); //NOI18N

                 replacementText = getValue(REPLACEMENT_TEXT, line);

             }

             Replacement replacement = new Replacement(filePath, offset, length, replacementText);

             replacements.add(replacement);

         }

         return replacements;

     }

     private static String getValue(String key, String line) {

         int keyStart = line.indexOf(key);

         assert keyStart != -1;

         int keyEnd = keyStart + key.length() + 1;

         String trimmed = line.substring(keyEnd).trim();

         boolean isTextValue = trimmed.charAt(0) == '\'';

         if (isTextValue) {

             if (trimmed.length() == 1) {

                 // '

                 // abcd'

                 return null;

             } else if (trimmed.charAt(trimmed.length() - 1) == '\'') {

                 trimmed = trimmed.substring(1, trimmed.length() - 1);

             } else {

                 return null;

             }

         }

         return trimmed;

     }

     public static class TranslationUnitDiagnostics {

         private final String mainSourceFilePath;

         private final String context;

         private final List<Diagnostics> diags;

         public TranslationUnitDiagnostics(String mainSourceFilePath, String context, List<Diagnostics> diags) {

             this.mainSourceFilePath = mainSourceFilePath;

             this.context = context;

             this.diags = diags;

         }

         public String getMainSourceFilePath() {

             return mainSourceFilePath;

         }

         public String getContext() {

             return context;

         }

         public List<Diagnostics> getDiags() {

             return diags;

         }

     }

     public static class Diagnostics {

         public static final String UNDEFINED = "undefined"; // NOI18N

         public enum Level {

             warning, error

         }

         private final String checkName;

         private final Diagnostics.Level level;

         private final String messageFilePath;

         private final int messageFileOffset;

         private final String message;

         private final List<Replacement> replacements;

         public Diagnostics(String checkName, Diagnostics.Level level, String messageFilePath, int messageFileOffset, String message, List<Replacement> replacements) {

             this.checkName = checkName;

             this.level = level;

             this.messageFilePath = messageFilePath;

             this.messageFileOffset = messageFileOffset;

             this.message = message;

             this.replacements = replacements;

         }

         public String getCheckName() {

             return checkName;

         }

         public Level getLevel() {

             return level;

         }

         public String getMessageFilePath() {

             return messageFilePath;

         }

         public int getMessageFileOffset() {

             return messageFileOffset;

         }

         public String getMessage() {

             return message;

         }

         public List<Replacement> getReplacements() {

             return replacements;

         }

     }

     public static class Replacement {

         public final String filePath;

         public final int offset;

         public final int length;

         public final String replacementText;

         public Replacement(String FilePath, int offset, int length, String replacementText) {

             this.filePath = FilePath;

             this.offset = offset;

             this.length = length;

             this.replacementText = replacementText;

         }

     }

     private static enum ClangTidyVersion {

         NEW_FORMAT(new NewFormatParser()),

         OLD_FORMAT(new OldFormatParser());

         public final TidyParser parser;

         private ClangTidyVersion(TidyParser parser) {

             this.parser = parser;

         }

     }

     private static abstract class TidyParser {

         abstract List<Diagnostics> parse(StringTokenizer st);

     }

     private static class NewFormatParser extends TidyParser {

         @Override

         public List<Diagnostics> parse(StringTokenizer st) {

             List<Diagnostics> list = new ArrayList<Diagnostics>();

             String line;

             while (st.hasMoreElements()) {

                 line = st.nextToken();

                 String checkName = getValue(CHECK_NAME, line);

                 line = st.nextToken();

                 Diagnostics.Level level = Diagnostics.Level.valueOf(getValue(LEVEL, line).toLowerCase());

                 line = st.nextToken();

                 String messageFilePath = getValue(MESSAGE_FILE_PATH, line);

                 line = st.nextToken();

                 int messageFileOffset = Integer.parseInt(getValue(MESSAGE_FILE_OFFSET, line));

                 line = st.nextToken();

                 String message = getValue(MESSAGE, line);

                 List<Replacement> replacements = parseReplacements(st);

                 list.add(new Diagnostics(checkName, level, messageFilePath, messageFileOffset, message, replacements));

             }

             return list;

         }

     }

     private static class OldFormatParser extends TidyParser {

         @Override

         public List<Diagnostics> parse(StringTokenizer st) {

             List<Replacement> parseReplacements = parseReplacements(st);

             return Collections.singletonList(new Diagnostics(UNDEFINED, Diagnostics.Level.warning, "", -1, "", parseReplacements)); //NOI18N

         }

     }

 }