/*
 * Copyright (c) 2014, 2015 Eike Stepper (Berlin, Germany) and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    Eike Stepper - initial API and implementation
 */
package org.eclipse.oomph.setup.ui.questionnaire;

import org.eclipse.oomph.preferences.PreferencesFactory;
import org.eclipse.oomph.setup.ui.questionnaire.AnimatedCanvas.Animator;

import org.eclipse.emf.common.util.URI;

import org.eclipse.swt.SWT;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Path;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Display;

import java.util.ArrayList;
import java.util.List;

/**
 * @author Eike Stepper
 */
public class GearAnimator extends Animator
{
  public static final String RECORDER_PREFERENCE_KEY = "RECORDER_PREFERENCE_KEY";

  public static final int NONE = -1;

  public static final int PAGE_WIDTH = 620;

  public static final int PAGE_HEIGHT = 420;

  public static final int BORDER = 30;

  public static final int GEARS = 7;

  private static final int TEETH = 8;

  private static final float ANGLE = 360 / TEETH;

  private static final double RADIAN = 2 * Math.PI / 360;

  private static final int EXIT = NONE - 1;

  private static final int BACK = EXIT - 1;

  private static final int NEXT = BACK - 1;

  private static final int CHOICES = NEXT - 1;

  private static final String[] TITLES = { "Welcome to Eclipse", "Refresh Resources Automatically?", "Show Line Numbers in Editors?",
      "Check Spelling in Text Editors?", "Execute Jobs in Background?", "Encode Text Files with UTF-8?", "Enable Preference Recorder?" };

  static final int BIG_FONT_PX = 48;

  static final int NORMAL_FONT_PX = (int)(BIG_FONT_PX * .75);

  private static Color WHITE;

  private static Color GRAY;

  private static Color DARK_GRAY;

  private final List<Listener> listeners = new ArrayList<Listener>();

  private Color purple;

  private Color tooltipColor;

  private Font tooltipFont;

  private Font bigFont;

  private Font hoverFont;

  private Font normalFont;

  private Font numberFont;

  private Image exit;

  private Image exitHover;

  private Image question;

  private final Image[] welcomeImages = new Image[2];

  private final Image[] summaryImages = new Image[2];

  private final Image[] backImages = new Image[2];

  private final Image[] nextImages = new Image[2];

  private final Image[] yesImages = new Image[5];

  private final Image[] noImages = new Image[5];

  private final Page[] pages = new Page[GEARS + 1];

  private final Point[] tooltipPoints = new Point[pages.length];

  private final Path[] gearPaths = new Path[GEARS + 1];

  private final Color[] gearBackground = new Color[2];

  private final Color[] gearForeground = new Color[2];

  private float radius;

  private int pageY;

  private int answerY;

  private int buttonR;

  private long startAnimation;

  private float speed;

  private float angle;

  private boolean overflow;

  private int selection;

  private int oldSelection = NONE;

  private int hover = NONE;

  private int oldHover = NONE;

  private Image pageBuffer;

  private GC pageGC;

  private Image oldPageBuffer;

  private GC oldPageGC;

  private boolean pageBufferUpdated;

  private boolean oldShowOverlay;

  private boolean summaryShown;

  private Rectangle exitBox;

  private Rectangle backBox;

  private Rectangle nextBox;

  public GearAnimator(Display display)
  {
    super(display);
    WHITE = display.getSystemColor(SWT.COLOR_WHITE);
    GRAY = display.getSystemColor(SWT.COLOR_GRAY);
    DARK_GRAY = display.getSystemColor(SWT.COLOR_DARK_GRAY);
  }

  @Override
  protected void init()
  {
    super.init();
    Display display = getDisplay();

    bigFont = createFont(BIG_FONT_PX, PAGE_WIDTH, TITLES);
    hoverFont = createFont(BIG_FONT_PX + 6, PAGE_WIDTH, TITLES);
    normalFont = createFont(NORMAL_FONT_PX, PAGE_WIDTH, TITLES);
    numberFont = createFont(24);
    tooltipFont = createFont(16);

    exit = loadImage("exit.png");
    exitHover = loadImage("exit_hover.png");
    question = loadImage("question.png");

    welcomeImages[0] = loadImage("welcome.png");
    welcomeImages[1] = loadImage("welcome_select.png");

    summaryImages[0] = loadImage("summary.png");
    summaryImages[1] = loadImage("summary_select.png");

    backImages[0] = loadImage("back.png");
    backImages[1] = loadImage("back_hover.png");

    nextImages[0] = loadImage("next.png");
    nextImages[1] = loadImage("next_hover.png");

    buttonR = nextImages[0].getBounds().height / 2;
    answerY = PAGE_HEIGHT + 4 * BORDER - buttonR;

    yesImages[0] = loadImage("yes.png");
    yesImages[1] = loadImage("yes_select.png");
    yesImages[2] = loadImage("yes_hover.png");
    yesImages[3] = loadImage("yes_big.png");
    yesImages[4] = loadImage("yes_badge.png");

    noImages[0] = loadImage("no.png");
    noImages[1] = loadImage("no_select.png");
    noImages[2] = loadImage("no_hover.png");
    noImages[3] = loadImage("no_big.png");
    noImages[4] = loadImage("no_badge.png");

    radius = 32;
    setSize((int)(GEARS * 2 * radius), (int)(2 * radius));
    pageY = getHeight() + 2 * BORDER;

    // Not selected.
    gearBackground[0] = createColor(169, 171, 202);
    gearForeground[0] = createColor(140, 132, 171);

    // Selected.
    gearBackground[1] = createColor(247, 148, 30);
    gearForeground[1] = createColor(207, 108, 0);

    purple = createColor(43, 34, 84);
    tooltipColor = createColor(253, 232, 206);

    pages[0] = new ImagePage(0, TITLES[0], 0, 0, 0, new TextAnswer(""));
    pages[1] = new PreferencePage(1, TITLES[1], 0, 5, 29, "/instance/org.eclipse.core.resources/refresh.lightweight.enabled");
    pages[2] = new PreferencePage(2, TITLES[2], 1, 19, 30, "/instance/org.eclipse.ui.editors/lineNumberRuler");
    pages[3] = new PreferencePage(3, TITLES[3], 1, 186, 37, "/instance/org.eclipse.ui.editors/spellingEnabled");
    pages[4] = new PreferencePage(4, TITLES[4], 0, 23, 160, "/instance/org.eclipse.ui.workbench/RUN_IN_BACKGROUND");
    pages[5] = new PreferencePage(5, TITLES[5], 0, 181, 95, "/instance/org.eclipse.core.resources/encoding", "UTF-8", null);
    pages[6] = new PreferencePage(6, TITLES[6], 1, 57, 82, RECORDER_PREFERENCE_KEY);
    pages[7] = new SummaryPage(7, "Summary");

    pageBuffer = new Image(display, PAGE_WIDTH, PAGE_HEIGHT);
    pageGC = new GC(pageBuffer);
    pageGC.setAdvanced(true);

    oldPageBuffer = new Image(display, PAGE_WIDTH, PAGE_HEIGHT);
    oldPageGC = new GC(oldPageBuffer);
    oldPageGC.setAdvanced(true);
  }

  @Override
  protected void dispose()
  {
    for (Path path : gearPaths)
    {
      if (path != null)
      {
        path.dispose();
      }
    }

    for (Page page : pages)
    {
      if (page != null)
      {
        page.dispose();
      }
    }

    pageGC.dispose();
    pageBuffer.dispose();
    oldPageGC.dispose();
    oldPageBuffer.dispose();
    super.dispose();
  }

  public Font getBigFont()
  {
    return bigFont;
  }

  public Font getHoverFont()
  {
    return hoverFont;
  }

  public Font getNormalFont()
  {
    return normalFont;
  }

  public final void addListener(Listener listener)
  {
    synchronized (listeners)
    {
      listeners.add(listener);
    }
  }

  public final Listener[] getListeners()
  {
    synchronized (listeners)
    {
      return listeners.toArray(new Listener[listeners.size()]);
    }
  }

  public final void removeListener(Listener listener)
  {
    synchronized (listeners)
    {
      listeners.remove(listener);
    }
  }

  public void restart()
  {
    angle = 0;
    speed = 0;
  }

  public final Page[] getPages()
  {
    return pages;
  }

  public final int getSelection()
  {
    return selection;
  }

  public final void setSelection(int selection)
  {
    hover = NONE;
    oldHover = NONE;

    if (selection < 0)
    {
      selection = 0;
      overflow = true;
    }
    else if (selection > pages.length - 1)
    {
      selection = pages.length - 1;
      overflow = true;
    }

    if (overflow)
    {
      overflow = false;
      while (advance())
      {
        // Just advance.
      }

      overflow = true;
      return;
    }

    oldSelection = this.selection;
    this.selection = selection;
    if (getSelectedPage() instanceof SummaryPage)
    {
      summaryShown = true;
    }

    Image tmpPageBuffer = oldPageBuffer;
    oldPageBuffer = pageBuffer;
    pageBuffer = tmpPageBuffer;

    GC tmpPageGC = oldPageGC;
    oldPageGC = pageGC;
    pageGC = tmpPageGC;

    pageBufferUpdated = false;

    restart();
  }

  public final int getOldSelection()
  {
    return oldSelection;
  }

  public final Page getSelectedPage()
  {
    return pages[selection];
  }

  @Override
  protected boolean onKeyPressed(KeyEvent e)
  {
    if (e.keyCode == SWT.ESC)
    {
      exit();
      return true;
    }

    if (e.keyCode == SWT.HOME)
    {
      setSelection(0);
      return true;
    }

    if (e.keyCode == SWT.END)
    {
      setSelection(GearAnimator.GEARS);
      return true;
    }

    if (e.keyCode == SWT.ARROW_RIGHT || e.keyCode == SWT.PAGE_DOWN)
    {
      setSelection(getSelection() + 1);
      return true;
    }

    if (e.keyCode == SWT.ARROW_LEFT || e.keyCode == SWT.PAGE_UP)
    {
      setSelection(getSelection() - 1);
      return true;
    }

    if (e.character >= '0' && e.character <= '6')
    {
      setSelection(e.character - '0');
      return true;
    }

    if (e.character == 13)
    {
      Page page = getSelectedPage();
      if (page instanceof SummaryPage)
      {
        page.doAnswer(0);
      }
      else
      {
        setSelection(getSelection() + 1);
      }

      return true;
    }

    if (e.character == 'y' || e.character == 'Y' || e.character == '+')
    {
      Page page = getSelectedPage();
      if (page instanceof PreferencePage)
      {
        page.doAnswer(0);
      }

      return true;
    }

    if (e.character == 'n' || e.character == 'N' || e.character == '-')
    {
      Page page = getSelectedPage();
      if (page instanceof PreferencePage)
      {
        page.doAnswer(1);
      }

      return true;
    }

    return false;
  }

  @Override
  protected boolean onMouseMove(int x, int y)
  {
    if (x != Integer.MIN_VALUE && y != Integer.MIN_VALUE)
    {
      GC gc = new GC(getCanvas());
      for (int i = 0; i < gearPaths.length; i++)
      {
        Path path = gearPaths[i];
        if (path != null && path.contains(x, y, gc, false))
        {
          if (i != hover)
          {
            hover = i;
          }

          return true;
        }
      }

      if (exitBox != null && exitBox.contains(x, y))
      {
        hover = EXIT;
        return true;
      }

      Page page = getSelectedPage();
      if (page != null)
      {
        if (page.showBack() && backBox != null && backBox.contains(x, y))
        {
          hover = BACK;
          return true;
        }

        if (page.showNext() && nextBox != null && nextBox.contains(x, y))
        {
          hover = NEXT;
          return true;
        }

        x -= BORDER;
        y -= pageY;

        hover = page.onMouseMove(x, y);
        if (hover != NONE)
        {
          return true;
        }
      }
    }

    hover = NONE;
    return false;
  }

  @Override
  protected boolean onMouseDown(int x, int y)
  {
    if (x != Integer.MIN_VALUE && y != Integer.MIN_VALUE)
    {
      GC gc = new GC(getCanvas());
      for (int i = 0; i < gearPaths.length; i++)
      {
        Path path = gearPaths[i];
        if (path != null && path.contains(x, y, gc, false))
        {
          if (i != getSelection())
          {
            setSelection(i);
          }

          return true;
        }
      }

      if (exitBox != null && exitBox.contains(x, y))
      {
        exit();
        return true;
      }

      Page page = getSelectedPage();
      if (page != null)
      {
        if (page.showBack() && backBox != null && backBox.contains(x, y))
        {
          setSelection(getSelection() - 1);
          return true;
        }

        if (page.showNext() && nextBox != null && nextBox.contains(x, y))
        {
          setSelection(getSelection() + 1);
          return true;
        }

        x -= BORDER;
        y -= pageY;

        if (page.onMouseDown(x, y))
        {
          return true;
        }
      }
    }

    return false;
  }

  protected void exit()
  {
    hover = EXIT;

    AnimatedCanvas canvas = getCanvas();
    canvas.redraw();

    ExitShell exitShell = new ExitShell(this);
    Boolean result = exitShell.openModal();

    if (Boolean.TRUE.equals(result))
    {
      for (Listener listener : getListeners())
      {
        listener.onExit(GearAnimator.this, getSelectedPage());
      }
    }

    hover = NONE;
    if (!canvas.isDisposed())
    {
      canvas.redraw();
    }
  }

  protected boolean shouldShowOverlay()
  {
    Page page = getSelectedPage();
    if (page instanceof ImagePage)
    {
      ImagePage questionPage = (ImagePage)page;

      if (hover <= CHOICES)
      {
        int hoveredChoice = -hover + CHOICES;
        return hoveredChoice == questionPage.getOverlayChoice();
      }

      int choice = questionPage.getChoice();
      if (choice != NONE)
      {
        return choice == questionPage.getOverlayChoice();
      }
    }

    return (System.currentTimeMillis() / 1000 & 1) == 1;
  }

  @Override
  protected boolean advance()
  {
    boolean needsRedraw = false;
    if (overflow)
    {
      overflow = false;
      needsRedraw = true;
    }

    boolean showOverlay = shouldShowOverlay();
    if (showOverlay != oldShowOverlay)
    {
      oldShowOverlay = showOverlay;
      updatePage();
      needsRedraw = true;
    }

    if (hover != oldHover)
    {
      needsRedraw = true;
    }

    if (speed >= ANGLE)
    {
      startAnimation = 0;
      return needsRedraw;
    }

    long now = System.currentTimeMillis();
    if (startAnimation == 0)
    {
      startAnimation = now;
    }

    long timeSinceStart = now - startAnimation;
    speed = timeSinceStart * ANGLE / 1900;
    angle += speed;
    return true;
  }

  @Override
  protected void paint(GC gc, Image buffer)
  {
    gc.setFont(getBaseFont());
    gc.setLineWidth(3);
    gc.setAntialias(SWT.ON);

    // Unselected gears
    Page page = getSelectedPage();
    int alpha = Math.min((int)(255 * speed / ANGLE), 255);

    for (int i = 0; i < GEARS + 1; i++)
    {
      if (i != selection && (i < GEARS || summaryShown))
      {
        tooltipPoints[i] = paintGear(gc, i, alpha);
      }
    }

    // Selected gear
    tooltipPoints[selection] = paintGear(gc, selection, alpha);

    // Exit button
    int centerX = BORDER + PAGE_WIDTH - exit.getBounds().width / 2;
    int centerY = BORDER + exit.getBounds().height / 2;
    Image exitImage = hover == EXIT ? exitHover : exit;

    exitBox = exitImage.getBounds();
    exitBox.x = centerX - exitImage.getBounds().width / 2;
    exitBox.y = centerY - exitImage.getBounds().height / 2;
    gc.drawImage(exitImage, exitBox.x, exitBox.y);

    // Selected page
    if (!pageBufferUpdated)
    {
      updatePage();
      pageBufferUpdated = true;
    }

    if (oldSelection == NONE)
    {
      gc.setAlpha(alpha);
      gc.drawImage(pageBuffer, BORDER, pageY);
      gc.setAlpha(255);
    }
    else
    {
      double progress = 2 * speed / ANGLE;
      int slide = Math.min((int)(PAGE_WIDTH * progress * progress), PAGE_WIDTH);

      gc.setAlpha(255 - alpha);
      if (selection > oldSelection)
      {
        gc.drawImage(oldPageBuffer, slide, 0, PAGE_WIDTH - slide, PAGE_HEIGHT, BORDER, pageY, PAGE_WIDTH - slide, PAGE_HEIGHT);
        gc.setAlpha(alpha);
        gc.drawImage(pageBuffer, 0, 0, slide, PAGE_HEIGHT, BORDER + PAGE_WIDTH - slide, pageY, slide, PAGE_HEIGHT);
      }
      else
      {
        gc.drawImage(oldPageBuffer, 0, 0, PAGE_WIDTH - slide, PAGE_HEIGHT, BORDER + slide, pageY, PAGE_WIDTH - slide, PAGE_HEIGHT);
        gc.setAlpha(alpha);
        gc.drawImage(pageBuffer, PAGE_WIDTH - slide, 0, slide, PAGE_HEIGHT, BORDER, pageY, slide, PAGE_HEIGHT);
      }

      gc.setAlpha(255);
    }

    // Gear tooltip
    if (hover >= 0 && hover < tooltipPoints.length)
    {
      Point point = tooltipPoints[hover];
      String title = pages[hover].getTitle();

      gc.setFont(tooltipFont);
      gc.setForeground(DARK_GRAY);
      gc.setBackground(tooltipColor);
      Rectangle rectangle = drawText(gc, point.x, point.y + 14, title, 2);

      gc.setForeground(GRAY);
      gc.setLineWidth(1);
      gc.drawRectangle(rectangle);
    }

    // Back button
    if (page.showBack())
    {
      backBox = Animator.drawImage(gc, backImages[hover == BACK ? 1 : 0], BORDER + buttonR, answerY);
    }

    // Next button
    if (page.showNext())
    {
      nextBox = Animator.drawImage(gc, nextImages[hover == NEXT ? 1 : 0], PAGE_WIDTH + BORDER - buttonR, answerY);
    }

    oldHover = hover;
  }

  private Point paintGear(GC gc, int i, int alpha)
  {
    double offset = 2 * i * radius;
    double x = BORDER + radius + offset;
    double y = BORDER + radius;
    double r2 = (double)radius * .8f;
    double r3 = (double)radius * .5f;

    int selected = 0;
    double factor = 1;
    if (i == oldSelection)
    {
      if (speed < ANGLE / 2)
      {
        selected = 1;
      }
    }
    else if (i == selection)
    {
      if (speed >= ANGLE / 2)
      {
        selected = 1;
        factor += (ANGLE - speed) * .02;
      }
      else
      {
        factor += speed * .02;
      }
    }

    boolean hovered = false;
    if (i == hover)
    {
      factor += .1;
      oldHover = hover;
      if (selected == 0)
      {
        hovered = true;
      }
    }

    double outerR = factor * radius;
    double innerR = factor * r2;
    float angleOffset = (angle + i * ANGLE) * (i % 2 == 1 ? -1 : 1);

    gc.setForeground(hovered ? DARK_GRAY : gearForeground[selected]);
    gc.setBackground(hovered ? GRAY : gearBackground[selected]);

    Display display = getDisplay();
    Path path = drawGear(gc, display, x, y, outerR, innerR, angleOffset);

    if (gearPaths[i] != null)
    {
      gearPaths[i].dispose();
    }

    gearPaths[i] = path;

    int ovalX = (int)(x - factor * r3);
    int ovalY = (int)(y - factor * r3);
    int ovalR = (int)(2 * factor * r3);
    gc.setBackground(WHITE);
    gc.fillOval(ovalX, ovalY, ovalR, ovalR);
    gc.drawOval(ovalX, ovalY, ovalR, ovalR);

    if (i == 0)
    {
      Animator.drawImage(gc, welcomeImages[selected], (int)x, (int)y);
    }
    else if (i < GEARS)
    {
      String number = Integer.toString(i);
      gc.setForeground(selected == 1 ? gearForeground[1] : GRAY);
      gc.setFont(numberFont);
      Animator.drawText(gc, x, y - 1, number);
    }
    else
    {
      Animator.drawImage(gc, summaryImages[selected], (int)x, (int)y);
    }

    return paintBadge(gc, x, y, outerR, i, alpha);
  }

  private Point paintBadge(GC gc, double x, double y, double outerR, int i, int alpha)
  {
    if (selection >= GEARS)
    {
      gc.setAlpha(255 - alpha);
    }
    else if (oldSelection >= GEARS)
    {
      gc.setAlpha(alpha);
    }

    Page page = pages[i];
    Answer answer = page.getChoiceAnswer();
    if (answer instanceof ImageAnswer)
    {
      ImageAnswer imageAnswer = (ImageAnswer)answer;
      Image image = imageAnswer.getImages()[4];
      gc.drawImage(image, (int)(x - image.getBounds().width / 2), (int)(y - outerR - 12));
    }

    gc.setAlpha(255);
    return new Point((int)x, (int)(y + outerR));
  }

  private Page updatePage()
  {
    pageGC.setBackground(WHITE);
    pageGC.fillRectangle(pageBuffer.getBounds());

    Page page = getSelectedPage();
    page.paint(pageGC);
    return page;
  }

  void updateOverlay(int x, int y)
  {
    Page page = getSelectedPage();
    if (page instanceof ImagePage)
    {
      ImagePage questionPage = (ImagePage)page;
      questionPage.overlayX += x;
      questionPage.overlayY += y;

      System.out.println("" + questionPage.overlayX + ", " + questionPage.overlayY);

      updatePage();
      overflow = true;
    }
  }

  private static Path drawGear(GC gc, Display display, double cx, double cy, double outerR, double innerR, float angleOffset)
  {
    double radian2 = ANGLE / 2 * RADIAN;
    double radian3 = .06;

    Path path = new Path(display);

    for (int i = 0; i < TEETH; i++)
    {
      double radian = (i * ANGLE + angleOffset) * RADIAN;

      double x = cx + outerR * Math.cos(radian);
      double y = cy - outerR * Math.sin(radian);

      if (i == 0)
      {
        path.moveTo((int)x, (int)y);
      }

      double r1 = radian + radian3;
      double r3 = radian + radian2;
      double r2 = r3 - radian3;
      double r4 = r3 + radian2;

      x = cx + innerR * Math.cos(r1);
      y = cy - innerR * Math.sin(r1);
      path.lineTo((int)x, (int)y);

      x = cx + innerR * Math.cos(r2);
      y = cy - innerR * Math.sin(r2);
      path.lineTo((int)x, (int)y);

      x = cx + outerR * Math.cos(r3);
      y = cy - outerR * Math.sin(r3);
      path.lineTo((int)x, (int)y);

      x = cx + outerR * Math.cos(r4);
      y = cy - outerR * Math.sin(r4);
      path.lineTo((int)x, (int)y);
    }

    path.close();
    gc.fillPath(path);
    gc.drawPath(path);
    return path;
  }

  /**
   * @author Eike Stepper
   */
  public interface Listener
  {
    public void onAnswer(GearAnimator animator, Page page, Answer answer);

    public void onExit(GearAnimator animator, Page page);
  }

  /**
   * @author Eike Stepper
   */
  public abstract class Answer
  {
    public Answer()
    {
    }

    public abstract Point getSize(GC gc, Page page);

    public abstract Rectangle paint(GC gc, Page page, int index, int x, int y, boolean hovered, boolean selected);
  }

  /**
   * @author Eike Stepper
   */
  public class TextAnswer extends Answer
  {
    private final String text;

    public TextAnswer(String text)
    {
      this.text = text;
    }

    public final String getText()
    {
      return text;
    }

    @Override
    public Point getSize(GC gc, Page page)
    {
      gc.setFont(hoverFont);
      return gc.stringExtent(text);
    }

    @Override
    public Rectangle paint(GC gc, Page page, int index, int x, int y, boolean hovered, boolean selected)
    {
      gc.setFont(hovered ? hoverFont : bigFont);
      gc.setForeground(selected ? purple : DARK_GRAY);

      Point extent = gc.stringExtent(text);
      x -= extent.x / 2 - 60; // TODO -60 is a hack!
      y -= extent.y / 2;
      gc.drawText(text, x, y, true);

      return new Rectangle(x, y, extent.x, extent.y);
    }
  }

  /**
   * @author Eike Stepper
   */
  public class ImageAnswer extends Answer
  {
    private final Image[] images;

    public ImageAnswer(Image... images)
    {
      this.images = images;
    }

    public final Image[] getImages()
    {
      return images;
    }

    @Override
    public Point getSize(GC gc, Page page)
    {
      Rectangle bounds = images[2].getBounds();
      return new Point(bounds.width, bounds.height);
    }

    @Override
    public Rectangle paint(GC gc, Page page, int index, int x, int y, boolean hovered, boolean selected)
    {
      Image image = images[0];
      if (hovered)
      {
        image = images[2];
      }
      else if (selected)
      {
        image = images[1];
      }
      else
      {
        if (page instanceof ImagePage && images.length > 3)
        {
          int overlayChoice = ((ImagePage)page).getOverlayChoice();
          boolean overlayChoiceYes = overlayChoice == index;
          boolean showOverlay = shouldShowOverlay();

          if (showOverlay == overlayChoiceYes)
          {
            image = images[3];
          }
        }
      }

      return Animator.drawImage(gc, image, x, y);
    }
  }

  /**
   * @author Eike Stepper
   */
  public class BackButton extends ImageAnswer
  {
    public BackButton()
    {
      super(backImages);
    }
  }

  /**
   * @author Eike Stepper
   */
  public class NextButton extends ImageAnswer
  {
    public NextButton()
    {
      super(nextImages);
    }
  }

  /**
   * @author Eike Stepper
   */
  public abstract class Page
  {
    private final int index;

    private final String title;

    private Answer[] answers;

    private Rectangle[] answerBoxes;

    private int choice = NONE;

    public Page(int index, String title)
    {
      this.index = index;
      this.title = title;
    }

    public final int getIndex()
    {
      return index;
    }

    public final String getTitle()
    {
      return title;
    }

    public final Answer[] getAnswers()
    {
      return answers;
    }

    public final void setAnswers(Answer[] answers)
    {
      this.answers = answers;
      answerBoxes = new Rectangle[answers.length];
    }

    public final int getAnswer(int x, int y)
    {
      for (int i = 0; i < answers.length; i++)
      {
        Rectangle box = answerBoxes[i];
        if (box != null && box.contains(x, y))
        {
          return i;
        }
      }

      return NONE;
    }

    public final Answer getChoiceAnswer()
    {
      return choice == NONE ? null : answers[choice];
    }

    public final int getChoice()
    {
      return choice;
    }

    public final void setChoice(int choice)
    {
      this.choice = choice;
    }

    protected void dispose()
    {
    }

    protected boolean showBack()
    {
      return index > 0;
    }

    protected boolean showNext()
    {
      return index < GEARS;
    }

    protected int onMouseMove(int x, int y)
    {
      int i = getAnswer(x, y);
      if (i != NONE)
      {
        pageBufferUpdated = false;
        return CHOICES - i;
      }

      if (hover <= CHOICES)
      {
        pageBufferUpdated = false;
      }

      return NONE;
    }

    protected boolean onMouseDown(int x, int y)
    {
      int i = getAnswer(x, y);
      if (i != NONE)
      {
        doAnswer(i);
        return true;
      }

      return false;
    }

    protected final void paint(GC gc)
    {
      String title = getTitle();

      Font oldFont = gc.getFont();
      gc.setFont(bigFont);

      Point extent = gc.stringExtent(title);
      gc.setForeground(purple);
      gc.drawText(title, (PAGE_WIDTH - extent.x) / 2, 0, true);

      gc.setFont(oldFont);

      paintContent(gc);
      paintAnswers(gc);
    }

    protected abstract void paintContent(GC gc);

    protected int getAnswerY()
    {
      return answerY;
    }

    private void doAnswer(int i)
    {
      Answer answer = answers[i];

      if (i == choice)
      {
        hover = NONE;
        choice = NONE;
        answer = null;
      }
      else
      {
        setChoice(i);
      }

      updatePage();

      for (Listener listener : getListeners())
      {
        listener.onAnswer(GearAnimator.this, this, answer);
      }

      if (answer != null)
      {
        int selection = getSelection();
        if (selection < GEARS)
        {
          setSelection(selection + 1);
        }
      }
    }

    private void paintAnswers(GC gc)
    {
      boolean selecteds[] = new boolean[answers.length];
      boolean hovereds[] = new boolean[answers.length];
      Point sizes[] = new Point[answers.length];

      int width = (answers.length - 1) * BORDER;
      int height = 0;

      for (int i = 0; i < answers.length; i++)
      {
        selecteds[i] = i == choice;
        if (CHOICES - i == hover)
        {
          oldHover = hover;
          hovereds[i] = true;
        }

        sizes[i] = answers[i].getSize(gc, this);
        width += sizes[i].x;
        height = Math.max(height, sizes[i].y);
      }

      int x = (PAGE_WIDTH - width) / 2;
      int y = getAnswerY() - pageY;

      for (int i = 0; i < answers.length; i++)
      {
        Answer answer = answers[i];
        answerBoxes[i] = answer.paint(gc, this, i, x, y, hovereds[i], selecteds[i]);
        x += BORDER + sizes[i].x;
      }
    }
  }

  /**
   * @author Eike Stepper
   */
  public class ImagePage extends Page
  {
    private final Image image;

    private final Image overlay;

    private final int overlayChoice;

    private int overlayX;

    private int overlayY;

    public ImagePage(int index, String title, int overlayChoice, int overlayX, int overlayY, Answer... answers)
    {
      super(index, title);
      this.overlayChoice = overlayChoice;
      setAnswers(answers);

      Display display = getDisplay();
      image = doLoadImage(display, index, "");
      overlay = doLoadImage(display, index, "_ovr");

      this.overlayX = overlayX;
      this.overlayY = overlayY;
    }

    public ImagePage(int index, String title, int overlayChoice, int overlayX, int overlayY)
    {
      this(index, title, overlayChoice, overlayX, overlayY, new Answer[] { new ImageAnswer(yesImages), new ImageAnswer(noImages) });
    }

    public final int getOverlayChoice()
    {
      return overlayChoice;
    }

    @Override
    protected void paintContent(GC gc)
    {
      if (image != null)
      {
        Rectangle bounds = image.getBounds();
        int x = (PAGE_WIDTH - bounds.width) / 2;
        int y = (PAGE_HEIGHT - bounds.height) / 2;
        gc.drawImage(image, x, y);

        if (overlay != null && shouldShowOverlay())
        {
          gc.drawImage(overlay, x + overlayX, y + overlayY);
        }
      }
    }

    private Image doLoadImage(final Display display, int index, String suffix)
    {
      try
      {
        return loadImage("page" + index + suffix + ".png");
      }
      catch (Exception ex)
      {
        return null;
      }
    }
  }

  /**
   * @author Eike Stepper
   */
  public class PreferencePage extends ImagePage
  {
    private final URI preferenceKey;

    private final String yesValue;

    private final String noValue;

    public PreferencePage(int index, String title, int overlayChoice, int overlayX, int overlayY, String preferenceKey, String yesValue, String noValue)
    {
      super(index, title, overlayChoice, overlayX, overlayY, new Answer[] { new ImageAnswer(yesImages), new ImageAnswer(noImages) });
      this.preferenceKey = PreferencesFactory.eINSTANCE.createURI(preferenceKey);
      this.yesValue = yesValue;
      this.noValue = noValue;
    }

    public PreferencePage(int index, String title, int overlayChoice, int overlayX, int overlayY, String preferenceKey)
    {
      this(index, title, overlayChoice, overlayX, overlayY, preferenceKey, "true", "false");
    }

    public final URI getPreferenceKey()
    {
      return preferenceKey;
    }

    public final String getYesValue()
    {
      return yesValue;
    }

    public final String getNoValue()
    {
      return noValue;
    }
  }

  /**
   * @author Eike Stepper
   */
  public class SummaryPage extends Page
  {
    private Rectangle[] boxes;

    public SummaryPage(int index, String title)
    {
      super(index, title);
      setAnswers(new Answer[] { new TextAnswer("Finish") });
    }

    @Override
    protected boolean showNext()
    {
      return false;
    }

    @Override
    protected int onMouseMove(int x, int y)
    {
      if (boxes != null)
      {
        for (int i = 0; i < boxes.length; i++)
        {
          Rectangle box = boxes[i];
          if (box.contains(x, y))
          {
            return i + 1;
          }
        }
      }

      return super.onMouseMove(x, y);
    }

    @Override
    protected boolean onMouseDown(int x, int y)
    {
      if (boxes != null)
      {
        for (int i = 0; i < boxes.length; i++)
        {
          Rectangle box = boxes[i];
          if (box.contains(x, y))
          {
            setSelection(i + 1);
            return true;
          }
        }
      }

      return super.onMouseDown(x, y);
    }

    @Override
    protected void paintContent(GC gc)
    {
      gc.setFont(normalFont);

      boxes = new Rectangle[GEARS - 1];
      int offsetX = yesImages[4].getBounds().width + 12;
      int minWidth = Integer.MAX_VALUE;
      int maxWidth = 0;

      for (int i = 1; i < GEARS; i++)
      {
        Page page = pages[i];
        Point extent = gc.stringExtent(page.getTitle());
        int width = extent.x;
        minWidth = Math.min(minWidth, width);
        maxWidth = Math.max(maxWidth, width);

        boxes[i - 1] = new Rectangle(0, 0, offsetX + width, extent.y + 4);
      }

      int width = (minWidth + maxWidth) / 2 + offsetX;

      for (int i = 1; i < GEARS; i++)
      {
        int x = (PAGE_WIDTH - width) / 2;
        int y = 40 * (1 + i);

        ImagePage page = (ImagePage)pages[i];
        ImageAnswer answer = (ImageAnswer)page.getChoiceAnswer();
        if (answer != null)
        {
          gc.drawImage(answer.images[4], x, y + 8);
          gc.setForeground(purple);
        }
        else
        {
          gc.drawImage(question, x, y + 8);
          gc.setForeground(DARK_GRAY);
        }

        String title = page.getTitle();
        if (title.endsWith("?"))
        {
          title = title.substring(0, title.length() - 1);
        }

        gc.drawText(title, x + offsetX, y);
        boxes[i - 1].x = x;
        boxes[i - 1].y = y + 4;
      }
    }
  }
}