/*
 * Copyright (C) 2011 The Android Open Source Project
 *
 * Licensed under the Eclipse Public License, Version 1.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.eclipse.org/org/documents/epl-v10.php
 *
 * 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.
 */
package com.android.ide.eclipse.adt.internal.lint;

import static com.android.SdkConstants.DOT_JAVA;
import static com.android.SdkConstants.DOT_XML;

import com.android.ide.eclipse.adt.AdtPlugin;
import com.android.ide.eclipse.adt.internal.editors.IconFactory;
import com.android.ide.eclipse.adt.internal.preferences.LintPreferencePage;
import com.android.ide.eclipse.adt.internal.project.BaseProjectHelper;
import com.android.tools.lint.detector.api.LintUtils;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.IJobChangeListener;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.preference.IPreferenceNode;
import org.eclipse.jface.preference.PreferenceDialog;
import org.eclipse.jface.preference.PreferenceManager;
import org.eclipse.jface.preference.PreferenceNode;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.IRegion;
import org.eclipse.jface.text.Region;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Text;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IViewSite;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.editors.text.TextFileDocumentProvider;
import org.eclipse.ui.part.ViewPart;
import org.eclipse.ui.texteditor.IDocumentProvider;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Eclipse View which shows lint warnings for the current project
 */
public class LintViewPart extends ViewPart implements SelectionListener, IJobChangeListener {
    /** The view id for this view part */
    public static final String ID = "com.android.ide.eclipse.adt.internal.lint.LintViewPart"; //$NON-NLS-1$
    private static final String QUICKFIX_DISABLED_ICON = "quickfix-disabled";         //$NON-NLS-1$
    private static final String QUICKFIX_ICON = "quickfix";                           //$NON-NLS-1$
    private static final String REFRESH_ICON = "refresh";                             //$NON-NLS-1$
    private static final String EXPAND_DISABLED_ICON = "expandall-disabled";          //$NON-NLS-1$
    private static final String EXPAND_ICON = "expandall";                            //$NON-NLS-1$
    private static final String COLUMNS_ICON = "columns";                             //$NON-NLS-1$
    private static final String OPTIONS_ICON = "options";                             //$NON-NLS-1$
    private static final String IGNORE_THIS_ICON = "ignore-this";                     //$NON-NLS-1$
    private static final String IGNORE_THIS_DISABLED_ICON = "ignore-this-disabled";   //$NON-NLS-1$
    private static final String IGNORE_FILE_ICON = "ignore-file";                     //$NON-NLS-1$
    private static final String IGNORE_FILE_DISABLED_ICON = "ignore-file-disabled";   //$NON-NLS-1$
    private static final String IGNORE_PRJ_ICON = "ignore-project";                   //$NON-NLS-1$
    private static final String IGNORE_PRJ_DISABLED_ICON = "ignore-project-disabled"; //$NON-NLS-1$
    private static final String IGNORE_ALL_ICON = "ignore-all";                   //$NON-NLS-1$
    private static final String IGNORE_ALL_DISABLED_ICON = "ignore-all-disabled"; //$NON-NLS-1$
    private IMemento mMemento;
    private LintList mLintView;
    private Text mDetailsText;
    private Label mErrorLabel;
    private SashForm mSashForm;
    private Action mFixAction;
    private Action mRemoveAction;
    private Action mIgnoreAction;
    private Action mAlwaysIgnoreAction;
    private Action mIgnoreFileAction;
    private Action mIgnoreProjectAction;
    private Action mRemoveAllAction;
    private Action mRefreshAction;
    private Action mExpandAll;
    private Action mCollapseAll;
    private Action mConfigureColumns;
    private Action mOptions;

    /**
     * Initial projects to show: this field is only briefly not null during the
     * construction initiated by {@link #show(List)}
     */
    private static List<? extends IResource> sInitialResources;

    /**
     * Constructs a new {@link LintViewPart}
     */
    public LintViewPart() {
    }

    @Override
    public void init(IViewSite site, IMemento memento) throws PartInitException {
        super.init(site, memento);
        mMemento = memento;
    }

    @Override
    public void saveState(IMemento memento) {
        super.saveState(memento);

        mLintView.saveState(memento);
    }

    @Override
    public void dispose() {
        if (mLintView != null) {
            mLintView.dispose();
            mLintView = null;
        }
        super.dispose();
    }

    @Override
    public void createPartControl(Composite parent) {
        GridLayout gridLayout = new GridLayout(1, false);
        gridLayout.verticalSpacing = 0;
        gridLayout.marginWidth = 0;
        gridLayout.marginHeight = 0;
        parent.setLayout(gridLayout);

        mErrorLabel = new Label(parent, SWT.NONE);
        mErrorLabel.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, false, false, 1, 1));

        mSashForm = new SashForm(parent, SWT.NONE);
        mSashForm.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
        mLintView = new LintList(getSite(), mSashForm, mMemento, false /*singleFile*/);

        mDetailsText = new Text(mSashForm,
                SWT.BORDER | SWT.READ_ONLY | SWT.WRAP | SWT.V_SCROLL | SWT.MULTI);
        Display display = parent.getDisplay();
        mDetailsText.setBackground(display.getSystemColor(SWT.COLOR_INFO_BACKGROUND));
        mDetailsText.setForeground(display.getSystemColor(SWT.COLOR_INFO_FOREGROUND));

        mLintView.addSelectionListener(this);
        mSashForm.setWeights(new int[] {8, 2});

        createActions();
        initializeToolBar();

        // If there are currently running jobs, listen for them such that we can update the
        // button state
        refreshStopIcon();

        if (sInitialResources != null) {
            mLintView.setResources(sInitialResources);
            sInitialResources = null;
        } else {
            // No supplied context: show lint warnings for all projects
            IJavaProject[] androidProjects = BaseProjectHelper.getAndroidProjects(null);
            if (androidProjects.length > 0) {
                List<IResource> projects = new ArrayList<IResource>();
                for (IJavaProject project : androidProjects) {
                    projects.add(project.getProject());
                }
                mLintView.setResources(projects);
            }
        }

        updateIssueCount();
    }

    /**
     * Create the actions.
     */
    private void createActions() {
        ISharedImages sharedImages = PlatformUI.getWorkbench().getSharedImages();
        IconFactory iconFactory = IconFactory.getInstance();
        mFixAction = new LintViewAction("Fix", ACTION_FIX,
                iconFactory.getImageDescriptor(QUICKFIX_ICON),
                iconFactory.getImageDescriptor(QUICKFIX_DISABLED_ICON));

        mIgnoreAction = new LintViewAction("Suppress this error with an annotation/attribute",
                ACTION_IGNORE_THIS,
                iconFactory.getImageDescriptor(IGNORE_THIS_ICON),
                iconFactory.getImageDescriptor(IGNORE_THIS_DISABLED_ICON));
        mIgnoreFileAction = new LintViewAction("Ignore in this file", ACTION_IGNORE_FILE,
                iconFactory.getImageDescriptor(IGNORE_FILE_ICON),
                iconFactory.getImageDescriptor(IGNORE_FILE_DISABLED_ICON));
        mIgnoreProjectAction = new LintViewAction("Ignore in this project", ACTION_IGNORE_TYPE,
                iconFactory.getImageDescriptor(IGNORE_PRJ_ICON),
                iconFactory.getImageDescriptor(IGNORE_PRJ_DISABLED_ICON));
        mAlwaysIgnoreAction = new LintViewAction("Always Ignore", ACTION_IGNORE_ALL,
                iconFactory.getImageDescriptor(IGNORE_ALL_ICON),
                iconFactory.getImageDescriptor(IGNORE_ALL_DISABLED_ICON));

        mRemoveAction = new LintViewAction("Remove", ACTION_REMOVE,
                sharedImages.getImageDescriptor(ISharedImages.IMG_ELCL_REMOVE),
                sharedImages.getImageDescriptor(ISharedImages.IMG_ELCL_REMOVE_DISABLED));
        mRemoveAllAction = new LintViewAction("Remove All", ACTION_REMOVE_ALL,
                sharedImages.getImageDescriptor(ISharedImages.IMG_ELCL_REMOVEALL),
                sharedImages.getImageDescriptor(ISharedImages.IMG_ELCL_REMOVEALL_DISABLED));
        mRefreshAction = new LintViewAction("Refresh (& Save Files)", ACTION_REFRESH,
                iconFactory.getImageDescriptor(REFRESH_ICON), null);
        mRemoveAllAction.setEnabled(true);
        mCollapseAll = new LintViewAction("Collapse All", ACTION_COLLAPSE,
                sharedImages.getImageDescriptor(ISharedImages.IMG_ELCL_COLLAPSEALL),
                sharedImages.getImageDescriptor(ISharedImages.IMG_ELCL_COLLAPSEALL_DISABLED));
        mCollapseAll.setEnabled(true);
        mExpandAll = new LintViewAction("Expand All", ACTION_EXPAND,
                iconFactory.getImageDescriptor(EXPAND_ICON),
                iconFactory.getImageDescriptor(EXPAND_DISABLED_ICON));
        mExpandAll.setEnabled(true);

        mConfigureColumns = new LintViewAction("Configure Columns...", ACTION_COLUMNS,
                iconFactory.getImageDescriptor(COLUMNS_ICON),
                null);

        mOptions = new LintViewAction("Options...", ACTION_OPTIONS,
                iconFactory.getImageDescriptor(OPTIONS_ICON),
                null);

        enableActions(Collections.<IMarker>emptyList(), false /*updateWidgets*/);
    }

    /**
     * Initialize the toolbar.
     */
    private void initializeToolBar() {
        IToolBarManager toolbarManager = getViewSite().getActionBars().getToolBarManager();
        toolbarManager.add(mRefreshAction);
        toolbarManager.add(mFixAction);
        toolbarManager.add(mIgnoreAction);
        toolbarManager.add(mIgnoreFileAction);
        toolbarManager.add(mIgnoreProjectAction);
        toolbarManager.add(mAlwaysIgnoreAction);
        toolbarManager.add(new Separator());
        toolbarManager.add(mRemoveAction);
        toolbarManager.add(mRemoveAllAction);
        toolbarManager.add(new Separator());
        toolbarManager.add(mExpandAll);
        toolbarManager.add(mCollapseAll);
        toolbarManager.add(mConfigureColumns);
        toolbarManager.add(mOptions);
    }

    @Override
    public void setFocus() {
        mLintView.setFocus();
    }

    /**
     * Sets the resource associated with the lint view
     *
     * @param resources the associated resources
     */
    public void setResources(List<? extends IResource> resources) {
        mLintView.setResources(resources);

        // Refresh the stop/refresh icon status
        refreshStopIcon();
    }

    private void refreshStopIcon() {
        Job[] currentJobs = LintJob.getCurrentJobs();
        if (currentJobs.length > 0) {
            ISharedImages sharedImages = PlatformUI.getWorkbench().getSharedImages();
            mRefreshAction.setImageDescriptor(sharedImages.getImageDescriptor(
                    ISharedImages.IMG_ELCL_STOP));
            for (Job job : currentJobs) {
                job.addJobChangeListener(this);
            }
        } else {
            mRefreshAction.setImageDescriptor(
                    IconFactory.getInstance().getImageDescriptor(REFRESH_ICON));

        }
    }

    // ---- Implements SelectionListener ----

    @Override
    public void widgetSelected(SelectionEvent e) {
        List<IMarker> markers = mLintView.getSelectedMarkers();
        if (markers.size() != 1) {
            mDetailsText.setText(""); //$NON-NLS-1$
        } else {
            mDetailsText.setText(EclipseLintClient.describe(markers.get(0)));
        }

        IStatusLineManager status = getViewSite().getActionBars().getStatusLineManager();
        status.setMessage(mDetailsText.getText());

        updateIssueCount();

        enableActions(markers, true /* updateWidgets */);
    }

    private void enableActions(List<IMarker> markers, boolean updateWidgets) {
        // Update enabled state of actions
        boolean hasSelection = markers.size() > 0;
        boolean canFix = hasSelection;
        for (IMarker marker : markers) {
            if (!LintFix.hasFix(EclipseLintClient.getId(marker))) {
                canFix = false;
                break;
            }

            // Some fixes cannot be run in bulk
            if (markers.size() > 1) {
                List<LintFix> fixes = LintFix.getFixes(EclipseLintClient.getId(marker), marker);
                if (fixes == null || !fixes.get(0).isBulkCapable()) {
                    canFix = false;
                    break;
                }
            }
        }

        boolean haveFile = false;
        boolean isJavaOrXml = true;
        for (IMarker marker : markers) {
            IResource resource = marker.getResource();
            if (resource instanceof IFile || resource instanceof IFolder) {
                haveFile = true;
                String name = resource.getName();
                if (!LintUtils.endsWith(name, DOT_XML) && !LintUtils.endsWith(name, DOT_JAVA)) {
                    isJavaOrXml = false;
                }
                break;
            }
        }

        mFixAction.setEnabled(canFix);
        mIgnoreAction.setEnabled(hasSelection && haveFile && isJavaOrXml);
        mIgnoreFileAction.setEnabled(hasSelection && haveFile);
        mIgnoreProjectAction.setEnabled(hasSelection);
        mAlwaysIgnoreAction.setEnabled(hasSelection);
        mRemoveAction.setEnabled(hasSelection);

        if (updateWidgets) {
            getViewSite().getActionBars().getToolBarManager().update(false);
        }
    }

    @Override
    public void widgetDefaultSelected(SelectionEvent e) {
        Object source = e.getSource();
        if (source == mLintView.getTreeViewer().getControl()) {
            // Jump to editor
            List<IMarker> selection = mLintView.getSelectedMarkers();
            if (selection.size() > 0) {
                EclipseLintClient.showMarker(selection.get(0));
            }
        }
    }

    // --- Implements IJobChangeListener ----

    @Override
    public void done(IJobChangeEvent event) {
        mRefreshAction.setImageDescriptor(
                IconFactory.getInstance().getImageDescriptor(REFRESH_ICON));

        if (!mLintView.isDisposed()) {
            mLintView.getDisplay().asyncExec(new Runnable()  {
                @Override
                public void run() {
                    if (!mLintView.isDisposed()) {
                        updateIssueCount();
                    }
                }
            });
        }
    }

    private void updateIssueCount() {
        int errors = mLintView.getErrorCount();
        int warnings = mLintView.getWarningCount();
        mErrorLabel.setText(String.format("%1$d errors, %2$d warnings", errors, warnings));
    }

    @Override
    public void aboutToRun(IJobChangeEvent event) {
    }

    @Override
    public void awake(IJobChangeEvent event) {
    }

    @Override
    public void running(IJobChangeEvent event) {
    }

    @Override
    public void scheduled(IJobChangeEvent event) {
    }

    @Override
    public void sleeping(IJobChangeEvent event) {
    }

    // ---- Actions ----

    private static final int ACTION_REFRESH = 1;
    private static final int ACTION_FIX = 2;
    private static final int ACTION_IGNORE_THIS = 3;
    private static final int ACTION_IGNORE_FILE = 4;
    private static final int ACTION_IGNORE_TYPE = 5;
    private static final int ACTION_IGNORE_ALL = 6;
    private static final int ACTION_REMOVE = 7;
    private static final int ACTION_REMOVE_ALL = 8;
    private static final int ACTION_COLLAPSE = 9;
    private static final int ACTION_EXPAND = 10;
    private static final int ACTION_COLUMNS = 11;
    private static final int ACTION_OPTIONS = 12;

    private class LintViewAction extends Action {

        private final int mAction;

        private LintViewAction(String label, int action,
                ImageDescriptor imageDesc, ImageDescriptor disabledImageDesc) {
            super(label);
            mAction = action;
            setImageDescriptor(imageDesc);
            if (disabledImageDesc != null) {
                setDisabledImageDescriptor(disabledImageDesc);
            }
        }

        @Override
        public void run() {
            switch (mAction) {
                case ACTION_REFRESH: {
                    IWorkbench workbench = PlatformUI.getWorkbench();
                    if (workbench != null) {
                        workbench.saveAllEditors(false /*confirm*/);
                    }

                    Job[] jobs = LintJob.getCurrentJobs();
                    if (jobs.length > 0) {
                        EclipseLintRunner.cancelCurrentJobs(false);
                    } else {
                        List<? extends IResource> resources = mLintView.getResources();
                        if (resources == null) {
                            return;
                        }
                        Job job = EclipseLintRunner.startLint(resources, null, null,
                                false /*fatalOnly*/, false /*show*/);
                        if (job != null && workbench != null) {
                            job.addJobChangeListener(LintViewPart.this);
                            ISharedImages sharedImages = workbench.getSharedImages();
                            setImageDescriptor(sharedImages.getImageDescriptor(
                                    ISharedImages.IMG_ELCL_STOP));
                        }
                    }
                    break;
                }
                case ACTION_FIX: {
                    List<IMarker> markers = mLintView.getSelectedMarkers();
                    for (IMarker marker : markers) {
                        List<LintFix> fixes = LintFix.getFixes(EclipseLintClient.getId(marker),
                                marker);
                        if (fixes == null) {
                            continue;
                        }
                        LintFix fix = fixes.get(0);
                        IResource resource = marker.getResource();
                        if (fix.needsFocus() && resource instanceof IFile) {
                            IRegion region = null;
                            try {
                                int start = marker.getAttribute(IMarker.CHAR_START, -1);
                                int end = marker.getAttribute(IMarker.CHAR_END, -1);
                                if (start != -1) {
                                    region = new Region(start, end - start);
                                }
                                AdtPlugin.openFile((IFile) resource, region);
                            } catch (PartInitException e) {
                                AdtPlugin.log(e, "Can't open file %1$s", resource);
                            }
                        }
                        IDocumentProvider provider = new TextFileDocumentProvider();
                        try {
                            provider.connect(resource);
                            IDocument document = provider.getDocument(resource);
                            if (document != null) {
                                fix.apply(document);
                                if (!fix.needsFocus()) {
                                    provider.saveDocument(new NullProgressMonitor(), resource,
                                            document,  true /*overwrite*/);
                                }
                            }
                        } catch (Exception e) {
                            AdtPlugin.log(e, "Did not find associated editor to apply fix: %1$s",
                                    resource.getName());
                        } finally {
                            provider.disconnect(resource);
                        }
                    }
                    break;
                }
                case ACTION_REMOVE: {
                    for (IMarker marker : mLintView.getSelectedMarkers()) {
                        try {
                            marker.delete();
                        } catch (CoreException e) {
                            AdtPlugin.log(e, null);
                        }
                    }
                    break;
                }
                case ACTION_REMOVE_ALL: {
                    List<? extends IResource> resources = mLintView.getResources();
                    if (resources != null) {
                        for (IResource resource : resources) {
                            EclipseLintClient.clearMarkers(resource);
                        }
                    }
                    break;
                }
                case ACTION_IGNORE_ALL:
                    assert false;
                    break;
                case ACTION_IGNORE_TYPE:
                case ACTION_IGNORE_FILE: {
                    boolean ignoreInFile = mAction == ACTION_IGNORE_FILE;
                    for (IMarker marker : mLintView.getSelectedMarkers()) {
                        String id = EclipseLintClient.getId(marker);
                        if (id != null) {
                            IResource resource = marker.getResource();
                            LintFixGenerator.suppressDetector(id, true,
                                    ignoreInFile ? resource : resource.getProject(),
                                    ignoreInFile);
                        }
                    }
                    break;
                }
                case ACTION_IGNORE_THIS: {
                    for (IMarker marker : mLintView.getSelectedMarkers()) {
                        LintFixGenerator.addSuppressAnnotation(marker);
                    }
                    break;
                }
                case ACTION_COLLAPSE: {
                    mLintView.collapseAll();
                    break;
                }
                case ACTION_EXPAND: {
                    mLintView.expandAll();
                    break;
                }
                case ACTION_COLUMNS: {
                    mLintView.configureColumns();
                    break;
                }
                case ACTION_OPTIONS: {
                    PreferenceManager manager = new PreferenceManager();

                    LintPreferencePage page = new LintPreferencePage();
                    String title = "Default/Global Settings";
                    page.setTitle(title);
                    IPreferenceNode node = new PreferenceNode(title, page);
                    manager.addToRoot(node);


                    List<? extends IResource> resources = mLintView.getResources();
                    if (resources != null) {
                        Set<IProject> projects = new HashSet<IProject>();
                        for (IResource resource : resources) {
                            projects.add(resource.getProject());
                        }
                        if (projects.size() > 0) {
                            for (IProject project : projects) {
                                page = new LintPreferencePage();
                                page.setTitle(String.format("Settings for %1$s",
                                        project.getName()));
                                page.setElement(project);
                                node = new PreferenceNode(project.getName(), page);
                                manager.addToRoot(node);
                            }
                        }
                    }

                    Shell shell = LintViewPart.this.getSite().getShell();
                    PreferenceDialog dialog = new PreferenceDialog(shell, manager);
                    dialog.create();
                    dialog.setSelectedNode(title);
                    dialog.open();
                    break;
                }
                default:
                    assert false : mAction;
            }
            updateIssueCount();
        }
    }

    /**
     * Shows or reconfigures the LintView to show the lint warnings for the
     * given project
     *
     * @param projects the projects to show lint warnings for
     */
    public static void show(List<? extends IResource> projects) {
        IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
        if (window != null) {
            IWorkbenchPage page = window.getActivePage();
            if (page != null) {
                try {
                    // Pass initial project context via static field read by constructor
                    sInitialResources = projects;
                    IViewPart view = page.showView(LintViewPart.ID, null,
                            IWorkbenchPage.VIEW_ACTIVATE);
                    if (sInitialResources != null && view instanceof LintViewPart) {
                        // The view must be showing already since the constructor was not
                        // run, so reconfigure the view instead
                        LintViewPart lintView = (LintViewPart) view;
                        lintView.setResources(projects);
                    }
                } catch (PartInitException e) {
                    AdtPlugin.log(e, "Cannot open Lint View");
                } finally {
                    sInitialResources = null;
                }
            }
        }
    }
}