package isac.gui.mawen.editor

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

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

 import isac.interfaces.IEditor

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

 import javax.swing._

 import java.awt._

 import java.awt.geom._

 import java.awt.font._

 import java.awt.event._

 import java.awt.font._

 import org.drools.xml.ExtensibleXmlParser.Null

 import scala.collection.immutable.List

 /**

  * 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()

   // list of boxes touched by mouse while drawing a rectangle; the outmost is relevant 

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

   var box : DrawBox  = null

   setFocusable(true)

   addKeyListener(EventUtil.CreateKeyEventHandler(this))

   addMouseWheelListener(EventUtil.CreateMouseWheelHandler(this))

   setSize(50,150)

   new Thread(new Runnable() {

     def run() {

       while (true) {

         Thread.sleep(250);

         repaint()

       }

     }

   }).start()

   def setAst(ast: Ast) = {

     this.ast = ast

     repaint()

   }

   def getAst() : Ast = this.ast

   override def paint(g: Graphics) = {

     Settings.g = g

     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)

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

   }

   // /--- enforced by trait MouseListener --------------------------------------\

 	def mouseEntered(e: MouseEvent) {}

 	def mouseExited(e: MouseEvent ) {}

 	def mousePressed(e: MouseEvent ) {

 	  AstInfoUtil.FindBox(ast) match {

 	    case Some(boxAst) => {

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

 	    }

 	    case None => {}

 	  }

 	  val cursorAst : Ast = AstInfoUtil.FindCursor(ast)

 	  if (cursorAst != null) {

   	  ast =TransformAstUtil.Update(ast, cursorAst , TransformAstUtil.CursorToAst)    

 	  }

 		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)

 		findHighestBoxOf(box, markedBoxes) match {

 		  case Some(highest) => {

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

 		  }

 		  case None => {}

 		}

 		markedBoxes = List.empty[DrawBox]

 		repaint()

 	}

 	def mouseClicked(e: MouseEvent ) {

 	  if (e.isControlDown()) {

 	    AstInfoUtil.FindBox(ast) match {

 	      case Some(boxAst) =>  ast =TransformAstUtil.Update(ast, boxAst, TransformAstUtil.UnBox)

 	      case None => {}

 	    }

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

 		      (g, box) => {

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

   	        EventUtil.foreachBoxFunction = null;

   	        repaint()

 		      }

 		    );

 		}

 		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 ) {

 	  if (Settings.drawBoxesOnMouseMove) {

 	    EventUtil.drawBoxAt(e.getPoint())

 	  }

 	  repaint()

 	}

   // \--- enforced by trait MouseMotionListener --------------------------------/

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

     if (markedBoxes != null && rootbox != null && rootbox.children != null) {

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

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

         ) {

         return Some(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) {

           findHighestBoxOf(box, markedBoxes) match {

             case Some(box) => return Some(box)

             case None => {}

           }          

         }

       }

     }

     return None

   }

 }