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

  }

}