package isac.gui.mawen.editor

 import java.awt.Graphics

 import java.awt.Point

 import java.util.ArrayList

 import java.awt.event.KeyListener

 import java.awt.event.KeyEvent

 import isac.gui.mawen.syntax.Ast

 import java.awt.event.MouseWheelListener

 import java.awt.event.MouseWheelEvent

 import java.awt.event.MouseMotionListener

 import java.awt.event.MouseEvent

 import isac.gui.mawen.editor.Box._

 import javafx.scene.input.KeyCode

 import java.awt.Toolkit

 import isac.gui.mawen.syntax.Ast.Variable

 import java.awt.datatransfer.DataFlavor

 import isac.gui.mawen.syntax.Ast._

 import java.awt.datatransfer.StringSelection

 /**

  * Event handler for <code>AstComponent</code>

  */

 object EventUtil {

   var foreachBoxFunction : (Graphics, DrawBox) => Unit = null

   def drawBoxAt(p: Point) = {

     foreachBoxFunction = EventUtil.doInBox(p, (g, box) => {

         Box.draw(box, g, false)

       }

     )

   }

   /*

    * return-value is stored in <code>foreachBoxFunction</code>

    */

   def doInBox(mousePos: Point, f: (Graphics, DrawBox) => Unit) : 

       (Graphics, DrawBox) => Unit = {

 	  (g: Graphics, box: DrawBox) => {

 	    val xfrom = box.x * Settings.zoom + Settings.translateX

   	  val xto   = box.x * Settings.zoom + Settings.translateX 

   	    + box.width  * Settings.zoom

   	  val yfrom = box.y * Settings.zoom + Settings.translateY 

         - box.height * Settings.zoom

   	  val yto   = box.y * Settings.zoom + Settings.translateY

   	  if (xfrom < mousePos.x && xto > mousePos.x && 

   	      yfrom < mousePos.y && yto > mousePos.y)

   	    f(g, box)

 	  }

 	}

   //TODOWN unused

   def CreateMouseMotionHandler(c: AstContainer) : MouseMotionListener = new MouseMotionListener() {

     def mouseDragged(e:MouseEvent) {

   	}

   	def mouseMoved(e: MouseEvent ) {

   	}

   }

   def CreateMouseWheelHandler(c: AstContainer) : MouseWheelListener = new MouseWheelListener() {

     def mouseWheelMoved(e: MouseWheelEvent): Unit = {

       if (Settings.isZoomAllowed) {

         if (e.getPreciseWheelRotation() < 0) {

           Settings.zoom -= 0.1f;

         } else {

           Settings.zoom += 0.1f;

         }

         if (Settings.zoom < 0.01f) {

           Settings.zoom = 0.01f;

         }

       }

       c.repaint()

     }

   }

   def CreateKeyEventHandler(c: AstContainer) : KeyListener = new KeyListener () {

     def keyPressed(event: KeyEvent): Unit = {

       if (event.getKeyCode == KeyEvent.VK_BACK_SPACE) { 

         EditingUtil.parse(c, -event.getKeyCode)

       }

     }

     def keyReleased(event: KeyEvent): Unit = {

       if (AstInfoUtil.hasBox(c.getAst())) {

         println("has Box")

          if (event.getKeyCode == KeyEvent.VK_DOWN) {

            TransformAstUtil.BoxChild(c)

          }else if (event.getKeyCode == KeyEvent.VK_RIGHT) {

            TransformAstUtil.BoxPrevChild(c)

          }else if (event.getKeyCode == KeyEvent.VK_LEFT) {

             TransformAstUtil.BoxNextChild(c)

          }else if (event.getKeyCode == KeyEvent.VK_UP) {

            TransformAstUtil.BoxParent(c)

          }

         EditorListenerHandler.fireNotifysBraille(c, AstInfoUtil.FindBox(c.getAst()))

       } else if (AstInfoUtil.hasCursor(c.getAst())) {

         println("has Cursor")

         EditingUtil.parse(c, -event.getKeyCode)

       }

       if (event.getKeyCode == KeyEvent.VK_DOWN) {

         TransformAstUtil.CursorChild(c)

       } else if (event.getKeyCode == KeyEvent.VK_RIGHT) {

         TransformAstUtil.CursorPrevChild(c)

       } else if (event.getKeyCode == KeyEvent.VK_LEFT) {

          TransformAstUtil.CursorNextChild(c)

       }else if (event.getKeyCode == KeyEvent.VK_UP) {

          TransformAstUtil.CursorParent(c)

       }else if (event.isControlDown() && event.getKeyCode == KeyEvent.VK_ENTER) {

         val boxAst : Ast = AstInfoUtil.FindBox(c.getAst())

     	  if (boxAst != null) {

       	  c.setAst(TransformAstUtil.Update(c.getAst(), boxAst, TransformAstUtil.UnBox))

     	  }

     	  val cursorAst : Ast = AstInfoUtil.FindCursor(c.getAst())

     	  if (cursorAst != null) {

       	  c.setAst(TransformAstUtil.Update(c.getAst(), cursorAst , TransformAstUtil.CursorToAst))

     	  }

         EditorListenerHandler.fireNotifyIsaCheck(c)

       }else if (event.isControlDown() && event.getKeyCode == KeyEvent.VK_V) {

         // !!!! Dirty Code !!!!

         c.setAst(Variable(Toolkit.getDefaultToolkit().getSystemClipboard().getData(DataFlavor.stringFlavor).asInstanceOf[String]))

         EditorListenerHandler.fireNotifyIsaCheck(c)

       }else if (event.isControlDown() && event.getKeyCode == KeyEvent.VK_C) {

         val astString = new StringSelection(Ast.math_string_of(c.getAst()))

         Toolkit.getDefaultToolkit().getSystemClipboard().setContents(astString, null)

         EditorListenerHandler.fireNotifyIsaCheck(c)

       }

       else if (

           (event.getKeyChar >= '0' && event.getKeyChar <= '9') 

           || (event.getKeyChar >= 'a' && event.getKeyChar <= 'z')

           || (event.getKeyChar >= 'A' && event.getKeyChar <= 'Z')

           || List('+', '-', '*', '/', '(', '=').contains(event.getKeyChar)) {

         EditingUtil.parse(c, event.getKeyChar.toInt)

         EditorListenerHandler.fireNotifysBraille(c, AstInfoUtil.FindBox(c.getAst()))

       } else if (

           event.getKeyCode == KeyEvent.VK_ENTER || 

           event.getKeyCode == KeyEvent.VK_DELETE || 

           event.getKeyCode == KeyEvent.VK_F2) {

         EditingUtil.parse(c, -event.getKeyCode)

       }

       if (event.getKeyCode == KeyEvent.VK_ENTER)

         println(c.getAst()) // Output ast on key enter

     }

     def keyTyped(event: KeyEvent): Unit = {

     }

   }

 }