/*
 * ECAL
 *
 * Copyright 2020 Matthias Ladkau. All rights reserved.
 *
 * This Source Code Form is subject to the terms of the MIT
 * License, If a copy of the MIT License was not distributed with this
 * file, You can obtain one at https://opensource.org/licenses/MIT.
 */

package interpreter

import (
	"fmt"
	"strings"

	"devt.de/krotik/common/stringutil"
	"devt.de/krotik/ecal/parser"
	"devt.de/krotik/ecal/scope"
	"devt.de/krotik/ecal/stdlib"
	"devt.de/krotik/ecal/util"
)

/*
identifierRuntime is the runtime component for identifiers.
*/
type identifierRuntime struct {
	*baseRuntime
}

/*
identifierRuntimeInst returns a new runtime component instance.
*/
func identifierRuntimeInst(erp *ECALRuntimeProvider, node *parser.ASTNode) parser.Runtime {
	return &identifierRuntime{newBaseRuntime(erp, node)}
}

/*
Eval evaluate this runtime component.
*/
func (rt *identifierRuntime) Eval(vs parser.Scope, is map[string]interface{}, tid uint64) (interface{}, error) {
	var res interface{}
	_, err := rt.baseRuntime.Eval(vs, is, tid)
	if err == nil {
		res, err = rt.resolveValue(vs, is, tid, rt.node)
	}
	return res, err
}

/*
resolveValue resolves the value of this identifier.
*/
func (rt *identifierRuntime) resolveValue(vs parser.Scope, is map[string]interface{}, tid uint64, node *parser.ASTNode) (interface{}, error) {
	var anode *parser.ASTNode
	var astring string
	var result interface{}
	var err error

	functionResolved := func(astring string, rnode *parser.ASTNode) *parser.ASTNode {

		res := &parser.ASTNode{ // Create a dummy identifier which models the value evaluation so far
			Name: parser.NodeIDENTIFIER,
			Token: &parser.LexToken{
				ID:         node.Token.ID,
				Identifier: node.Token.Identifier,
				Lline:      node.Token.Lline,
				Lpos:       node.Token.Lpos,
				Pos:        node.Token.Pos,
				Val:        strings.Replace(astring, ".", ">", -1),
			},
			Children: nil,
		}

		for i, c := range rnode.Children {
			if c.Name == parser.NodeFUNCCALL {
				res.Children = rnode.Children[i+1:]
			}
		}

		return res
	}

	anode, astring, err = buildAccessString(rt.erp, vs, is, tid, node, node.Token.Val)

	if len(node.Children) == 0 {

		// Simple case we just have a variable

		result, _, err = vs.GetValue(node.Token.Val)

	} else if cval, ok := stdlib.GetStdlibConst(astring); ok {

		result = cval

	} else {

		if rerr, ok := err.(*util.RuntimeError); err == nil || ok && rerr.Type == util.ErrInvalidConstruct {
			funcCallInAccessStringExecuted := ok && rerr.Type == util.ErrInvalidConstruct

			if result, _, err = vs.GetValue(astring); err == nil {

				if funcCallInAccessStringExecuted {

					result, err = rt.resolveFunction(astring, vs, is, tid, rerr.Node, result, err)

					node = functionResolved(astring, anode)

					if len(node.Children) > 0 {

						// We have more identifiers after the func call - there is more to do ...

						vs = scope.NewScope("funcresult")
						vs.SetValue(node.Token.Val, result)

						result, err = rt.resolveValue(vs, is, tid, node)
					}
				} else {

					result, err = rt.resolveFunction(astring, vs, is, tid, node, result, err)
				}
			}
		}
	}

	return result, err
}

/*
resolveFunction execute function calls and return the result.
*/
func (rt *identifierRuntime) resolveFunction(astring string, vs parser.Scope, is map[string]interface{},
	tid uint64, node *parser.ASTNode, result interface{}, err error) (interface{}, error) {

	is["erp"] = rt.erp      // All functions have access to the ECAL Runtime Provider
	is["astnode"] = rt.node // ... and the AST node

	for _, funccall := range node.Children {

		if funccall.Name == parser.NodeFUNCCALL {
			var funcObj util.ECALFunction

			ok := astring == "log" || astring == "error" || astring == "debug"

			if !ok {

				funcObj, ok = result.(util.ECALFunction)

				if !ok {

					// Check for stdlib function

					funcObj, ok = stdlib.GetStdlibFunc(astring)

					if !ok {

						// Check for inbuild function

						funcObj, ok = InbuildFuncMap[astring]
					}
				}
			}

			if ok {
				var args []interface{}

				// Collect the parameter values

				for _, c := range funccall.Children {
					var val interface{}

					if err == nil {
						val, err = c.Runtime.Eval(vs, make(map[string]interface{}), tid)
						args = append(args, val)
					}
				}

				if err == nil {

					if astring == "log" || astring == "error" || astring == "debug" {

						// Convert non-string structures

						for i, a := range args {
							if _, ok := a.(string); !ok {
								args[i] = stringutil.ConvertToPrettyString(a)
							}
						}

						if astring == "log" {
							rt.erp.Logger.LogInfo(args...)
						} else if astring == "error" {
							rt.erp.Logger.LogError(args...)
						} else if astring == "debug" {
							rt.erp.Logger.LogDebug(args...)
						}

					} else {

						if rt.erp.Debugger != nil {
							rt.erp.Debugger.VisitStepInState(node, vs, tid)
						}

						// Execute the function

						result, err = funcObj.Run(rt.instanceID, vs, is, tid, args)

						if rt.erp.Debugger != nil {
							rt.erp.Debugger.VisitStepOutState(node, vs, tid)
						}

						_, ok1 := err.(*util.RuntimeError)
						_, ok2 := err.(*util.RuntimeErrorWithDetail)

						if err != nil && !ok1 && !ok2 {

							// Convert into a proper runtime error if necessary

							rerr := rt.erp.NewRuntimeError(util.ErrRuntimeError,
								err.Error(), node).(*util.RuntimeError)

							if err == util.ErrIsIterator || err == util.ErrEndOfIteration || err == util.ErrContinueIteration {
								rerr.Type = err
							}

							err = rerr
						}

						if tr, ok := err.(util.TraceableRuntimeError); ok {

							// Add tracing information to the error

							tr.AddTrace(rt.node)
						}
					}
				}

			} else {

				err = rt.erp.NewRuntimeError(util.ErrUnknownConstruct,
					fmt.Sprintf("Unknown function: %v", node.Token.Val), node)
			}

			break
		}
	}

	return result, err
}

/*
Set sets a value to this identifier.
*/
func (rt *identifierRuntime) Set(vs parser.Scope, is map[string]interface{}, tid uint64, value interface{}) error {
	var err error

	if len(rt.node.Children) == 0 {

		// Simple case we just have a variable

		err = vs.SetValue(rt.node.Token.Val, value)

	} else {
		var as string

		_, as, err = buildAccessString(rt.erp, vs, is, tid, rt.node, rt.node.Token.Val)

		if err == nil {

			// Collect all the children and find the right spot

			err = vs.SetValue(as, value)
		}
	}

	return err
}

/*
buildAccessString builds an access string using a given node and a prefix.
*/
func buildAccessString(erp *ECALRuntimeProvider, vs parser.Scope, is map[string]interface{},
	tid uint64, node *parser.ASTNode, prefix string) (*parser.ASTNode, string, error) {

	var err error
	res := prefix

	for i, c := range node.Children {

		if err == nil {

			// The unexpected construct error is used in two ways:
			// 1. Error message when a function call is used on the left hand of
			// an assignment.
			// 2. Signalling there is a function call involved on the right hand
			// of an assignment.

			if c.Name == parser.NodeCOMPACCESS {
				var val interface{}
				val, err = c.Children[0].Runtime.Eval(vs, is, tid)
				res = fmt.Sprintf("%v.%v", res, val)

				if len(node.Children) > i+1 && node.Children[i+1].Name == parser.NodeFUNCCALL {

					err = erp.NewRuntimeError(util.ErrInvalidConstruct,
						"Unexpected construct", node)
					break
				}

			} else if c.Name == parser.NodeIDENTIFIER {

				res = fmt.Sprintf("%v.%v", res, c.Token.Val)

				if len(c.Children) > 0 && c.Children[0].Name == parser.NodeFUNCCALL {
					node = c

					err = erp.NewRuntimeError(util.ErrInvalidConstruct,
						"Unexpected construct", node)
					break
				}

				node, res, err = buildAccessString(erp, vs, is, tid, c, res)
			}
		}
	}

	return node, res, err
}