package isac.gui.mawen.editor

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

 import isac.gui.mawen.syntax.Ast

 import java.awt.event.KeyEvent

 /**

  * Edit a formulas listening to key events

  * according to a state-transition-system

  * described in mmahringer Fig.TODO.TODOWN.

  */

 object EditingUtil {

   def parse(c: AstContainer, inputCode: Int) : Unit =  {

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

     val cursorAstElem = AstInfoUtil.AstOfCursor(cursorAst)

     findState(c, cursorAst, inputCode) match {

       case Some(ast) => c.setAst(TransformAstUtil.Update(c.getAst(), cursorAst, TransformAstUtil.ReplaceCursor(ast)))

       case None => {}

     }

   }

   def findState(c: AstContainer, cursorAst: Ast, inputCode: Int) : Option[Ast] = cursorAst match {

     case Appl(List(Variable(str), Constant("CURSOR"))) if str forall Character.isDigit  => numberState(AstInfoUtil.AstOfCursor(cursorAst), inputCode) match {

       case Some(ast) => Some(ast)

       case None => startState(c, inputCode, cursorAst)

     }

     case Appl(List(a, Constant("CURSOR"))) => identState(AstInfoUtil.AstOfCursor(cursorAst), inputCode) match {

       case Some(ast) => Some(ast)

       case None => startState(c, inputCode, cursorAst)

     }case Appl(List(Constant("CURSOR"), Constant("GAP"))) => identState(AstInfoUtil.AstOfCursor(cursorAst), inputCode)

     case _ => startState(c, inputCode, cursorAst)

   }

   def startState(c: AstContainer, inputCode: Int, cursorAst: Ast) : Option[Ast] = {

     println("startstate")

     if (isActionCode(inputCode)) {

       println("action")

       return ActionState(c, -inputCode, cursorAst)

     } else if (isDelim(inputCode) ) {

       return delimerState(c, inputCode.toChar , cursorAst)

     }

     return None

   }

   def identState(cursorAstElem: Ast, inputCode: Int) = cursorAstElem match {

     case Variable(str) if isIdentifier(inputCode) || isNumber(inputCode) => Some(Appl(List(Variable(str + inputCode.toChar), Constant("CURSOR"))))

     case Constant("GAP") if isIdentifier(inputCode) || isNumber(inputCode) => Some(Appl(List(Variable("" + inputCode.toChar), Constant("CURSOR"))))

     case Variable(str) if inputCode == -KeyEvent.VK_BACK_SPACE && str.length() == 1 => Some(Appl(List(Constant("CURSOR"), Constant("GAP"))))

     case Variable(str) if inputCode == -KeyEvent.VK_BACK_SPACE => Some(Appl(List(Variable(str.slice(0, str.length - 1)), Constant("CURSOR"))))

     case _ => None

   }

   def numberState(cursorAstElem: Ast, inputCode: Int) : Option[Ast] = cursorAstElem match {

     case Variable(str) if (isNumber(inputCode.toChar))                             =>  Some(Appl(List(Variable(str + inputCode.toChar), Constant("CURSOR"))))

     case Constant("GAP") if isIdentifier(inputCode) || isNumber(inputCode)         => Some(Appl(List(Variable("" + inputCode.toChar), Constant("CURSOR"))))

     case Variable(str) if inputCode == -KeyEvent.VK_BACK_SPACE && str.length() == 1 => Some(Appl(List(Constant("CURSOR"), Constant("GAP"))))

     case Variable(str) if inputCode == -KeyEvent.VK_BACK_SPACE                      => Some(Appl(List(Variable(str.slice(0, str.length - 1)), Constant("CURSOR"))))

     case _ => {

       println("none")

       None

     }

   }

   def ActionState(c: AstContainer, code: Int, cursorAst: Ast) : Option[Ast] = code match {

     case KeyEvent.VK_RIGHT => TransformAstUtil.CursorNextChild(c); None

     case KeyEvent.VK_LEFT => TransformAstUtil.CursorPrevChild(c); None

     case KeyEvent.VK_UP => TransformAstUtil.CursorParent(c); None

     case KeyEvent.VK_DOWN => TransformAstUtil.CursorChild(c); None

     case KeyEvent.VK_ENTER => cursorAst match {

       case Appl(List(Constant("CURSOR"), a)) => Some(a)

       case Appl(List(a, Constant("CURSOR"))) => Some(a)

       case _ => None

     }

     case KeyEvent.VK_DELETE => Some(Appl(List(Constant("CURSOR"),Constant("GAP"))))

     case KeyEvent.VK_F2 => {

       val b = AstInfoUtil.FindBox(c.getAst())

       if (b == null) {

         return None

       }

       println(b)

       c.setAst(TransformAstUtil.Update(c.getAst(), b, (a) => a match {

         case Appl(List(Constant(str), ast)) if str.startsWith("BOX") => Appl(List(Constant("CURSOR"), ast))

       }))

       None

     }

   }

   def delimerState(c: AstContainer, input: Character, cursorAst: Ast) : Option[Ast] =  AstInfoUtil.AstOfCursor(cursorAst) match {

     case Variable(str)   if input == '(' && isLongDelim(str)

       => Some(ReplaceFirstGap(

            Settings.OperatorToAst(str),

            Appl(List(Constant("CURSOR"), Constant("GAP")))))

     case Variable(str)

       => Some(ReplaceFirstGap(

            ReplaceFirstGap(

              Settings.OperatorToAst(input.toString()),

              Variable(str)),

            Appl(List(Constant("CURSOR"), Constant("GAP")))))

     case Appl(asts)

       => Some(ReplaceFirstGap(

            ReplaceFirstGap(

              Settings.OperatorToAst(input.toString()),

              Appl(asts)),

            Appl(List(Constant("CURSOR"), Constant("GAP")))))

     case Constant("GAP") => Some(Settings.OperatorToAst(input.toString()))

     case Constant(str) => {

       val operatorParams = AstInfoUtil.Parent(c.getAst(), cursorAst).asInstanceOf[Appl].name.tail

       var newOperatorAst = Settings.OperatorToAst(input.toString())

       for(a <- operatorParams) {

         newOperatorAst = ReplaceFirstGap(newOperatorAst, a)

       }

       newOperatorAst = newOperatorAst match { 

         case Appl(c::a) => Appl(Appl(List(c, Constant("CURSOR"))) :: a) 

         case _ => Constant("GAP")

         } 

       c.setAst(TransformAstUtil.Update(c.getAst(), AstInfoUtil.Parent(c.getAst(), cursorAst), (a) =>  newOperatorAst))

       None

     }

   }

   def isNumber(ch: Integer) : Boolean = ch >= '0' && ch <= '9'

   def isIdentifier(ch: Integer) : Boolean = (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') 

   def isDelim(ch: Integer) : Boolean=  List('+', '-', '*', '/', '(', '=').contains(ch)

   def isActionCode(code: Integer) : Boolean = code == -KeyEvent.VK_ENTER ||

                                            code == -KeyEvent.VK_LEFT ||

                                            code == -KeyEvent.VK_UP ||

                                            code == -KeyEvent.VK_RIGHT || 

                                            code == -KeyEvent.VK_DOWN || 

                                            code == -KeyEvent.VK_DELETE ||

                                            code == -KeyEvent.VK_F2

   //TODOWN rename to isLongOp

   def isLongDelim(ch: String) : Boolean=  Settings.layout.keys.filter(x => x.length() > 1).toList.contains(ch)

   //TODOWN delete

   def OperatorToAst(ch: Character) : Ast = Settings.OperatorToAst(ch.toString())

   def ReplaceFirstGap(ast: Ast, replace: Ast) : Ast = ast match {

     case Appl(Constant("GAP") :: asts)      => Appl(replace :: asts)

     case Appl(a :: Constant("GAP") :: asts) => Appl(a :: replace :: asts)

     case Appl(Appl(iasts):: oasts)          => Appl(ReplaceFirstGap(Appl(iasts), replace) :: oasts)

     case Appl(a :: asts)                    => Appl(a :: ReplaceFirstGap(Appl(asts), replace).asInstanceOf[Appl].name)

     case a                                  => a

   }

 }