package NET.worlds.console;

import NET.worlds.scape.Camera;
import NET.worlds.scape.EventQueue;
import NET.worlds.scape.FrameEvent;
import NET.worlds.scape.LibraryDropTarget;
import NET.worlds.scape.Pilot;
import NET.worlds.scape.ToolTipManager;
import java.awt.Canvas;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.IllegalComponentStateException;
import java.awt.Point;
import java.util.Enumeration;
import java.util.Vector;

public class RenderCanvas extends Canvas implements FramePart, LibraryDropTarget {
   private static final long serialVersionUID = -811200590685352009L;
   DefaultConsole universeConsole;
   private Window w;
   private Dimension dim;
   private Camera camera;
   private int xRenderExtent;
   private int yRenderExtent;
   private boolean fullScreenOverlay = false;
   private boolean mayNeedToResize;
   private Vector<RenderCanvasOverlay> overlays;

   public RenderCanvas(Dimension d) {
      this(null, d);
   }

   public RenderCanvas(DefaultConsole dc, Dimension d) {
      this.universeConsole = dc;
      this.dim = d;
      this.overlays = new Vector<RenderCanvasOverlay>();
   }

   public void drive() {
      if (this.w != null && Pilot.getActiveRoom() != null) {
         this.w.setDeltaMode(true);
      }
   }

   public boolean getDeltaMode() {
      return this.w == null ? false : this.w.getDeltaMode();
   }

   @Override
   public void activate(Console c, Container f, Console prev) {
   }

   @Override
   public void deactivate() {
   }

   public void setCamera(Camera cam) {
      this.camera = cam;
      if (cam != null) {
         cam.setCanvas(this);
      }
   }

   public Camera getCamera() {
      return this.camera;
   }

   public Window getWindow() {
      return this.w;
   }

   @Override
   public void update(Graphics g) {
   }

   @Override
   public void paint(Graphics g) {
   }

   @Override
   public void reshape(int x, int y, int width, int height) {
      super.reshape(x, y, width, height);
      this.mayNeedToResize = true;
   }

   @Override
   public Dimension minimumSize() {
      return this.dim;
   }

   @Override
   public Dimension preferredSize() {
      return this.dim;
   }

   public void addOverlay(RenderCanvasOverlay overlay) {
      assert this.overlays != null;

      this.overlays.addElement(overlay);
      this.mayNeedToResize = true;
   }

   public void removeOverlay(RenderCanvasOverlay overlay) {
      assert this.overlays != null;

      this.overlays.removeElement(overlay);
      this.mayNeedToResize = true;
   }

   private void computeOverlayDimensions() {
      int minYPer = 100;
      int minXPer = 100;
      this.fullScreenOverlay = false;
      Dimension size = this.getSize();
      if (this.overlays != null) {
         Enumeration<RenderCanvasOverlay> e = this.overlays.elements();

         while (e.hasMoreElements()) {
            RenderCanvasOverlay o = e.nextElement();
            o.canvasResized(size.width, size.height);
            if (o.isFullscreen()) {
               this.fullScreenOverlay = true;
               minYPer = 0;
               minXPer = 0;
            }

            int ox = 100 - o.getXPercent();
            int oy = 100 - o.getYPercent();
            if (ox < minXPer) {
               minXPer = ox;
            }

            if (oy < minYPer) {
               minYPer = oy;
            }
         }
      }

      if (minXPer == 0 && minYPer == 0) {
         this.xRenderExtent = this.yRenderExtent = 0;
      } else if (minXPer == 0) {
         this.xRenderExtent = size.width;
         this.yRenderExtent = (int)((double)size.height * minYPer * 0.01);
      } else if (minYPer == 0) {
         this.xRenderExtent = (int)((double)size.width * minXPer * 0.01);
         this.yRenderExtent = size.height;
      } else {
         this.xRenderExtent = size.width;
         this.yRenderExtent = size.height;
      }
   }

   @Override
   public boolean handle(FrameEvent f) {
      if (this.camera == null) {
         return true;
      } else if (!this.checkForWindow(true)) {
         return true;
      } else {
         EventQueue.pollForEvents(this.camera);
         if (this.w == null) {
            return true;
         } else {
            if (this.mayNeedToResize) {
               this.computeOverlayDimensions();
               this.w.maybeResize(this.xRenderExtent, this.yRenderExtent);
               if (Window.usingMicrosoftVMHacks()) {
                  Point pt = this.getLocationOnScreen();
                  Dimension dim = this.getSize();
                  this.w.reShape(pt.x, pt.y, dim.width, dim.height);
               }

               this.mayNeedToResize = false;
            }

            if (this.camera != null) {
               this.doRender();
            }

            return true;
         }
      }
   }

   public boolean checkForWindow(boolean interceptEvents) {
      if (this.w == null) {
         String title = Console.getFrame().getTitle();
         if (title == null) {
            return false;
         }

         try {
            this.w = new Window(title, this.getLocationOnScreen(), this.getSize(), this.camera, interceptEvents);
         } catch (IllegalComponentStateException var4) {
            return false;
         } catch (WindowNotFoundException var5) {
            return false;
         }

         this.mayNeedToResize = false;
      }

      return true;
   }

   private synchronized void doRender() {
      if (this.universeConsole != null && this.universeConsole.isUniverseMode()) {
         ToolTipManager.toolTipManager().killToolTip();
         if (this.w != null) {
            this.w.hideNativeWindow();
         }
      } else {
         ToolTipManager.toolTipManager().heartbeat();
         this.w.showNativeWindow();
         if (this.fullScreenOverlay) {
            ToolTipManager.toolTipManager().killToolTip();
         } else {
            this.camera.renderToCanvas();
         }
      }
   }

   @Override
   public void removeNotify() {
      if (this.w != null) {
         this.w.dispose();
         this.w = null;
      }

      super.removeNotify();
   }
}