package main

import (
	"bytes"
	"fmt"
	"strings"
)

type EvalResult struct {
	vars     Vars
	rules    []*Rule
	ruleVars map[string]Vars
}

type Evaluator struct {
	paramVars    []tmpval // $1 => paramVars[1]
	outVars      Vars
	outRules     []*Rule
	outRuleVars  map[string]Vars
	vars         Vars
	lastRule     *Rule
	currentScope Vars

	filename string
	lineno   int
}

func newEvaluator(vars map[string]Var) *Evaluator {
	return &Evaluator{
		outVars:     make(Vars),
		vars:        vars,
		outRuleVars: make(map[string]Vars),
	}
}

func (ev *Evaluator) Value(v Value) []byte {
	if v, ok := v.(Valuer); ok {
		return v.Value()
	}
	var buf bytes.Buffer
	v.Eval(&buf, ev)
	return buf.Bytes()
}

// TODO(ukai): use unicode.IsSpace?
func isWhitespace(b byte) bool {
	switch b {
	case ' ', '\t', '\n', '\r':
		return true
	}
	return false
}

func (ev *Evaluator) Values(v Value) [][]byte {
	var buf bytes.Buffer
	v.Eval(&buf, ev)
	val := buf.Bytes()
	var values [][]byte
	b := -1
	for i := 0; i < len(val); i++ {
		if b < 0 {
			if isWhitespace(val[i]) {
				continue
			}
			b = i
		} else {
			if isWhitespace(val[i]) {
				values = append(values, val[b:i])
				b = -1
				continue
			}
		}
	}
	if b >= 0 {
		values = append(values, val[b:])
	}
	return values
}

func (ev *Evaluator) evalAssign(ast *AssignAST) {
	ev.lastRule = nil
	lhs, rhs := ev.evalAssignAST(ast)
	Log("ASSIGN: %s=%q (flavor:%q)", lhs, rhs, rhs.Flavor())
	if len(lhs) == 0 {
		Error(ast.filename, ast.lineno, "*** empty variable name.")
	}
	ev.outVars.Assign(lhs, rhs)
}

func (ev *Evaluator) evalAssignAST(ast *AssignAST) (string, Var) {
	ev.filename = ast.filename
	ev.lineno = ast.lineno

	v, _, err := parseExpr([]byte(ast.lhs), nil)
	if err != nil {
		panic(fmt.Errorf("parse %s:%d %v", ev.filename, ev.lineno, err))
	}
	var lhs string
	switch v := v.(type) {
	case literal:
		lhs = string(v)
	case tmpval:
		lhs = string(v)
	default:
		lhs = string(bytes.TrimSpace(ev.Value(v)))
	}
	rhs := ast.evalRHS(ev, lhs)
	return lhs, rhs
}

func (ev *Evaluator) setTargetSpecificVar(assign *AssignAST, output string) {
	vars, present := ev.outRuleVars[output]
	if !present {
		vars = make(Vars)
		ev.outRuleVars[output] = vars
	}
	ev.currentScope = vars
	lhs, rhs := ev.evalAssignAST(assign)
	Log("rule outputs:%q assign:%q=%q (flavor:%q)", output, lhs, rhs, rhs.Flavor())
	vars.Assign(lhs, TargetSpecificVar{v: rhs, op: assign.op})
	ev.currentScope = nil
}

func (ev *Evaluator) evalMaybeRule(ast *MaybeRuleAST) {
	ev.lastRule = nil
	ev.filename = ast.filename
	ev.lineno = ast.lineno

	expr := ast.expr
	if ast.semicolonIndex >= 0 {
		expr = expr[0:ast.semicolonIndex]
	}
	if ast.equalIndex >= 0 {
		expr = expr[0:ast.equalIndex]
	}
	lexpr, _, err := parseExpr([]byte(expr), nil)
	if err != nil {
		panic(fmt.Errorf("parse %s:%d %v", ev.filename, ev.lineno, err))
	}
	line := ev.Value(lexpr)
	if ast.equalIndex >= 0 {
		line = append(line, []byte(ast.expr[ast.equalIndex:])...)
	}
	Log("rule? %q=>%q", ast.expr, line)

	// See semicolon.mk.
	if len(bytes.TrimRight(line, " \t\n;")) == 0 {
		return
	}

	rule := &Rule{
		filename: ast.filename,
		lineno:   ast.lineno,
	}
	assign, err := rule.parse(string(line)) // use []byte?
	if err != nil {
		Error(ast.filename, ast.lineno, "%v", err.Error())
	}
	Log("rule %q => outputs:%q, inputs:%q", line, rule.outputs, rule.inputs)

	// TODO: Pretty print.
	//Log("RULE: %s=%s (%d commands)", lhs, rhs, len(cmds))

	if assign != nil {
		if ast.semicolonIndex >= 0 {
			// TODO(ukai): reuse lexpr above?
			lexpr, _, err := parseExpr([]byte(ast.expr), nil)
			if err != nil {
				panic(fmt.Errorf("parse %s:%d %v", ev.filename, ev.lineno, err))
			}
			assign, err = rule.parse(string(ev.Value(lexpr)))
			if err != nil {
				Error(ast.filename, ast.lineno, "%v", err.Error())
			}
		}
		for _, output := range rule.outputs {
			ev.setTargetSpecificVar(assign, output)
		}
		for _, output := range rule.outputPatterns {
			ev.setTargetSpecificVar(assign, output)
		}
		return
	}

	if ast.semicolonIndex > 0 {
		rule.cmds = append(rule.cmds, ast.expr[ast.semicolonIndex+1:])
	}
	Log("rule outputs:%q cmds:%q", rule.outputs, rule.cmds)
	ev.lastRule = rule
	ev.outRules = append(ev.outRules, rule)
}

func (ev *Evaluator) evalCommand(ast *CommandAST) {
	ev.filename = ast.filename
	ev.lineno = ast.lineno
	if ev.lastRule == nil {
		// This could still be an assignment statement. See
		// assign_after_tab.mk.
		if strings.IndexByte(ast.cmd, '=') >= 0 {
			line := trimLeftSpace(ast.cmd)
			mk, err := ParseMakefileString(line, ast.filename, ast.lineno)
			if err != nil {
				panic(err)
			}
			if len(mk.stmts) == 1 && mk.stmts[0].(*AssignAST) != nil {
				ev.eval(mk.stmts[0])
			}
			return
		}
		Error(ast.filename, ast.lineno, "*** commands commence before first target.")
	}
	ev.lastRule.cmds = append(ev.lastRule.cmds, ast.cmd)
	if ev.lastRule.cmdLineno == 0 {
		ev.lastRule.cmdLineno = ast.lineno
	}
}

func (ev *Evaluator) LookupVar(name string) Var {
	if ev.currentScope != nil {
		v := ev.currentScope.Lookup(name)
		if v.IsDefined() {
			return v
		}
	}
	v := ev.outVars.Lookup(name)
	if v.IsDefined() {
		return v
	}
	return ev.vars.Lookup(name)
}

func (ev *Evaluator) LookupVarInCurrentScope(name string) Var {
	if ev.currentScope != nil {
		v := ev.currentScope.Lookup(name)
		return v
	}
	v := ev.outVars.Lookup(name)
	if v.IsDefined() {
		return v
	}
	return ev.vars.Lookup(name)
}

func (ev *Evaluator) evalInclude(ast *IncludeAST) {
	ev.lastRule = nil
	ev.filename = ast.filename
	ev.lineno = ast.lineno

	Log("%s:%d include %q", ev.filename, ev.lineno, ast.expr)
	// TODO: Handle glob
	v, _, err := parseExpr([]byte(ast.expr), nil)
	if err != nil {
		panic(err)
	}
	files := ev.Values(v)
	for _, f := range files {
		file := string(f)
		Log("Reading makefile %q", file)
		mk, err := ParseMakefile(file)
		if err != nil {
			if ast.op == "include" {
				panic(err)
			} else {
				continue
			}
		}

		makefileList := ev.outVars.Lookup("MAKEFILE_LIST")
		makefileList = makefileList.Append(ev, mk.filename)
		ev.outVars.Assign("MAKEFILE_LIST", makefileList)

		for _, stmt := range mk.stmts {
			ev.eval(stmt)
		}
	}
}

func (ev *Evaluator) evalIf(ast *IfAST) {
	var isTrue bool
	switch ast.op {
	case "ifdef", "ifndef":
		expr, _, err := parseExpr([]byte(ast.lhs), nil)
		if err != nil {
			panic(fmt.Errorf("ifdef parse %s:%d %v", ast.filename, ast.lineno, err))
		}
		vname := ev.Value(expr)
		v := ev.LookupVar(string(vname))
		value := ev.Value(v)
		isTrue = (len(value) > 0) == (ast.op == "ifdef")
		Log("%s lhs=%q value=%q => %t", ast.op, ast.lhs, value, isTrue)
	case "ifeq", "ifneq":
		lexpr, _, err := parseExpr([]byte(ast.lhs), nil)
		if err != nil {
			panic(fmt.Errorf("ifeq lhs parse %s:%d %v", ast.filename, ast.lineno, err))
		}
		rexpr, _, err := parseExpr([]byte(ast.rhs), nil)
		if err != nil {
			panic(fmt.Errorf("ifeq rhs parse %s:%d %v", ast.filename, ast.lineno, err))
		}
		lhs := string(ev.Value(lexpr))
		rhs := string(ev.Value(rexpr))
		isTrue = (lhs == rhs) == (ast.op == "ifeq")
		Log("%s lhs=%q %q rhs=%q %q => %t", ast.op, ast.lhs, lhs, ast.rhs, rhs, isTrue)
	default:
		panic(fmt.Sprintf("unknown if statement: %q", ast.op))
	}

	var stmts []AST
	if isTrue {
		stmts = ast.trueStmts
	} else {
		stmts = ast.falseStmts
	}
	for _, stmt := range stmts {
		ev.eval(stmt)
	}
}

func (ev *Evaluator) eval(ast AST) {
	ast.eval(ev)
}

func Eval(mk Makefile, vars Vars) (er *EvalResult, err error) {
	ev := newEvaluator(vars)
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("panic in eval %s: %v", mk.filename, r)
		}
	}()

	makefile_list := vars.Lookup("MAKEFILE_LIST")
	makefile_list = makefile_list.Append(ev, mk.filename)
	ev.outVars.Assign("MAKEFILE_LIST", makefile_list)

	for _, stmt := range mk.stmts {
		ev.eval(stmt)
	}
	return &EvalResult{
		vars:     ev.outVars,
		rules:    ev.outRules,
		ruleVars: ev.outRuleVars,
	}, nil
}