package SPAGE.engine.gui;



import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.InvocationEvent;
import java.awt.event.KeyEvent;
import java.awt.image.BufferedImage;
import java.nio.IntBuffer;
import java.util.Hashtable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.ReentrantLock;

import javax.swing.JPanel;

import sun.awt.AppContext;
import sun.awt.SunToolkit;
import sun.util.logging.PlatformLogger.Level;
import javafx.application.Platform;
import javafx.embed.swing.JFXPanel;
import javafx.scene.Scene;
import javafx.scene.image.Image;
import javafx.scene.image.PixelReader;

import com.sun.javafx.application.PlatformImpl;
import com.sun.javafx.cursor.CursorFrame;
import com.sun.javafx.cursor.CursorType;
import com.sun.javafx.cursor.ImageCursorFrame;
import com.sun.javafx.embed.AbstractEvents;
import com.sun.javafx.embed.EmbeddedSceneInterface;
import com.sun.javafx.embed.EmbeddedStageInterface;
import com.sun.javafx.embed.HostInterface;
import com.sun.javafx.stage.EmbeddedWindow;
import com.sun.javafx.tk.Toolkit;

public class GLStagePlatform {

   private volatile EmbeddedWindow stage;
    private volatile Scene scene;
    
    private EmbeddedStageInterface stagePeer;
    private EmbeddedSceneInterface scenePeer;
    private HostContainer hostContainer;
    
    private texupdater tex;
    
    private int width;
    private int height;
    
    private int scaleFactor = 1;
    
    private boolean leftbtn,midbtn,rightbtn;
    private boolean shift,ctrl,alt,meta;
    private boolean dirty=true;
    
    private int mousex,mousey;
    
    private CursorChangeListener cursListen;
 private boolean drawcursor;
 private ImageCursorFrame currentframe;
 
 private Hashtable<CursorType,ImageCursorFrame> cursorimages = new Hashtable<CursorType,ImageCursorFrame>();
 
 ReentrantLock cursorlock = new ReentrantLock();
 
    public boolean getPixels(IntBuffer dest, int width, int height)
    {
       if(scenePeer!=null)
       {
        boolean success=scenePeer.getPixels(dest, width, height);
        
       
       
       if(success)
       {
          
       
          if(drawcursor&&currentframe!=null)
          {
          
             cursorlock.lock();
             System.out.println("draw cursor");
             //NOTE composite the cursor
             
          com.sun.prism.Image img =(com.sun.prism.Image) currentframe.getPlatformImage();
       
             
             
             for(int x=0;x<currentframe.getWidth();x++)
             {
                for(int y=0;y<currentframe.getHeight();y++)
                {
                   
                   int framex=(int) (mousex-currentframe.getHotspotX()+x);
                   int framey=(int) (mousey-currentframe.getHotspotY()+y);
                   
                   
                   if(framex>=0&&framex<=width&&framey>=0&&framey<=height)
                   {
                   
                      int index=framex+(width*framey);
                      
                      int destcolor=dest.get(index);
                      
                      int srccolor=img.getArgb(x, y);
                      
                      int endcolor=AlphaBlend(destcolor,srccolor);
                      
                      dest.put(index, endcolor);
                      
                      
                   }
                }

             }
             cursorlock.unlock();
             
             
          
          }
          
          return true;
       }

       }
       return false;
    }
    
    
    
    public GLStagePlatform(int w, int h, texupdater t)
    {
       tex=t;
       tex.giveplatform(this);
       width=w;
       height=h;
       initFx();
        hostContainer = new HostContainer();
    }
    
    private synchronized static void initFx() {
        // Note that calling PlatformImpl.startup more than once is OK
        PlatformImpl.startup(() -> {
            // No need to do anything here
        });
    }
    
    public void setScene(final Scene newScene) {
        if (Toolkit.getToolkit().isFxUserThread()) {
            setSceneImpl(newScene);
        } else {
            final CountDownLatch initLatch = new CountDownLatch(1);
            Platform.runLater(() -> {
                setSceneImpl(newScene);
                initLatch.countDown();
            });
            try {
                initLatch.await();
            } catch (InterruptedException z) {
                z.printStackTrace(System.err);
            }
        }
    }
    
    private void setSceneImpl(Scene newScene) {
        if ((stage != null) && (newScene == null)) {
            stage.hide();
            stage = null;
        }
        scene = newScene;
        if ((stage == null) && (newScene != null)) {
            stage = new EmbeddedWindow(hostContainer);
        }
        if (stage != null) {
            stage.setScene(newScene);
            if (!stage.isShowing()) {
                stage.show();
               
            }
        }
    }
    
    
    
    public Scene getScene() {
       
    
       
        return scene;
    }
   
    
    private void invokeOnClientEDT(Runnable r) {
        AppContext context = SunToolkit.targetToAppContext(this);
        if (context == null) {
          
            return;
        }
        SunToolkit.postEvent(context, new InvocationEvent(this, r));
    }  
    
    
    
    private class HostContainer implements HostInterface {

      public boolean grabFocus() {
         System.out.println("grabfocus");
         
         return false;
      }

      public void repaint() {
dirty=true;
      }

      public boolean requestFocus() {
         System.out.println("requestfocus");
         return false;
      }

      public void setCursor(CursorFrame cursor) {
         
         if(cursListen!=null)
         {
            cursListen.cursorchanged(cursor);
         }
         
         if(drawcursor)
         {
            cursorlock.lock();
         dirty=true;
            if(cursor instanceof ImageCursorFrame)
            {
               currentframe=(ImageCursorFrame) cursor;
            }
            else
            {
               currentframe=cursorimages.get(cursor.getCursorType());
               
            }
            cursorlock.unlock();
         }
         
         
         
         System.out.println("setcursor"+cursor);
      }

      public void setEmbeddedScene(EmbeddedSceneInterface embeddedScene) {
          if (scenePeer == embeddedScene) {
                return;
            }
            scenePeer = embeddedScene;
            
            if (width > 0 && height > 0) {
                scenePeer.setSize(width, height);
            }
            scenePeer.setPixelScaleFactor(scaleFactor);
         
      }

       public void setEmbeddedStage(EmbeddedStageInterface embeddedStage) {
            stagePeer = embeddedStage;
            if (stagePeer == null) {
                return;
            }
            if (width > 0 && height > 0) {
                stagePeer.setSize(width, height);
            }
   stagePeer.setLocation(0, 0);
           }

      public void setEnabled(boolean arg0) {
         System.out.println("setenabled");
      }

      public void setPreferredSize(int arg0, int arg1) {
         System.out.println("setpreferredsize: "+arg0+" x "+arg1);
      }

      public boolean traverseFocusOut(boolean arg0) {
         
         System.out.println("traversefocusout");
         
         return false;
      }

      public void ungrabFocus() {
         System.out.println("ungrabfocus");
      }
       
       public void giveCursorImage(CursorType type, ImageCursorFrame image)
       {
          cursorimages.put(type, image);
       }
      
      
    }


    public int setupTexture()
    {
       return tex.setup(width, height);
    }
    
    public void update()
    {
       if(dirty)
       {
       tex.update();
       dirty=false;
       }
       
    }
    
    
   public void mousePress(int button)
   {
      if(scenePeer!=null)
      {
         stagePeer.setFocused(true,AbstractEvents.FOCUSEVENT_ACTIVATED);
         
         
     int eventbutton=0;
     switch (button)
     {
     
     case 1:  leftbtn=true; eventbutton=AbstractEvents.MOUSEEVENT_PRIMARY_BUTTON; break;
   
     case 2: rightbtn=true; eventbutton=AbstractEvents.MOUSEEVENT_SECONDARY_BUTTON;break;
     
     case 3: midbtn=true;eventbutton = AbstractEvents.MOUSEEVENT_MIDDLE_BUTTON; break;
     }
     
     
    
     
     scenePeer.mouseEvent(AbstractEvents.MOUSEEVENT_PRESSED,
          eventbutton, leftbtn, midbtn, rightbtn, mousex, mousey, mousex, mousey, 
          shift, ctrl, alt, meta, 0, false);
      }

   }
    
   
   public void mouseRelease(int button)
   {
      

      if(scenePeer!=null)
      {
      int eventbutton=0;
     switch (button)
     {
     
     case 1:  leftbtn=false; eventbutton=AbstractEvents.MOUSEEVENT_PRIMARY_BUTTON; break;
     
     case 2: rightbtn=false; eventbutton=AbstractEvents.MOUSEEVENT_SECONDARY_BUTTON;  break;
     
     case 3: midbtn=false;eventbutton = AbstractEvents.MOUSEEVENT_MIDDLE_BUTTON; break;
     }
     
     scenePeer.mouseEvent(AbstractEvents.MOUSEEVENT_RELEASED,
             eventbutton, leftbtn, midbtn, rightbtn, mousex, mousey, mousex, mousey, 
             shift, ctrl, alt, meta, 0,false);
     

      }
   }
   
   public void mouseMove(int x, int y)
   {
      
      if(drawcursor)
      {
         dirty=true;
      }
      
      
      if(scenePeer!=null)
      {
      mousex=x;mousey=y;
      
      if(leftbtn||midbtn||rightbtn)
      {
         scenePeer.mouseEvent(AbstractEvents.MOUSEEVENT_DRAGGED,
               AbstractEvents.MOUSEEVENT_NONE_BUTTON, leftbtn, midbtn, rightbtn, mousex, mousey, mousex, mousey, 
                shift, ctrl, alt, meta, 0, false);
      }
      else
      {
     
      scenePeer.mouseEvent(AbstractEvents.MOUSEEVENT_MOVED,
            AbstractEvents.MOUSEEVENT_NONE_BUTTON, leftbtn, midbtn, rightbtn, mousex, mousey, mousex, mousey, 
             shift, ctrl, alt, meta, 0, false);
      }
      }
   }
   
   
   public void resize(int w, int h)
   {
      width=w;
      height=h;
      
      if(scenePeer!=null)
      {
         scenePeer.setSize(w, h);
      }
      
      if(stagePeer!=null)
      {
         stagePeer.setSize(w , h );
      }
      
      if(tex!=null)
      {
         tex.resize(w, h);
      }
   }



public void keyPress(int VKcode)
   {
   
   switch(VKcode)
   {
   case KeyEvent.VK_SHIFT:
      shift=true;
      break;
   case KeyEvent.VK_CONTROL:
      ctrl=true;
      break;
   case KeyEvent.VK_ALT:
      alt=true;
      break;
   case KeyEvent.META_DOWN_MASK:
      meta=true;
      break;
      
   }
   
   int modifiers=0;
   
   if(shift)
      modifiers |= AbstractEvents.MODIFIER_SHIFT;
   
   if(ctrl)
      modifiers |= AbstractEvents.MODIFIER_CONTROL;
   
   if(alt)
      modifiers |= AbstractEvents.MODIFIER_ALT;
   
   if(meta)
      modifiers |= AbstractEvents.MODIFIER_META;
   
   char[] c={};
   
   scenePeer.keyEvent(AbstractEvents.KEYEVENT_PRESSED, VKcode, c, modifiers);
   
   
      
   }
   
   public void keyRelease(int VKcode)
   {
      
      switch(VKcode)
      {
      case KeyEvent.VK_SHIFT:
         shift=false;
         break;
      case KeyEvent.VK_CONTROL:
         ctrl=false;
         break;
      case KeyEvent.VK_ALT:
         alt=false;
         break;
      case KeyEvent.META_DOWN_MASK:
         meta=false;
         break;
         
      }
      
      int modifiers=0;
      
      if(shift)
         modifiers |= AbstractEvents.MODIFIER_SHIFT;
      
      if(ctrl)
         modifiers |= AbstractEvents.MODIFIER_CONTROL;
      
      if(alt)
         modifiers |= AbstractEvents.MODIFIER_ALT;
      
      if(meta)
         modifiers |= AbstractEvents.MODIFIER_META;
      
      char[] c={};
      
      scenePeer.keyEvent(AbstractEvents.KEYEVENT_RELEASED, VKcode, c, modifiers);
      
   }
   
   public void keyType(char letter)
   {
      
      
      int modifiers=0;
      
      if(shift)
         modifiers |= AbstractEvents.MODIFIER_SHIFT;
      
      if(ctrl)
         modifiers |= AbstractEvents.MODIFIER_CONTROL;
      
      if(alt)
         modifiers |= AbstractEvents.MODIFIER_ALT;
      
      if(meta)
         modifiers |= AbstractEvents.MODIFIER_META;
      
      
      char[] c = {letter};
      
      scenePeer.keyEvent(AbstractEvents.KEYEVENT_TYPED, com.sun.glass.events.KeyEvent.VK_UNDEFINED, c, modifiers);
   }

   
   public void setCursorChangeListener(CursorChangeListener listen)
   {
      cursListen=listen;
   }
   
   public void drawCursor(boolean draw)
   {
      drawcursor=draw;
   }
   
   
   
   
   public interface texupdater {
      
      public int setup(int w, int h);
      
      public void resize(int w, int h);
      
      public void update();
      
      public void giveplatform(GLStagePlatform plat);

   }
 
   public interface CursorChangeListener
   {
      public void cursorchanged(CursorFrame cursor);
   }

   
    int AlphaBlend( int bg,  int src)
   {
       
       int bA=src&0xff;
       int gA=(src>>8)&0xff;
       int rA=(src>>16)&0xff;
       int aA=(src>>24)&0xff;
       
       int bB=bg&0xff;
       int gB=(bg>>8)&0xff;
       int rB=(bg>>16)&0xff;
       int aB=(bg>>24)&0xff;
       
       
       int rOut = (rA * aA / 255) + (rB * aB * (255 - aA) / (255*255));
             int gOut = (gA * aA / 255) + (gB * aB * (255 - aA) / (255*255));
             int bOut = (bA * aA / 255) + (bB * aB * (255 - aA) / (255*255));
             int aOut = aA + (aB * (255 - aA) / 255);
             
             
             return (aOut<<24)|(rOut<<16)|(gOut<<8)|(bOut);
   }
   
   
}