/*

 * 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.options.ClangAnalyzerOptions;

import com.sun.tools.ide.analysis.modernize.resources.BundleUtilities;

import java.io.CharConversionException;

import java.io.File;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.List;

import java.util.concurrent.atomic.AtomicBoolean;

import java.util.prefs.Preferences;

import org.netbeans.modules.analysis.spi.Analyzer;

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

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

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

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

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

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

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

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

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

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

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

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

import org.openide.filesystems.FileObject;

import org.openide.util.ImageUtilities;

import org.openide.util.NbBundle;

import org.openide.util.lookup.ServiceProvider;

import org.openide.xml.XMLUtil;

public class ModernizeAnalyzerImpl extends AbstractAnalyzer {

    private static final String PREFIX = "tidy-"; //NOI18N

    private ModernizeErrorProvider currentErrorProvider;

    private ModernizeAnalyzerImpl(Context ctx) {

        super(ctx);

    }

    @Override

    public ModernizeErrorProvider getErrorProvider(Preferences preferences) {

        return ModernizeErrorProvider.getInstance();

    }

    @Override

    protected boolean isCompileUnitBased() {

        return true;

    }

    @Override

    protected Collection<ErrorDescription> done() {

        if (currentErrorProvider != null) {

            Collection<ErrorDescription> results = currentErrorProvider.done();

            currentErrorProvider = null;

            return results;

        }

        return Collections.<ErrorDescription>emptyList();

    }

    @Override

    protected Collection<? extends ErrorDescription> doRunImpl(final FileObject sr, final Context ctx, final CsmErrorProvider provider, final AtomicBoolean cancel) {

        final CsmFile csmFile = CsmUtilities.getCsmFile(sr, false, false);

        if (csmFile == null) {

            return Collections.<ErrorDescription>emptyList();

        }

        CsmErrorProvider.Request request = new RequestImpl(csmFile, ctx, cancel);

        final ArrayList<ErrorDescription> res = new ArrayList<>();

        CsmErrorProvider.Response response = new ModernizeResponse(sr, res, cancel);

        this.currentErrorProvider = (ModernizeErrorProvider) provider;

        provider.getErrors(request, response);

        return res;

    }

    protected static class ModernizeResponse extends AbstractResponse {

        public ModernizeResponse(FileObject sr, ArrayList<ErrorDescription> res, AtomicBoolean cancel) {

            super(sr, res, cancel);

        }

        @Override

        public ErrorDescription addErrorImpl(CsmErrorInfo errorInfo, FileObject fo) {

            String messages[] = errorInfo.getMessage().split("\n"); //NOI18N

            if (messages.length > 0) {

                StringBuilder sb = new StringBuilder();

                if (errorInfo instanceof ModernizeErrorInfo) {

                    ModernizeErrorInfo mei = (ModernizeErrorInfo) errorInfo;

                    sb.append("<pre>"); //NOI18N

                    sb.append("["); //NOI18N

                    sb.append(mei.getId());

                    sb.append("]"); //NOI18N

                    sb.append("\n"); //NOI18N

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

                    if (replacements.isEmpty()) {

                        sb.append(CndPathUtilities.getRelativePath(mei.getProject().getProjectRoot(), mei.getDiagnostics().getMessageFilePath())).append(" "); //NOI18N

                        sb.append(mei.getDiagnostics().getMessageFileOffset()).append("\n");

                    } else {

                        for (YamlParser.Replacement replacement : replacements) {

                            sb.append("\n"); //NOI18N

                            sb.append("Replacement: "); //NOI18N

                            sb.append(CndPathUtilities.getRelativePath(mei.getProject().getProjectRoot(), replacement.filePath)).append(" "); //NOI18N

                            sb.append(replacement.offset).append("-").append(replacement.offset + replacement.length).append("\n"); //NOI18N

                            String attributeValue = replacement.replacementText;

                            try {

                                attributeValue = XMLUtil.toAttributeValue(replacement.replacementText);

                            } catch (CharConversionException ex) {

                            }

                            sb.append(attributeValue).append("\n"); //NOI18N

                        }

                    }

                    sb.append(mei.getMessage());

                    sb.append("</pre>"); //NOI18N

                    LazyFixList list = new LazyFixListImpl();

                    return ErrorDescriptionFactory.createErrorDescription(PREFIX + mei.getId(), Severity.valueOf(mei.getSeverity().toString().toUpperCase()),

                            messages[0], sb.toString(), list, fo, errorInfo.getStartOffset(), errorInfo.getStartOffset());

                }

            }

            return null;

        }

    }

    @ServiceProvider(service = AnalyzerFactory.class)

    public static final class AnalyzerFactoryImpl extends AnalyzerFactory {

        public AnalyzerFactoryImpl() {

            super(ModernizeErrorProvider.NAME,

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

                    ImageUtilities.loadImage("com/sun/tools/ide/analysis/modernize/impl/bugs.png")); //NOI18N

        }

        @Override

        public Iterable<? extends WarningDescription> getWarnings() {

            List<WarningDescription> result = new ArrayList<>();

            final ModernizeErrorProvider provider = ModernizeErrorProvider.getInstance();

            for (CodeAudit audit : provider.getAudits()) {

                result.add(WarningDescription.create(PREFIX + audit.getID(), audit.getName(), ModernizeErrorProvider.NAME, provider.getDisplayName()));

            }

            String[] fatals = BundleUtilities.getFatalErrors();

            for (String id : fatals) { //NOI18N

                if (!id.isEmpty()) {

                    result.add(WarningDescription.create(PREFIX + id, BundleUtilities.getDescription(id), ModernizeErrorProvider.NAME, provider.getDisplayName()));

                }

            }

            return result;

        }

        @Override

        public CustomizerProvider<Void, AbstractHintsPanel> getCustomizerProvider() {

            return new CustomizerProvider<Void, AbstractHintsPanel>() {

                @Override

                public Void initialize() {

                    return null;

                }

                @Override

                public AbstractHintsPanel createComponent(CustomizerContext<Void, AbstractHintsPanel> context) {

                    return AbstractAnalyzer.createComponent(ModernizeErrorProvider.getInstance());

                }

            };

        }

        @Override

        public Collection<? extends MissingPlugin> requiredPlugins(Context context) {

//            ExecutionEnvironment env = detectEnvironment(context);

//            if (env == null) {

//                env = ExecutionEnvironmentFactory.getLocal();

//            }

            String installedTool = ClangAnalyzerOptions.getClangAnalyzerPath();

            if (installedTool == null || !new File(installedTool).exists()) {

                String codeBase = ClangAnalyzerOptions.getMissingModuleName();

                if (codeBase != null) {

                    return Arrays.asList(new MissingPlugin(codeBase, NbBundle.getMessage(ModernizeAnalyzerImpl.class, "Modernize_NAME"))); //NOI18N

                }

            }

            return Collections.emptyList();

        }

        @Override

        public Analyzer createAnalyzer(Context context) {

            return new ModernizeAnalyzerImpl(context);

        }

    }

}