/*

  * 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 com.sun.tools.ide.analysis.modernize.impl.ModernizeAnalyzerImpl.ResponseImpl;

 import com.sun.tools.ide.analysis.modernize.impl.YamlParser.Replacement;

 import com.sun.tools.ide.analysis.modernize.options.AnalyzerPreferences;

 import com.sun.tools.ide.analysis.modernize.options.ClangAnalyzerOptions;

 import static com.sun.tools.ide.analysis.modernize.utils.AnalyticsTools.fatalError;

 import static com.sun.tools.ide.analysis.modernize.utils.AnalyticsTools.findItem;

 import java.io.File;

 import java.io.IOException;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.List;

 import java.util.logging.Level;

 import java.util.logging.Logger;

 import java.util.prefs.Preferences;

 import javax.swing.JComponent;

 import javax.swing.JLabel;

 import org.netbeans.modules.cnd.analysis.api.AbstractCustomizerProvider;

 import org.netbeans.modules.cnd.analysis.api.AnalyzerResponse;

 import org.netbeans.modules.cnd.api.model.CsmFile;

 import org.netbeans.modules.cnd.api.model.syntaxerr.AbstractCodeAudit;

 import org.netbeans.modules.cnd.api.model.syntaxerr.AuditPreferences;

 import org.netbeans.modules.cnd.api.model.syntaxerr.CodeAudit;

 import org.netbeans.modules.cnd.api.model.syntaxerr.CodeAuditFactory;

 import org.netbeans.modules.cnd.api.model.syntaxerr.CodeAuditProvider;

 import org.netbeans.modules.cnd.api.model.syntaxerr.CsmErrorInfo;

 import org.netbeans.modules.cnd.api.model.syntaxerr.CsmErrorInfo.Severity;

 import org.netbeans.modules.cnd.api.model.syntaxerr.CsmErrorInfoHintProvider;

 import org.netbeans.modules.cnd.api.model.syntaxerr.CsmErrorProvider;

 import org.netbeans.modules.cnd.api.project.NativeFileItem.Language;

 import org.netbeans.modules.cnd.api.project.NativeProject;

 import org.netbeans.modules.cnd.api.remote.RemoteProject;

 import org.netbeans.modules.cnd.makeproject.api.MakeProject;

 import org.netbeans.modules.cnd.makeproject.api.configurations.Item;

 import org.netbeans.modules.cnd.modelutil.CsmUtilities;

 import org.netbeans.modules.cnd.utils.MIMENames;

 import org.netbeans.modules.nativeexecution.api.ExecutionEnvironment;

 import org.netbeans.modules.nativeexecution.api.ExecutionEnvironmentFactory;

 import org.netbeans.modules.nativeexecution.api.util.ConnectionManager;

 import org.netbeans.spi.editor.hints.Fix;

 import org.openide.filesystems.FileObject;

 import org.openide.filesystems.FileUtil;

 import org.openide.util.Exceptions;

 import org.openide.util.Lookup;

 import org.openide.util.NbBundle;

 import org.openide.util.lookup.ServiceProvider;

 import org.openide.util.lookup.ServiceProviders;

 @ServiceProviders({

     @ServiceProvider(service = CsmErrorProvider.class, position = 2100)

     ,

     @ServiceProvider(service = CodeAuditProvider.class, position = 2100)

 })

 public final class ModernizeErrorProvider extends CsmErrorProvider implements CodeAuditProvider, AbstractCustomizerProvider {

     public static final Logger LOG = Logger.getLogger("ide.analysis.tidy"); //NOI18N

     private Collection<CodeAudit> audits;

     public static final String NAME = "Modernize"; //NOI18N

     public static ModernizeErrorProvider getInstance() {

         for (CsmErrorProvider provider : Lookup.getDefault().lookupAll(CsmErrorProvider.class)) {

             if (NAME.equals(provider.getName()) && provider instanceof ModernizeErrorProvider) {

                 return (ModernizeErrorProvider) provider;

             }

         }

         return null;

     }

     @Override

     protected boolean validate(Request request) {

         CsmFile file = request.getFile();

         return file != null;

     }

     @Override

     public boolean hasHintControlPanel() {

         return true;

     }

     @Override

     public String getName() {

         return NAME;

     }

     @Override

     public String getDisplayName() {

         return NbBundle.getMessage(ModernizeErrorProvider.class, "Modernize_NAME"); //NOI18N

     }

     @Override

     public String getDescription() {

         return NbBundle.getMessage(ModernizeErrorProvider.class, "Modernize_DESCRIPTION"); //NOI18N

     }

     @Override

     public String getMimeType() {

         return MIMENames.SOURCES_MIME_TYPE;

     }

     @Override

     public boolean isSupportedEvent(EditorEvent kind) {

         return kind == EditorEvent.FileBased;

     }

     @Override

     protected void doGetErrors(CsmErrorProvider.Request request, CsmErrorProvider.Response response) {

         CsmFile file = request.getFile();

         if (file != null) {

             if (request.isCancelled()) {

                 return;

             }

             Object platformProject = file.getProject().getPlatformProject();

             if (platformProject instanceof NativeProject) {

                 Lookup.Provider project = ((NativeProject) platformProject).getProject();

                 if (project != null) {

                     if (request.isCancelled()) {

                         return;

                     }

                     Thread currentThread = Thread.currentThread();

                     currentThread.setName("Provider " + getName() + " prosess " + file.getAbsolutePath()); // NOI18N

                     RemoteProject info = project.getLookup().lookup(RemoteProject.class);

                     if (info != null) {

                         ExecutionEnvironment execEnv = info.getDevelopmentHost();

                         if (execEnv != null) {

                             if (request.isCancelled()) {

                                 return;

                             }

                             if (ConnectionManager.getInstance().isConnectedTo(execEnv)) {

                                 Item item = findItem(file, project);

                                 if (item != null) {

                                     if (request.isCancelled()) {

                                         return;

                                     }

                                     // Temporarily analyzing even excluded items

                                     if (/* !item.isExcluded() &&  */(item.getLanguage() == Language.C || item.getLanguage() == Language.CPP || item.getLanguage() == Language.C_HEADER)) {

                                         analyze(execEnv, item, project, request, response);

                                     }

                                 }

                             }

                         }

                     }

                 }

             }

         }

     }

     public void analyze(ExecutionEnvironment execEnv, Item item, Lookup.Provider project, CsmErrorProvider.Request request, CsmErrorProvider.Response response) {

         String binaryPath = ClangAnalyzerOptions.getClangAnalyzerPath();

         boolean isAnalyzer = response instanceof ModernizeAnalyzerImpl.ResponseImpl;

         if (binaryPath == null) {

             Level level = isAnalyzer ? Level.INFO : Level.FINE;

             LOG.log(level, "clang-tidy needs to be installed as a plugin"); //NOI18N

             return;

         }

         if (isAnalyzer && isNewRun()) {

             AnalyzedFiles.getDefault().clear();

         }

         DiagnosticsTool diagnosticsTool = new DiagnosticsTool(execEnv, item, (MakeProject) project, binaryPath);

         try {

             CsmFile csmFile = request.getFile();

             Collection<String> checks = /*isAnalyzer ? Collections.singleton("*") : */ getEnabledChecks(); //NOI18N

             Collection<CsmFile> tu = new ArrayList<CsmFile>();

             if (isAnalyzer) {

                 tu.add(csmFile);

             } else {

                 if (AnalyzedFiles.getDefault().isStartFile(csmFile)) {

                     tu.add(csmFile);

                 } else {

                     tu.addAll(AnalyzedFiles.getDefault().getStartFiles(csmFile));

                 }

             }

             if (!isAnalyzer) {

                 response = new ResponseMerger(response);

             }

             for (CsmFile startFile : tu) {

                 int exitCode = diagnosticsTool.process(checks, startFile, true);

                 if (exitCode != DiagnosticsTool.STATUS_OK) {

                     String error = NbBundle.getMessage(ModernizeErrorProvider.class, "compile.file.error"); //NOI18N

                     String info = NbBundle.getMessage(ModernizeErrorProvider.class, "compile.file.error.info", "" + exitCode); //NOI18N

                     fatalError(AnalyzerResponse.AnalyzerSeverity.FileError, "fatal.analyze.error", error + "\n" + info, csmFile, response); //NOI18N

                     return;

                 }

                 List<YamlParser.Diagnostics> results = YamlParser.getDefault().parseYaml(diagnosticsTool.getYamlAsString());

                 postProcess(isAnalyzer, startFile, project, results, request, response);

             }

             if (!isAnalyzer) {

                 response.done();

             }

         } catch (ConnectionManager.CancellationException ex) {

             Exceptions.printStackTrace(ex);

         } catch (IOException ex) {

             Exceptions.printStackTrace(ex);

         }

     }

     private static CsmErrorProvider last;

     private boolean isNewRun() {

         if (last == null || this != last) {

             last = this;

             return true;

         }

         return false;

     }

     public void postProcess(boolean isAnalyzer, CsmFile startFile, Lookup.Provider project, List<YamlParser.Diagnostics> results, CsmErrorProvider.Request request, CsmErrorProvider.Response response) {

         CsmFile file = request.getFile();

         List<CsmFile> otherCsmFiles = new ArrayList<CsmFile>();

         for (YamlParser.Diagnostics diag : results) {

             // TODO: don't add "Configure Hint" fix multiple times for one line

             FileObject fo = FileUtil.toFileObject(new File(diag.getMessageFilePath()));

             CsmFile csmFile = CsmUtilities.getCsmFile(fo, false, false);

             // Composing a preview message. Showing a start file for compilation unit

             // in case we analysing a header file

             ModernizeErrorInfo info;

             if (startFile.equals(file) && csmFile.equals(file)) {

                 String message = String.format("[%s]: %s", diag.getCheckName(), diag.getMessage()); //NOI18N

                 info = ModernizeErrorInfo.withFixedMessage(diag, message, project);

             } else {

                 info = ModernizeErrorInfo.withMutableMessage(diag, diag.getCheckName(), startFile.getName().toString(), diag.getMessage(), project);

             }

             if (isAnalyzer) {

                 // Add found errors for all files (can be other files from compileUnit)

                 ((ResponseImpl) response).addError(AnalyzerResponse.AnalyzerSeverity.DetectedError, null, fo, info);

                 if (!csmFile.equals(file)) {

                     // May be not header (e.g BBB.cc: AAA.cc -> (includes) BBB.cc -> ... )

                     otherCsmFiles.add(csmFile);

                 }

             } else if (fo.equals(file.getFileObject())) {

                 // Add found errors only for file displayed in Editor

                 response.addError(info);

             }

         }

         if (isAnalyzer /* and not empty? */) {

             AnalyzedFiles.getDefault().cacheHierarchy(file, otherCsmFiles);

         }

     }

     @ServiceProvider(path = CodeAuditFactory.REGISTRATION_PATH + ModernizeErrorProvider.NAME, service = CodeAuditFactory.class, position = 4000)

     public static final class Factory implements CodeAuditFactory {

         @Override

         public AbstractCodeAudit create(AuditPreferences preferences) {

             String id = NbBundle.getMessage(ModernizeCodeAudit.class, "LBL_ProviderName");  // NOI18N

             String description = NbBundle.getMessage(ModernizeCodeAudit.class, "LBL_ProviderDescription");  // NOI18N

             return new ModernizeCodeAudit(id, id, description, "error", false, preferences);  // NOI18N

         }

     }

     private String oldPath;

     @Override

     public synchronized Collection<CodeAudit> getAudits() {

         String path = ClangAnalyzerOptions.getClangAnalyzerPath();

         if (path == null) {

             return Collections.emptyList();

         }

         if (oldPath == null) {

             oldPath = path;

         }

         if (audits == null || !oldPath.equals(path)) {

             List<CodeAudit> res = DiagnosticsTool.getAudits(path, ExecutionEnvironmentFactory.getLocal(), AnalyzerPreferences.getAuditPreferences());

             audits = res;

             oldPath = path;

         }

         return audits;

     }

     public Collection<String> getEnabledChecks() {

         Collection<CodeAudit> auditList = getAudits();

         List<String> enabled = new ArrayList<String>();

         for (CodeAudit codeAudit : auditList) {

             if (codeAudit.isEnabled()) {

                 enabled.add(codeAudit.getID());

             }

         }

         return enabled.size() == auditList.size() ? Collections.singleton("*") : enabled; //NOI18N

     }

     @Override

     public AuditPreferences getPreferences() {

         return AnalyzerPreferences.getAuditPreferences();

     }

     @Override

     public JComponent createComponent(Preferences context) {

         return new JLabel();

     }

     public static interface ErrorInfoWithId {

         String getId();

     }

     public static final class FatalErrorInfo implements CsmErrorInfo, ErrorInfoWithId {

         private final String id;

         private final String message;

         public FatalErrorInfo(String id, String message) {

             this.id = id;

             this.message = message;

         }

         @Override

         public String getMessage() {

             return message;

         }

         @Override

         public Severity getSeverity() {

             return Severity.WARNING;

         }

         @Override

         public int getStartOffset() {

             return 0;

         }

         @Override

         public int getEndOffset() {

             return 1;

         }

         @Override

         public String getId() {

             return id;

         }

     }

     @ServiceProvider(service = CsmErrorInfoHintProvider.class, position = 9100)

     public final static class ModerinzeHintProvider extends CsmErrorInfoHintProvider {

         @Override

         protected List<Fix> doGetFixes(CsmErrorInfo info, List<Fix> alreadyFound) {

             if (info instanceof ModernizeErrorInfo) {

                 alreadyFound.add(new ConfigureHintsFix((ModernizeErrorInfo) info));

             }

             return alreadyFound;

         }

     }

     @ServiceProvider(service = CsmErrorInfoHintProvider.class, position = 1600)

     public static final class ModernizeFixProvider extends CsmErrorInfoHintProvider {

         @Override

         protected List<Fix> doGetFixes(CsmErrorInfo info, List<Fix> alreadyFound) {

             alreadyFound.addAll(createFixes(info));

             return alreadyFound;

         }

     }

     private static List<? extends Fix> createFixes(CsmErrorInfo info) {

         if (info instanceof ModernizeErrorInfo) {

             ModernizeErrorInfo mei = (ModernizeErrorInfo) info;

             List<Replacement> replacements = mei.getDiagnostics().getReplacements();

             if (!replacements.isEmpty()) {

                 return Collections.singletonList(new ModernizeFix(replacements, mei.getId()));

             }

         }

         return Collections.EMPTY_LIST;

     }

 }