package com.github.celldynamics.quimp;
   
   import java.awt.event.ActionListener;
   import java.awt.event.ItemEvent;
   import java.awt.event.ItemListener;
   import java.awt.event.MouseEvent;
   import java.io.File;
   
   import javax.swing.event.ChangeEvent;
  import javax.swing.event.ChangeListener;
  
  import com.github.celldynamics.quimp.filesystem.FileExtensions;
  import com.github.celldynamics.quimp.geom.ExtendedVector2d;
  
  import ij.IJ;
  import ij.ImagePlus;
  import ij.gui.ImageCanvas;
  import ij.gui.ImageWindow;
  import ij.gui.Overlay;
  import ij.gui.StackWindow;
  import ij.io.OpenDialog;
  import ij.plugin.PlugIn;
  import ij.plugin.TextReader;
  import ij.process.ImageProcessor;
  
  /**
   *
   * @author rtyson
   */
  public class Q_Explorer implements PlugIn {
  
    /**
     * The map canvs.
     */
    MapCanvas[] mapCanvs;
  
    /**
     * The mov canvas.
     */
    MovCanvas movCanvas;
  
    /**
     * The explorer window.
     */
    ExplorerStackWindow explorerWindow;
  
    /**
     * The image manager.
     */
    ImageManager imageManager;
  
    /**
     * The o H.
     */
    OutlineHandler oH;
  
    /*
     * (non-Javadoc)
     * 
     * @see ij.plugin.PlugIn#run(java.lang.String)
     */
    @Override
    public void run(String string) {
      try {
        // do {
        OpenDialog od =
                new OpenDialog("Open paramater file (" + FileExtensions.configFileExt + ")...",
                        OpenDialog.getLastDirectory(), "");
        if (od.getFileName() == null) {
          return;
        }
        File paramFile = new File(od.getDirectory(), od.getFileName());
        EXp.qp = new QParams(paramFile);
        EXp.qp.readParams();
        setup();
        return;
        // } while (true);
  
      } catch (Exception e) {
        // IJ.error("Unknown exception");
        e.printStackTrace();
      }
    }
  
    /**
     * The Class MapCanvas.
     */
    @SuppressWarnings("serial")
    class MapCanvas extends ImageCanvas {
  
      /**
       * Instantiates a new map canvas.
       *
       * @param imp the imp
       */
      MapCanvas(ImagePlus imp) {
        super(imp);
      }
  
     /*
      * (non-Javadoc)
      * 
      * @see ij.gui.ImageCanvas#mousePressed(java.awt.event.MouseEvent)
      */
     @Override
     public void mousePressed(MouseEvent e) {
       super.mousePressed(e);
       IJ.log("Map pressed at: (" + offScreenX(e.getX()) + "," + offScreenY(e.getY()) + ")");
       mapUpdate(e.getX(), e.getY());
     }
   }
 
   /**
    * The Class MovCanvas.
    */
   @SuppressWarnings("serial")
   class MovCanvas extends ImageCanvas {
 
     /**
      * Instantiates a new mov canvas.
      *
      * @param imp the imp
      */
     MovCanvas(ImagePlus imp) {
       super(imp);
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see ij.gui.ImageCanvas#mousePressed(java.awt.event.MouseEvent)
      */
     @Override
     public void mousePressed(MouseEvent e) {
       IJ.log("Movie pressed at: (" + offScreenX(e.getX()) + "," + offScreenY(e.getY()) + ")");
     }
   }
 
   /**
    * The Class ExplorerStackWindow.
    */
   @SuppressWarnings("serial")
   class ExplorerStackWindow extends StackWindow
           implements ActionListener, ItemListener, ChangeListener {
 
     /**
      * Instantiates a new explorer stack window.
      *
      * @param imp the imp
      * @param stackCanvas the stack canvas
      */
     ExplorerStackWindow(ImagePlus imp, ImageCanvas stackCanvas) {
       super(imp, stackCanvas);
 
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see java.awt.event.ItemListener#itemStateChanged(java.awt.event.ItemEvent)
      */
     @Override
     public void itemStateChanged(ItemEvent ie) {
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see javax.swing.event.ChangeListener#stateChanged(javax.swing.event.ChangeEvent)
      */
     @Override
     public void stateChanged(ChangeEvent ce) {
     }
 
     /*
      * (non-Javadoc)
      * 
      * @see ij.gui.StackWindow#updateSliceSelector()
      */
     @Override
     public void updateSliceSelector() {
       super.updateSliceSelector();
       EXp.frame = sliceSelector.getValue();
       imageManager.updateOverlays(); // draw overlay
     } // update the frame label, overlay, frame and set zoom
   }
 
   /**
    * Setup.
    */
   void setup() {
     oH = new OutlineHandler(EXp.qp);
     if (!oH.readSuccess) {
       IJ.error("Failed to read " + EXp.qp.getSnakeQP().getName());
       return;
     }
     imageManager = new ImageManager(oH);
     buildWindows();
   }
 
   /**
    * Builds the windows.
    */
   void buildWindows() {
     mapCanvs = new MapCanvas[imageManager.nbMaps];
     mapCanvs[0] = new MapCanvas(imageManager.mapsIpl[0]);
     new ImageWindow(imageManager.mapsIpl[0], mapCanvs[0]);
     imageManager.mapsIpl[0].show();
 
     movCanvas = new MovCanvas(imageManager.movieIpl);
     explorerWindow = new ExplorerStackWindow(imageManager.movieIpl, movCanvas);
 
     imageManager.movieIpl.show();
     imageManager.movieIpl.setSlice(1);
     EXp.frame = 1;
     imageManager.updateOverlays();
   }
 
   /**
    * Map update.
    *
    * @param x the x
    * @param y the y
    */
   void mapUpdate(int x, int y) {
     imageManager.setSlice(y);
   }
 
   /**
    * Map 2 mov.
    *
    * @return the extended vector 2 d
    */
   ExtendedVector2d map2Mov() {
     return new ExtendedVector2d(-1, -1);
   }
 }
 
 class ImageManager {
 
   ImagePlus[] mapsIpl;
   ImagePlus movieIpl;
   ImagePlus xMap;
   ImagePlus yMap;
   Overlay[] movOverlay;
   ExtendedVector2d mapCoord;
   ExtendedVector2d movCoord;
   int nbMaps;
 
   ImageManager(OutlineHandler oH) {
     nbMaps = 1;
     mapsIpl = new ImagePlus[1];
 
     xMap = openMap(EXp.qp.getxmapFile(), "xMap");
     yMap = openMap(EXp.qp.getxmapFile(), "yMap");
 
     mapsIpl[0] = openMap(EXp.qp.getMotilityFile(), "Motility Map");
 
     movieIpl = IJ.openImage(EXp.qp.getSegImageFile().getAbsolutePath());
     movOverlay = new Overlay[movieIpl.getStackSize()];
 
     // build overlays
     movOverlay = new Overlay[movieIpl.getStackSize()];
     for (int i = 1; i <= movieIpl.getStackSize(); i++) {
       movOverlay[i - 1] = new Overlay();
       if (oH.isOutlineAt(i)) {
         movOverlay[i - 1].add(oH.getStoredOutline(i).asFloatRoi());
       }
     }
 
   }
 
   private ImagePlus openMap(File f, String n) {
 
     if (!f.exists()) {
       IJ.log("Could not open " + f.getName());
       return null;
     }
 
     TextReader textR = new TextReader();
     ImageProcessor ip = textR.open(f.getAbsolutePath());
     return new ImagePlus(n, ip);
   }
 
   void updateOverlays() {
     movieIpl.setOverlay(movOverlay[EXp.frame - 1]);
   }
 
   void setSlice(int i) {
     movieIpl.setSlice(i);
     EXp.frame = i;
     this.updateOverlays();
   }
 
 }
 
 class EXp {
 
   static QParams qp;
   static int frame;
 
   EXp() {
 
   }
 
 }