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

class AstComponent(var ast: Ast, editorPanel: EditorPanel) extends JComponent with AstContainer with MouseListener with MouseMotionListener with MouseWheelListener with ActionListener with KeyListener {

  var isSelected = false

  addMouseListener(this)

  addMouseMotionListener(this)

  addMouseWheelListener(this)

  var pressedMousePoint : Point = null

  var marker : Rectangle = new Rectangle()

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

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

  var box : Box  = null

  setFocusable(true)

  addKeyListener(EventUtil.CreateKeyEventHandler(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)

    box =  Util.assembleBoxes(g, ast, (g2: Graphics, x0: Int, y0: Int, str: String, box: Box) => 

        {

          if (EventUtil.foreachBoxFunction != null) {

            EventUtil.foreachBoxFunction(g2, box)

          }

        }

      )

      BoxUtil.Draw(box , g, editorPanel.field)

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

		isSelected = true

	}

	def mouseExited(e: MouseEvent ) {

		isSelected = false

	}

	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 : Box = findHighesBoxOf(box, markedBoxes)

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

		markedBoxes = List.empty[Box]

		repaint()

	}

	def mouseClicked(e: MouseEvent ) {

		if (e.isControlDown()) {

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

		      (g, box) => {

		        println(isac.gui.mawen.syntax.Ast.raw_string_of(ast))

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

  	        println(isac.gui.mawen.syntax.Ast.raw_string_of(ast))

  	        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 (b.BoxIn(marker) && b.isLeaf()) {

          b.draw(g, false)

          if (!markedBoxes.contains(b))

            markedBoxes = b :: markedBoxes 

        }

      }

      repaint()

    }

	}

	def mouseMoved(e: MouseEvent ) {

	  EventUtil.drawBoxAt(e.getPoint())

    repaint()

	}

  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;

      }

      repaint();

    }

  }

  def actionPerformed(e: ActionEvent): Unit = {

    ast = TransformAstUtil.Update(

        ast, 

        e.getSource().asInstanceOf[AstTextField].getAst,

        e.getSource().asInstanceOf[AstTextField].ToAstFunc)

    editorPanel.field.setVisible(false)

    repaint()

  }

  def keyPressed(event: KeyEvent): Unit = {

  }

  def keyReleased(event: KeyEvent): Unit = {

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

      ast = TransformAstUtil.Update(

        ast, 

        editorPanel.field.getAst,

        editorPanel.field.ToAstFunc)

      editorPanel.field.setVisible(false)

      repaint()

      editorPanel.fireNotifyIsaCheck();

    }

  }

  def keyTyped(event: KeyEvent): Unit = {

  }

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

    println("size: " + markedBoxes.length)

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

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

      ) {

      return rootbox

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

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

      for( box <- rootbox.children) {

        var resb = findHighesBoxOf(box, markedBoxes)

        if (resb != null) {

          return resb

        }

      }

    }

    return null

  }

}