/*
 * Copyright (C) 2012 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.editors.layout.gle2;

import static com.android.SdkConstants.ANDROID_STYLE_RESOURCE_PREFIX;
import static com.android.SdkConstants.PREFIX_RESOURCE_REF;
import static com.android.SdkConstants.STYLE_RESOURCE_PREFIX;
import static com.android.ide.eclipse.adt.internal.editors.layout.configuration.Configuration.MASK_RENDERING;
import static com.android.ide.eclipse.adt.internal.editors.layout.gle2.ImageUtils.SHADOW_SIZE;
import static com.android.ide.eclipse.adt.internal.editors.layout.gle2.ImageUtils.SMALL_SHADOW_SIZE;
import static com.android.ide.eclipse.adt.internal.editors.layout.gle2.RenderPreviewMode.DEFAULT;
import static com.android.ide.eclipse.adt.internal.editors.layout.gle2.RenderPreviewMode.INCLUDES;

import com.android.annotations.NonNull;
import com.android.annotations.Nullable;
import com.android.ide.common.rendering.api.RenderSession;
import com.android.ide.common.rendering.api.ResourceValue;
import com.android.ide.common.rendering.api.Result;
import com.android.ide.common.rendering.api.Result.Status;
import com.android.ide.common.resources.ResourceFile;
import com.android.ide.common.resources.ResourceRepository;
import com.android.ide.common.resources.ResourceResolver;
import com.android.ide.common.resources.configuration.FolderConfiguration;
import com.android.ide.common.resources.configuration.ScreenOrientationQualifier;
import com.android.ide.eclipse.adt.AdtPlugin;
import com.android.ide.eclipse.adt.AdtUtils;
import com.android.ide.eclipse.adt.internal.editors.IconFactory;
import com.android.ide.eclipse.adt.internal.editors.descriptors.DocumentDescriptor;
import com.android.ide.eclipse.adt.internal.editors.layout.configuration.Configuration;
import com.android.ide.eclipse.adt.internal.editors.layout.configuration.ConfigurationChooser;
import com.android.ide.eclipse.adt.internal.editors.layout.configuration.ConfigurationClient;
import com.android.ide.eclipse.adt.internal.editors.layout.configuration.ConfigurationDescription;
import com.android.ide.eclipse.adt.internal.editors.layout.configuration.Locale;
import com.android.ide.eclipse.adt.internal.editors.layout.configuration.NestedConfiguration;
import com.android.ide.eclipse.adt.internal.editors.layout.configuration.VaryingConfiguration;
import com.android.ide.eclipse.adt.internal.editors.layout.gle2.IncludeFinder.Reference;
import com.android.ide.eclipse.adt.internal.editors.uimodel.UiDocumentNode;
import com.android.ide.eclipse.adt.internal.resources.ResourceHelper;
import com.android.ide.eclipse.adt.internal.resources.manager.ProjectResources;
import com.android.ide.eclipse.adt.internal.resources.manager.ResourceManager;
import com.android.ide.eclipse.adt.internal.sdk.AndroidTargetData;
import com.android.ide.eclipse.adt.internal.sdk.Sdk;
import com.android.ide.eclipse.adt.io.IFileWrapper;
import com.android.io.IAbstractFile;
import com.android.resources.Density;
import com.android.resources.ResourceType;
import com.android.resources.ScreenOrientation;
import com.android.sdklib.IAndroidTarget;
import com.android.sdklib.devices.Device;
import com.android.sdklib.devices.Screen;
import com.android.sdklib.devices.State;
import com.android.utils.SdkUtils;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.jobs.IJobChangeEvent;
import org.eclipse.core.runtime.jobs.IJobChangeListener;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.jface.dialogs.InputDialog;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Region;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.progress.UIJob;
import org.w3c.dom.Document;

import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.lang.ref.SoftReference;
import java.util.Comparator;
import java.util.Map;

/**
 * Represents a preview rendering of a given configuration
 */
public class RenderPreview implements IJobChangeListener {
    /** Whether previews should use large shadows */
    static final boolean LARGE_SHADOWS = false;

    /**
     * Still doesn't work; get exceptions from layoutlib:
     * java.lang.IllegalStateException: After scene creation, #init() must be called
     *   at com.android.layoutlib.bridge.impl.RenderAction.acquire(RenderAction.java:151)
     * <p>
     * TODO: Investigate.
     */
    private static final boolean RENDER_ASYNC = false;

    /**
     * Height of the toolbar shown over a preview during hover. Needs to be
     * large enough to accommodate icons below.
     */
    private static final int HEADER_HEIGHT = 20;

    /** Whether to dump out rendering failures of the previews to the log */
    private static final boolean DUMP_RENDER_DIAGNOSTICS = false;

    /** Extra error checking in debug mode */
    private static final boolean DEBUG = false;

    private static final Image EDIT_ICON;
    private static final Image ZOOM_IN_ICON;
    private static final Image ZOOM_OUT_ICON;
    private static final Image CLOSE_ICON;
    private static final int EDIT_ICON_WIDTH;
    private static final int ZOOM_IN_ICON_WIDTH;
    private static final int ZOOM_OUT_ICON_WIDTH;
    private static final int CLOSE_ICON_WIDTH;
    static {
        ISharedImages sharedImages = PlatformUI.getWorkbench().getSharedImages();
        IconFactory icons = IconFactory.getInstance();
        CLOSE_ICON = sharedImages.getImage(ISharedImages.IMG_ETOOL_DELETE);
        EDIT_ICON = icons.getIcon("editPreview");   //$NON-NLS-1$
        ZOOM_IN_ICON = icons.getIcon("zoomplus");   //$NON-NLS-1$
        ZOOM_OUT_ICON = icons.getIcon("zoomminus"); //$NON-NLS-1$
        CLOSE_ICON_WIDTH = CLOSE_ICON.getImageData().width;
        EDIT_ICON_WIDTH = EDIT_ICON.getImageData().width;
        ZOOM_IN_ICON_WIDTH = ZOOM_IN_ICON.getImageData().width;
        ZOOM_OUT_ICON_WIDTH = ZOOM_OUT_ICON.getImageData().width;
    }

    /** The configuration being previewed */
    private @NonNull Configuration mConfiguration;

    /** Configuration to use if we have an alternate input to be rendered */
    private @NonNull Configuration mAlternateConfiguration;

    /** The associated manager */
    private final @NonNull RenderPreviewManager mManager;
    private final @NonNull LayoutCanvas mCanvas;

    private @NonNull SoftReference<ResourceResolver> mResourceResolver =
            new SoftReference<ResourceResolver>(null);
    private @Nullable Job mJob;
    private @Nullable Image mThumbnail;
    private @Nullable String mDisplayName;
    private int mWidth;
    private int mHeight;
    private int mX;
    private int mY;
    private int mTitleHeight;
    private double mScale = 1.0;
    private double mAspectRatio;

    /** If non null, points to a separate file containing the source */
    private @Nullable IFile mAlternateInput;

    /** If included within another layout, the name of that outer layout */
    private @Nullable Reference mIncludedWithin;

    /** Whether the mouse is actively hovering over this preview */
    private boolean mActive;

    /**
     * Whether this preview cannot be rendered because of a model error - such
     * as an invalid configuration, a missing resource, an error in the XML
     * markup, etc. If non null, contains the error message (or a blank string
     * if not known), and null if the render was successful.
     */
    private String mError;

    /** Whether in the current layout, this preview is visible */
    private boolean mVisible;

    /** Whether the configuration has changed and needs to be refreshed the next time
     * this preview made visible. This corresponds to the change flags in
     * {@link ConfigurationClient}. */
    private int mDirty;

    /**
     * Creates a new {@linkplain RenderPreview}
     *
     * @param manager the manager
     * @param canvas canvas where preview is painted
     * @param configuration the associated configuration
     * @param width the initial width to use for the preview
     * @param height the initial height to use for the preview
     */
    private RenderPreview(
            @NonNull RenderPreviewManager manager,
            @NonNull LayoutCanvas canvas,
            @NonNull Configuration configuration) {
        mManager = manager;
        mCanvas = canvas;
        mConfiguration = configuration;
        updateSize();

        // Should only attempt to create configurations for fully configured devices
        assert mConfiguration.getDevice() != null
                && mConfiguration.getDeviceState() != null
                && mConfiguration.getLocale() != null
                && mConfiguration.getTarget() != null
                && mConfiguration.getTheme() != null
                && mConfiguration.getFullConfig() != null
                && mConfiguration.getFullConfig().getScreenSizeQualifier() != null :
                    mConfiguration;
    }

    /**
     * Sets the configuration to use for this preview
     *
     * @param configuration the new configuration
     */
    public void setConfiguration(@NonNull Configuration configuration) {
        mConfiguration = configuration;
    }

    /**
     * Gets the scale being applied to the thumbnail
     *
     * @return the scale being applied to the thumbnail
     */
    public double getScale() {
        return mScale;
    }

    /**
     * Sets the scale to apply to the thumbnail
     *
     * @param scale the factor to scale the thumbnail picture by
     */
    public void setScale(double scale) {
        disposeThumbnail();
        mScale = scale;
    }

    /**
     * Returns the aspect ratio of this render preview
     *
     * @return the aspect ratio
     */
    public double getAspectRatio() {
        return mAspectRatio;
    }

    /**
     * Returns whether the preview is actively hovered
     *
     * @return whether the mouse is hovering over the preview
     */
    public boolean isActive() {
        return mActive;
    }

    /**
     * Sets whether the preview is actively hovered
     *
     * @param active if the mouse is hovering over the preview
     */
    public void setActive(boolean active) {
        mActive = active;
    }

    /**
     * Returns whether the preview is visible. Previews that are off
     * screen are typically marked invisible during layout, which means we don't
     * have to expend effort computing preview thumbnails etc
     *
     * @return true if the preview is visible
     */
    public boolean isVisible() {
        return mVisible;
    }

    /**
     * Returns whether this preview represents a forked layout
     *
     * @return true if this preview represents a separate file
     */
    public boolean isForked() {
        return mAlternateInput != null || mIncludedWithin != null;
    }

    /**
     * Returns the file to be used for this preview, or null if this is not a
     * forked layout meaning that the file is the one used in the chooser
     *
     * @return the file or null for non-forked layouts
     */
    @Nullable
    public IFile getAlternateInput() {
        if (mAlternateInput != null) {
            return mAlternateInput;
        } else if (mIncludedWithin != null) {
            return mIncludedWithin.getFile();
        }

        return null;
    }

    /**
     * Returns the area of this render preview, PRIOR to scaling
     *
     * @return the area (width times height without scaling)
     */
    int getArea() {
        return mWidth * mHeight;
    }

    /**
     * Sets whether the preview is visible. Previews that are off
     * screen are typically marked invisible during layout, which means we don't
     * have to expend effort computing preview thumbnails etc
     *
     * @param visible whether this preview is visible
     */
    public void setVisible(boolean visible) {
        if (visible != mVisible) {
            mVisible = visible;
            if (mVisible) {
                if (mDirty != 0) {
                    // Just made the render preview visible:
                    configurationChanged(mDirty); // schedules render
                } else {
                    updateForkStatus();
                    mManager.scheduleRender(this);
                }
            } else {
                dispose();
            }
        }
    }

    /**
     * Sets the layout position relative to the top left corner of the preview
     * area, in control coordinates
     */
    void setPosition(int x, int y) {
        mX = x;
        mY = y;
    }

    /**
     * Gets the layout X position relative to the top left corner of the preview
     * area, in control coordinates
     */
    int getX() {
        return mX;
    }

    /**
     * Gets the layout Y position relative to the top left corner of the preview
     * area, in control coordinates
     */
    int getY() {
        return mY;
    }

    /** Determine whether this configuration has a better match in a different layout file */
    private void updateForkStatus() {
        ConfigurationChooser chooser = mManager.getChooser();
        FolderConfiguration config = mConfiguration.getFullConfig();
        if (mAlternateInput != null && chooser.isBestMatchFor(mAlternateInput, config)) {
            return;
        }

        mAlternateInput = null;
        IFile editedFile = chooser.getEditedFile();
        if (editedFile != null) {
            if (!chooser.isBestMatchFor(editedFile, config)) {
                ProjectResources resources = chooser.getResources();
                if (resources != null) {
                    ResourceFile best = resources.getMatchingFile(editedFile.getName(),
                            ResourceType.LAYOUT, config);
                    if (best != null) {
                        IAbstractFile file = best.getFile();
                        if (file instanceof IFileWrapper) {
                            mAlternateInput = ((IFileWrapper) file).getIFile();
                        } else if (file instanceof File) {
                            mAlternateInput = AdtUtils.fileToIFile(((File) file));
                        }
                    }
                }
                if (mAlternateInput != null) {
                    mAlternateConfiguration = Configuration.create(mConfiguration,
                            mAlternateInput);
                }
            }
        }
    }

    /**
     * Creates a new {@linkplain RenderPreview}
     *
     * @param manager the manager
     * @param configuration the associated configuration
     * @return a new configuration
     */
    @NonNull
    public static RenderPreview create(
            @NonNull RenderPreviewManager manager,
            @NonNull Configuration configuration) {
        LayoutCanvas canvas = manager.getCanvas();
        return new RenderPreview(manager, canvas, configuration);
    }

    /**
     * Throws away this preview: cancels any pending rendering jobs and disposes
     * of image resources etc
     */
    public void dispose() {
        disposeThumbnail();

        if (mJob != null) {
            mJob.cancel();
            mJob = null;
        }
    }

    /** Disposes the thumbnail rendering. */
    void disposeThumbnail() {
        if (mThumbnail != null) {
            mThumbnail.dispose();
            mThumbnail = null;
        }
    }

    /**
     * Returns the display name of this preview
     *
     * @return the name of the preview
     */
    @NonNull
    public String getDisplayName() {
        if (mDisplayName == null) {
            String displayName = getConfiguration().getDisplayName();
            if (displayName == null) {
                // No display name: this must be the configuration used by default
                // for the view which is originally displayed (before adding thumbnails),
                // and you've switched away to something else; now we need to display a name
                // for this original configuration. For now, just call it "Original"
                return "Original";
            }

            return displayName;
        }

        return mDisplayName;
    }

    /**
     * Sets the display name of this preview. By default, the display name is
     * the display name of the configuration, but it can be overridden by calling
     * this setter (which only sets the preview name, without editing the configuration.)
     *
     * @param displayName the new display name
     */
    public void setDisplayName(@NonNull String displayName) {
        mDisplayName = displayName;
    }

    /**
     * Sets an inclusion context to use for this layout, if any. This will render
     * the configuration preview as the outer layout with the current layout
     * embedded within.
     *
     * @param includedWithin a reference to a layout which includes this one
     */
    public void setIncludedWithin(Reference includedWithin) {
        mIncludedWithin = includedWithin;
    }

    /**
     * Request a new render after the given delay
     *
     * @param delay the delay to wait before starting the render job
     */
    public void render(long delay) {
        Job job = mJob;
        if (job != null) {
            job.cancel();
        }
        if (RENDER_ASYNC) {
            job = new AsyncRenderJob();
        } else {
            job = new RenderJob();
        }
        job.schedule(delay);
        job.addJobChangeListener(this);
        mJob = job;
    }

    /** Render immediately */
    private void renderSync() {
        GraphicalEditorPart editor = mCanvas.getEditorDelegate().getGraphicalEditor();
        if (editor.getReadyLayoutLib(false /*displayError*/) == null) {
            // Don't attempt to render when there is no ready layout library: most likely
            // the targets are loading/reloading.
            return;
        }

        disposeThumbnail();

        Configuration configuration =
                mAlternateInput != null && mAlternateConfiguration != null
                ? mAlternateConfiguration : mConfiguration;
        ResourceResolver resolver = getResourceResolver(configuration);
        RenderService renderService = RenderService.create(editor, configuration, resolver);

        if (mIncludedWithin != null) {
            renderService.setIncludedWithin(mIncludedWithin);
        }

        if (mAlternateInput != null) {
            IAndroidTarget target = editor.getRenderingTarget();
            AndroidTargetData data = null;
            if (target != null) {
                Sdk sdk = Sdk.getCurrent();
                if (sdk != null) {
                    data = sdk.getTargetData(target);
                }
            }

            // Construct UI model from XML
            DocumentDescriptor documentDescriptor;
            if (data == null) {
                documentDescriptor = new DocumentDescriptor("temp", null);//$NON-NLS-1$
            } else {
                documentDescriptor = data.getLayoutDescriptors().getDescriptor();
            }
            UiDocumentNode model = (UiDocumentNode) documentDescriptor.createUiNode();
            model.setEditor(mCanvas.getEditorDelegate().getEditor());
            model.setUnknownDescriptorProvider(editor.getModel().getUnknownDescriptorProvider());

            Document document = DomUtilities.getDocument(mAlternateInput);
            if (document == null) {
                mError = "No document";
                createErrorThumbnail();
                return;
            }
            model.loadFromXmlNode(document);
            renderService.setModel(model);
        } else {
            renderService.setModel(editor.getModel());
        }
        RenderLogger log = editor.createRenderLogger(getDisplayName());
        renderService.setLog(log);
        RenderSession session = renderService.createRenderSession();
        Result render = session.render(1000);

        if (DUMP_RENDER_DIAGNOSTICS) {
            if (log.hasProblems() || !render.isSuccess()) {
                AdtPlugin.log(IStatus.ERROR, "Found problems rendering preview "
                        + getDisplayName() + ": "
                        + render.getErrorMessage() + " : "
                        + log.getProblems(false));
                Throwable exception = render.getException();
                if (exception != null) {
                    AdtPlugin.log(exception, "Failure rendering preview " + getDisplayName());
                }
            }
        }

        if (render.isSuccess()) {
            mError = null;
        } else {
            mError = render.getErrorMessage();
            if (mError == null) {
                mError = "";
            }
        }

        if (render.getStatus() == Status.ERROR_TIMEOUT) {
            // TODO: Special handling? schedule update again later
            return;
        }
        if (render.isSuccess()) {
            BufferedImage image = session.getImage();
            if (image != null) {
                createThumbnail(image);
            }
        }

        if (mError != null) {
            createErrorThumbnail();
        }
    }

    private ResourceResolver getResourceResolver(Configuration configuration) {
        ResourceResolver resourceResolver = mResourceResolver.get();
        if (resourceResolver != null) {
            return resourceResolver;
        }

        GraphicalEditorPart graphicalEditor = mCanvas.getEditorDelegate().getGraphicalEditor();
        String theme = configuration.getTheme();
        if (theme == null) {
            return null;
        }

        Map<ResourceType, Map<String, ResourceValue>> configuredFrameworkRes = null;
        Map<ResourceType, Map<String, ResourceValue>> configuredProjectRes = null;

        FolderConfiguration config = configuration.getFullConfig();
        IAndroidTarget target = graphicalEditor.getRenderingTarget();
        ResourceRepository frameworkRes = null;
        if (target != null) {
            Sdk sdk = Sdk.getCurrent();
            if (sdk == null) {
                return null;
            }
            AndroidTargetData data = sdk.getTargetData(target);

            if (data != null) {
                // TODO: SHARE if possible
                frameworkRes = data.getFrameworkResources();
                configuredFrameworkRes = frameworkRes.getConfiguredResources(config);
            } else {
                return null;
            }
        } else {
            return null;
        }
        assert configuredFrameworkRes != null;


        // get the resources of the file's project.
        ProjectResources projectRes = ResourceManager.getInstance().getProjectResources(
                graphicalEditor.getProject());
        configuredProjectRes = projectRes.getConfiguredResources(config);

        if (!theme.startsWith(PREFIX_RESOURCE_REF)) {
            if (frameworkRes.hasResourceItem(ANDROID_STYLE_RESOURCE_PREFIX + theme)) {
                theme = ANDROID_STYLE_RESOURCE_PREFIX + theme;
            } else {
                theme = STYLE_RESOURCE_PREFIX + theme;
            }
        }

        resourceResolver = ResourceResolver.create(
                configuredProjectRes, configuredFrameworkRes,
                ResourceHelper.styleToTheme(theme),
                ResourceHelper.isProjectStyle(theme));
        mResourceResolver = new SoftReference<ResourceResolver>(resourceResolver);
        return resourceResolver;
    }

    /**
     * Sets the new image of the preview and generates a thumbnail
     *
     * @param image the full size image
     */
    void createThumbnail(BufferedImage image) {
        if (image == null) {
            mThumbnail = null;
            return;
        }

        ImageOverlay imageOverlay = mCanvas.getImageOverlay();
        boolean drawShadows = imageOverlay == null || imageOverlay.getShowDropShadow();
        double scale = getWidth() / (double) image.getWidth();
        int shadowSize;
        if (LARGE_SHADOWS) {
            shadowSize = drawShadows ? SHADOW_SIZE : 0;
        } else {
            shadowSize = drawShadows ? SMALL_SHADOW_SIZE : 0;
        }
        if (scale < 1.0) {
            if (LARGE_SHADOWS) {
                image = ImageUtils.scale(image, scale, scale,
                        shadowSize, shadowSize);
                if (drawShadows) {
                    ImageUtils.drawRectangleShadow(image, 0, 0,
                            image.getWidth() - shadowSize,
                            image.getHeight() - shadowSize);
                }
            } else {
                image = ImageUtils.scale(image, scale, scale,
                        shadowSize, shadowSize);
                if (drawShadows) {
                    ImageUtils.drawSmallRectangleShadow(image, 0, 0,
                            image.getWidth() - shadowSize,
                            image.getHeight() - shadowSize);
                }
            }
        }

        mThumbnail = SwtUtils.convertToSwt(mCanvas.getDisplay(), image,
                true /* transferAlpha */, -1);
    }

    void createErrorThumbnail() {
        int shadowSize = LARGE_SHADOWS ? SHADOW_SIZE : SMALL_SHADOW_SIZE;
        int width = getWidth();
        int height = getHeight();
        BufferedImage image = new BufferedImage(width + shadowSize, height + shadowSize,
                BufferedImage.TYPE_INT_ARGB);

        Graphics2D g = image.createGraphics();
        g.setColor(new java.awt.Color(0xfffbfcc6));
        g.fillRect(0, 0, width, height);

        g.dispose();

        ImageOverlay imageOverlay = mCanvas.getImageOverlay();
        boolean drawShadows = imageOverlay == null || imageOverlay.getShowDropShadow();
        if (drawShadows) {
            if (LARGE_SHADOWS) {
                ImageUtils.drawRectangleShadow(image, 0, 0,
                        image.getWidth() - SHADOW_SIZE,
                        image.getHeight() - SHADOW_SIZE);
            } else {
                ImageUtils.drawSmallRectangleShadow(image, 0, 0,
                        image.getWidth() - SMALL_SHADOW_SIZE,
                        image.getHeight() - SMALL_SHADOW_SIZE);
            }
        }

        mThumbnail = SwtUtils.convertToSwt(mCanvas.getDisplay(), image,
                true /* transferAlpha */, -1);
    }

    private static double getScale(int width, int height) {
        int maxWidth = RenderPreviewManager.getMaxWidth();
        int maxHeight = RenderPreviewManager.getMaxHeight();
        if (width > 0 && height > 0
                && (width > maxWidth || height > maxHeight)) {
            if (width >= height) { // landscape
                return maxWidth / (double) width;
            } else { // portrait
                return maxHeight / (double) height;
            }
        }

        return 1.0;
    }

    /**
     * Returns the width of the preview, in pixels
     *
     * @return the width in pixels
     */
    public int getWidth() {
        return (int) (mWidth * mScale * RenderPreviewManager.getScale());
    }

    /**
     * Returns the height of the preview, in pixels
     *
     * @return the height in pixels
     */
    public int getHeight() {
        return (int) (mHeight * mScale * RenderPreviewManager.getScale());
    }

    /**
     * Handles clicks within the preview (x and y are positions relative within the
     * preview
     *
     * @param x the x coordinate within the preview where the click occurred
     * @param y the y coordinate within the preview where the click occurred
     * @return true if this preview handled (and therefore consumed) the click
     */
    public boolean click(int x, int y) {
        if (y >= mTitleHeight && y < mTitleHeight + HEADER_HEIGHT) {
            int left = 0;
            left += CLOSE_ICON_WIDTH;
            if (x <= left) {
                // Delete
                mManager.deletePreview(this);
                return true;
            }
            left += ZOOM_IN_ICON_WIDTH;
            if (x <= left) {
                // Zoom in
                mScale = mScale * (1 / 0.5);
                if (Math.abs(mScale-1.0) < 0.0001) {
                    mScale = 1.0;
                }

                render(0);
                mManager.layout(true);
                mCanvas.redraw();
                return true;
            }
            left += ZOOM_OUT_ICON_WIDTH;
            if (x <= left) {
                // Zoom out
                mScale = mScale * (0.5 / 1);
                if (Math.abs(mScale-1.0) < 0.0001) {
                    mScale = 1.0;
                }
                render(0);

                mManager.layout(true);
                mCanvas.redraw();
                return true;
            }
            left += EDIT_ICON_WIDTH;
            if (x <= left) {
                // Edit. For now, just rename
                InputDialog d = new InputDialog(
                        AdtPlugin.getShell(),
                        "Rename Preview",  // title
                        "Name:",
                        getDisplayName(),
                        null);
                if (d.open() == Window.OK) {
                    String newName = d.getValue();
                    mConfiguration.setDisplayName(newName);
                    if (mDescription != null) {
                        mManager.rename(mDescription, newName);
                    }
                    mCanvas.redraw();
                }

                return true;
            }

            // Clicked anywhere else on header
            // Perhaps open Edit dialog here?
        }

        mManager.switchTo(this);
        return true;
    }

    /**
     * Paints the preview at the given x/y position
     *
     * @param gc the graphics context to paint it into
     * @param x the x coordinate to paint the preview at
     * @param y the y coordinate to paint the preview at
     */
    void paint(GC gc, int x, int y) {
        mTitleHeight = paintTitle(gc, x, y, true /*showFile*/);
        y += mTitleHeight;
        y += 2;

        int width = getWidth();
        int height = getHeight();
        if (mThumbnail != null && mError == null) {
            gc.drawImage(mThumbnail, x, y);

            if (mActive) {
                int oldWidth = gc.getLineWidth();
                gc.setLineWidth(3);
                gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_LIST_SELECTION));
                gc.drawRectangle(x - 1, y - 1, width + 2, height + 2);
                gc.setLineWidth(oldWidth);
            }
        } else if (mError != null) {
            if (mThumbnail != null) {
                gc.drawImage(mThumbnail, x, y);
            } else {
                gc.setBackground(gc.getDevice().getSystemColor(SWT.COLOR_WIDGET_BORDER));
                gc.drawRectangle(x, y, width, height);
            }

            gc.setClipping(x, y, width, height);
            Image icon = IconFactory.getInstance().getIcon("renderError"); //$NON-NLS-1$
            ImageData data = icon.getImageData();
            int prevAlpha = gc.getAlpha();
            int alpha = 96;
            if (mThumbnail != null) {
                alpha -= 32;
            }
            gc.setAlpha(alpha);
            gc.drawImage(icon, x + (width - data.width) / 2, y + (height - data.height) / 2);

            String msg = mError;
            Density density = mConfiguration.getDensity();
            if (density == Density.TV || density == Density.LOW) {
                msg = "Broken rendering library; unsupported DPI. Try using the SDK manager " +
                        "to get updated layout libraries.";
            }
            int charWidth = gc.getFontMetrics().getAverageCharWidth();
            int charsPerLine = (width - 10) / charWidth;
            msg = SdkUtils.wrap(msg, charsPerLine, null);
            gc.setAlpha(255);
            gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_BLACK));
            gc.drawText(msg, x + 5, y + HEADER_HEIGHT, true);
            gc.setAlpha(prevAlpha);
            gc.setClipping((Region) null);
        } else {
            gc.setBackground(gc.getDevice().getSystemColor(SWT.COLOR_WIDGET_BORDER));
            gc.drawRectangle(x, y, width, height);

            Image icon = IconFactory.getInstance().getIcon("refreshPreview"); //$NON-NLS-1$
            ImageData data = icon.getImageData();
            int prevAlpha = gc.getAlpha();
            gc.setAlpha(96);
            gc.drawImage(icon, x + (width - data.width) / 2,
                    y + (height - data.height) / 2);
            gc.setAlpha(prevAlpha);
        }

        if (mActive) {
            int left = x ;
            int prevAlpha = gc.getAlpha();
            gc.setAlpha(208);
            Color bg = mCanvas.getDisplay().getSystemColor(SWT.COLOR_WHITE);
            gc.setBackground(bg);
            gc.fillRectangle(left, y, x + width - left, HEADER_HEIGHT);
            gc.setAlpha(prevAlpha);

            y += 2;

            // Paint icons
            gc.drawImage(CLOSE_ICON, left, y);
            left += CLOSE_ICON_WIDTH;

            gc.drawImage(ZOOM_IN_ICON, left, y);
            left += ZOOM_IN_ICON_WIDTH;

            gc.drawImage(ZOOM_OUT_ICON, left, y);
            left += ZOOM_OUT_ICON_WIDTH;

            gc.drawImage(EDIT_ICON, left, y);
            left += EDIT_ICON_WIDTH;
        }
    }

    /**
     * Paints the preview title at the given position (and returns the required
     * height)
     *
     * @param gc the graphics context to paint into
     * @param x the left edge of the preview rectangle
     * @param y the top edge of the preview rectangle
     */
    private int paintTitle(GC gc, int x, int y, boolean showFile) {
        String displayName = getDisplayName();
        return paintTitle(gc, x, y, showFile, displayName);
    }

    /**
     * Paints the preview title at the given position (and returns the required
     * height)
     *
     * @param gc the graphics context to paint into
     * @param x the left edge of the preview rectangle
     * @param y the top edge of the preview rectangle
     * @param displayName the title string to be used
     */
    int paintTitle(GC gc, int x, int y, boolean showFile, String displayName) {
        int titleHeight = 0;

        if (showFile && mIncludedWithin != null) {
            if (mManager.getMode() != INCLUDES) {
                displayName = "<include>";
            } else {
                // Skip: just paint footer instead
                displayName = null;
            }
        }

        int width = getWidth();
        int labelTop = y + 1;
        gc.setClipping(x, labelTop, width, 100);

        // Use font height rather than extent height since we want two adjacent
        // previews (which may have different display names and therefore end
        // up with slightly different extent heights) to have identical title
        // heights such that they are aligned identically
        int fontHeight = gc.getFontMetrics().getHeight();

        if (displayName != null && displayName.length() > 0) {
            gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_WHITE));
            Point extent = gc.textExtent(displayName);
            int labelLeft = Math.max(x, x + (width - extent.x) / 2);
            Image icon = null;
            Locale locale = mConfiguration.getLocale();
            if (locale != null && (locale.hasLanguage() || locale.hasRegion())
                    && (!(mConfiguration instanceof NestedConfiguration)
                            || ((NestedConfiguration) mConfiguration).isOverridingLocale())) {
                icon = locale.getFlagImage();
            }

            if (icon != null) {
                int flagWidth = icon.getImageData().width;
                int flagHeight = icon.getImageData().height;
                labelLeft = Math.max(x + flagWidth / 2, labelLeft);
                gc.drawImage(icon, labelLeft - flagWidth / 2 - 1, labelTop);
                labelLeft += flagWidth / 2 + 1;
                gc.drawText(displayName, labelLeft,
                        labelTop - (extent.y - flagHeight) / 2, true);
            } else {
                gc.drawText(displayName, labelLeft, labelTop, true);
            }

            labelTop += extent.y;
            titleHeight += fontHeight;
        }

        if (showFile && (mAlternateInput != null || mIncludedWithin != null)) {
            // Draw file flag, and parent folder name
            IFile file = mAlternateInput != null
                    ? mAlternateInput : mIncludedWithin.getFile();
            String fileName = file.getParent().getName() + File.separator
                    + file.getName();
            Point extent = gc.textExtent(fileName);
            Image icon = IconFactory.getInstance().getIcon("android_file"); //$NON-NLS-1$
            int flagWidth = icon.getImageData().width;
            int flagHeight = icon.getImageData().height;

            int labelLeft = Math.max(x, x + (width - extent.x - flagWidth - 1) / 2);

            gc.drawImage(icon, labelLeft, labelTop);

            gc.setForeground(gc.getDevice().getSystemColor(SWT.COLOR_GRAY));
            labelLeft += flagWidth + 1;
            labelTop -= (extent.y - flagHeight) / 2;
            gc.drawText(fileName, labelLeft, labelTop, true);

            titleHeight += Math.max(titleHeight, icon.getImageData().height);
        }

        gc.setClipping((Region) null);

        return titleHeight;
    }

    /**
     * Notifies that the preview's configuration has changed.
     *
     * @param flags the change flags, a bitmask corresponding to the
     *            {@code CHANGE_} constants in {@link ConfigurationClient}
     */
    public void configurationChanged(int flags) {
        if (!mVisible) {
            mDirty |= flags;
            return;
        }

        if ((flags & MASK_RENDERING) != 0) {
            mResourceResolver.clear();
            // Handle inheritance
            mConfiguration.syncFolderConfig();
            updateForkStatus();
            updateSize();
        }

        // Sanity check to make sure things are working correctly
        if (DEBUG) {
            RenderPreviewMode mode = mManager.getMode();
            if (mode == DEFAULT) {
                assert mConfiguration instanceof VaryingConfiguration;
                VaryingConfiguration config = (VaryingConfiguration) mConfiguration;
                int alternateFlags = config.getAlternateFlags();
                switch (alternateFlags) {
                    case Configuration.CFG_DEVICE_STATE: {
                        State configState = config.getDeviceState();
                        State chooserState = mManager.getChooser().getConfiguration()
                                .getDeviceState();
                        assert configState != null && chooserState != null;
                        assert !configState.getName().equals(chooserState.getName())
                                : configState.toString() + ':' + chooserState;

                        Device configDevice = config.getDevice();
                        Device chooserDevice = mManager.getChooser().getConfiguration()
                                .getDevice();
                        assert configDevice != null && chooserDevice != null;
                        assert configDevice == chooserDevice
                                : configDevice.toString() + ':' + chooserDevice;

                        break;
                    }
                    case Configuration.CFG_DEVICE: {
                        Device configDevice = config.getDevice();
                        Device chooserDevice = mManager.getChooser().getConfiguration()
                                .getDevice();
                        assert configDevice != null && chooserDevice != null;
                        assert configDevice != chooserDevice
                                : configDevice.toString() + ':' + chooserDevice;

                        State configState = config.getDeviceState();
                        State chooserState = mManager.getChooser().getConfiguration()
                                .getDeviceState();
                        assert configState != null && chooserState != null;
                        assert configState.getName().equals(chooserState.getName())
                                : configState.toString() + ':' + chooserState;

                        break;
                    }
                    case Configuration.CFG_LOCALE: {
                        Locale configLocale = config.getLocale();
                        Locale chooserLocale = mManager.getChooser().getConfiguration()
                                .getLocale();
                        assert configLocale != null && chooserLocale != null;
                        assert configLocale != chooserLocale
                                : configLocale.toString() + ':' + chooserLocale;
                        break;
                    }
                    default: {
                        // Some other type of override I didn't anticipate
                        assert false : alternateFlags;
                    }
                }
            }
        }

        mDirty = 0;
        mManager.scheduleRender(this);
    }

    private void updateSize() {
        Device device = mConfiguration.getDevice();
        if (device == null) {
            return;
        }
        Screen screen = device.getDefaultHardware().getScreen();
        if (screen == null) {
            return;
        }

        FolderConfiguration folderConfig = mConfiguration.getFullConfig();
        ScreenOrientationQualifier qualifier = folderConfig.getScreenOrientationQualifier();
        ScreenOrientation orientation = qualifier == null
                ? ScreenOrientation.PORTRAIT : qualifier.getValue();

        // compute width and height to take orientation into account.
        int x = screen.getXDimension();
        int y = screen.getYDimension();
        int screenWidth, screenHeight;

        if (x > y) {
            if (orientation == ScreenOrientation.LANDSCAPE) {
                screenWidth = x;
                screenHeight = y;
            } else {
                screenWidth = y;
                screenHeight = x;
            }
        } else {
            if (orientation == ScreenOrientation.LANDSCAPE) {
                screenWidth = y;
                screenHeight = x;
            } else {
                screenWidth = x;
                screenHeight = y;
            }
        }

        int width = RenderPreviewManager.getMaxWidth();
        int height = RenderPreviewManager.getMaxHeight();
        if (screenWidth > 0) {
            double scale = getScale(screenWidth, screenHeight);
            width = (int) (screenWidth * scale);
            height = (int) (screenHeight * scale);
        }

        if (width != mWidth || height != mHeight) {
            mWidth = width;
            mHeight = height;

            Image thumbnail = mThumbnail;
            mThumbnail = null;
            if (thumbnail != null) {
                thumbnail.dispose();
            }
            if (mHeight != 0) {
                mAspectRatio = mWidth / (double) mHeight;
            }
        }
    }

    /**
     * Returns the configuration associated with this preview
     *
     * @return the configuration
     */
    @NonNull
    public Configuration getConfiguration() {
        return mConfiguration;
    }

    // ---- Implements IJobChangeListener ----

    @Override
    public void aboutToRun(IJobChangeEvent event) {
    }

    @Override
    public void awake(IJobChangeEvent event) {
    }

    @Override
    public void done(IJobChangeEvent event) {
        mJob = null;
    }

    @Override
    public void running(IJobChangeEvent event) {
    }

    @Override
    public void scheduled(IJobChangeEvent event) {
    }

    @Override
    public void sleeping(IJobChangeEvent event) {
    }

    // ---- Delayed Rendering ----

    private final class RenderJob extends UIJob {
        public RenderJob() {
            super("RenderPreview");
            setSystem(true);
            setUser(false);
        }

        @Override
        public IStatus runInUIThread(IProgressMonitor monitor) {
            mJob = null;
            if (!mCanvas.isDisposed()) {
                renderSync();
                mCanvas.redraw();
                return org.eclipse.core.runtime.Status.OK_STATUS;
            }

            return org.eclipse.core.runtime.Status.CANCEL_STATUS;
        }

        @Override
        public Display getDisplay() {
            if (mCanvas.isDisposed()) {
                return null;
            }
            return mCanvas.getDisplay();
        }
    }

    private final class AsyncRenderJob extends Job {
        public AsyncRenderJob() {
            super("RenderPreview");
            setSystem(true);
            setUser(false);
        }

        @Override
        protected IStatus run(IProgressMonitor monitor) {
            mJob = null;

            if (mCanvas.isDisposed()) {
                return org.eclipse.core.runtime.Status.CANCEL_STATUS;
            }

            renderSync();

            // Update display
            mCanvas.getDisplay().asyncExec(new Runnable() {
                @Override
                public void run() {
                    mCanvas.redraw();
                }
            });

            return org.eclipse.core.runtime.Status.OK_STATUS;
        }
    }

    /**
     * Sets the input file to use for rendering. If not set, this will just be
     * the same file as the configuration chooser. This is used to render other
     * layouts, such as variations of the currently edited layout, which are
     * not kept in sync with the main layout.
     *
     * @param file the file to set as input
     */
    public void setAlternateInput(@Nullable IFile file) {
        mAlternateInput = file;
    }

    /** Corresponding description for this preview if it is a manually added preview */
    private @Nullable ConfigurationDescription mDescription;

    /**
     * Sets the description of this preview, if this preview is a manually added preview
     *
     * @param description the description of this preview
     */
    public void setDescription(@Nullable ConfigurationDescription description) {
        mDescription = description;
    }

    /**
     * Returns the description of this preview, if this preview is a manually added preview
     *
     * @return the description
     */
    @Nullable
    public ConfigurationDescription getDescription() {
        return mDescription;
    }

    @Override
    public String toString() {
        return getDisplayName() + ':' + mConfiguration;
    }

    /** Sorts render previews into increasing aspect ratio order */
    static Comparator<RenderPreview> INCREASING_ASPECT_RATIO = new Comparator<RenderPreview>() {
        @Override
        public int compare(RenderPreview preview1, RenderPreview preview2) {
            return (int) Math.signum(preview1.mAspectRatio - preview2.mAspectRatio);
        }
    };
    /** Sorts render previews into visual order: row by row, column by column */
    static Comparator<RenderPreview> VISUAL_ORDER = new Comparator<RenderPreview>() {
        @Override
        public int compare(RenderPreview preview1, RenderPreview preview2) {
            int delta = preview1.mY - preview2.mY;
            if (delta == 0) {
                delta = preview1.mX - preview2.mX;
            }
            return delta;
        }
    };
}