package isac.gui.mawen.editor

 import javax.swing._

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

 import java.awt._

 import java.awt.geom._

 import java.awt.font._

 import edu.tum.cs.isabelle.api.Implementation

 import java.awt.event._

 import java.awt.font._

 import shapeless.Widen

 import org.drools.xml.ExtensibleXmlParser.Null

 import scala.collection.immutable.List

 import isac.gui.mawen.editor.Box.DrawBox

 /**

  * The Java Swing component for a formula

  * represented by an <code>Ast</code>

  */

 class AstComponent(var ast: Ast) extends JComponent with AstContainer with MouseListener with MouseMotionListener {

   addMouseListener(this)

   addMouseMotionListener(this)

   var pressedMousePoint : Point = null

   var marker : Rectangle = new Rectangle()

   var markedBoxes : List[DrawBox] = List.empty[DrawBox]

   var mousePositionFunction : (Graphics, Int, Int, String, Box) => Unit = null

   var box : DrawBox  = null

   setFocusable(true)

   addKeyListener(EventUtil.CreateKeyEventHandler(this))

   addMouseWheelListener(EventUtil.CreateMouseWheelHandler(this))

   setSize(50,150)

   def setAst(ast: Ast) = {

     this.ast = ast

     repaint()

   }

   def getAst() : Ast = this.ast

   override def paint(g: Graphics) = {

     val g2 = g.asInstanceOf[Graphics2D]

     // enable antialiasing for Text

     val rh = new RenderingHints(

       RenderingHints.KEY_TEXT_ANTIALIASING,

       RenderingHints.VALUE_TEXT_ANTIALIAS_ON);

     g2.setRenderingHints(rh);

     // white background

     g.setColor(Color.WHITE)

     g.fillRect(0, 0, getWidth, getHeight)

     g.setColor(Color.BLACK)

     g.translate(Settings.translateX, Settings.translateY)

     g2.scale(Settings.zoom, Settings.zoom)

     Settings.fillStringbounds(ast, g2)

     box =  CalcUtil.assembleBoxes(ast, (box: DrawBox) => 

         {

           if (EventUtil.foreachBoxFunction != null) {

             EventUtil.foreachBoxFunction(g2, box)

           }

         }

       )

       BoxUtil.Draw(box , g)

       setSize((box.width * Settings.zoom).round + 50 + Settings.translateX, Math.max((box.height * Settings.zoom).round, 50)  + Settings.translateY)

       setPreferredSize(getSize)

       EventUtil.foreachBoxFunction = null

       g.drawRect(marker.x, marker.y, marker.width, marker.height)

   }

 	def mouseEntered(e: MouseEvent) {

 	}

 	def mouseExited(e: MouseEvent ) {

 	}

 	def mousePressed(e: MouseEvent ) {

 	  val boxAst : Ast = AstInfoUtil.FindBox(ast)

 	  if (boxAst != null) {

   	  ast =TransformAstUtil.Update(ast, boxAst, TransformAstUtil.UnBox)    

 	  }

 		pressedMousePoint = new Point ( Settings.translateX - e.getX , Settings.translateY - e.getY)

 		marker.setLocation((e.getX / Settings.zoom ).round   -  (Settings.translateX / Settings.zoom).round, 

 		                   (e.getY / Settings.zoom ).round   -  (Settings.translateY / Settings.zoom).round)

 	}

 	def mouseReleased(e: MouseEvent ) {

 		pressedMousePoint = null

 		marker.setSize(0, 0)

 		var highest : DrawBox = findHighesBoxOf(box, markedBoxes)

 		ast = TransformAstUtil.Update(ast, highest.ast, TransformAstUtil.Box)

 		markedBoxes = List.empty[DrawBox]

 		repaint()

 	}

 	def mouseClicked(e: MouseEvent ) {

 		if (e.isControlDown()) {

 		  EventUtil.foreachBoxFunction = EventUtil.doInBox(e.getPoint,

 		      (g, box) => {

   	        ast = TransformAstUtil.Update(ast, box.ast, TransformAstUtil.AstToCursor)

   	        repaint()

 		      }

 		    );

 		}else {

 		  mousePositionFunction = null

 		}

 		repaint()

 	}

   def mouseDragged(e:MouseEvent) {

     if (e.isControlDown() &&  Settings.isdraggingAllowed) {

       if (pressedMousePoint != null) {

     	  Settings.translateX = e.getX + pressedMousePoint.x  

     	  Settings.translateY = e.getY + pressedMousePoint.y 

     	  repaint()

   	  }

     }

     else {

       marker.setSize(((e.getX / Settings.zoom).round - marker.x )  - (Settings.translateX / Settings.zoom).round, 

                      ((e.getY / Settings.zoom).round - marker.y ) - (Settings.translateY / Settings.zoom).round)

       EventUtil.foreachBoxFunction = (g, b) => {

         if (Box.BoxIn(b, marker) && Box.isLeaf(b)) {

           Box.draw(b, g, false)

           if (!markedBoxes.contains(b))

             markedBoxes = b :: markedBoxes 

         }

       }

       repaint()

     }

 	}

 	def mouseMoved(e: MouseEvent ) {

 	  EventUtil.drawBoxAt(e.getPoint())

     repaint()

 	}

   def findHighesBoxOf(rootbox: DrawBox, markedBoxes : List[DrawBox]) : DrawBox = {

     if (markedBoxes.forall(x => Box.Contains(rootbox,x)) && 

         ! rootbox.children.exists(x => markedBoxes.forall(y => Box.Contains(x, y)))

       ) {

       return rootbox

     } else if (markedBoxes.forall(x => Box.Contains(rootbox, x)) && 

         rootbox.children.exists(x => markedBoxes.forall(y => Box.Contains(x, y)))) {

       for( box <- rootbox.children) {

         var resb = findHighesBoxOf(box, markedBoxes)

         if (resb != null) {

           return resb

         }

       }

     }

     return null

   }

 }