compile.mml

use (
	. "lang"
	  "strings"
	  "code"
	  "lists"
	  "structs"
	  "snippets"
	  "codetree"
)

fn primitive(code) string(code.value)

let (
	intLiteral   primitive
	floatLiteral primitive
	boolLiteral  primitive
)

fn stringLiteral(s) formats("\"%s\"", strings.escape(s.value))

fn symbol(s) formats("_%s", s.name)

fn spread(s) formats("%s.(*mml.List).Values...", do(s.value))

fn list(l) {
	fn (
		isSpread(c)     len(c) > 3 && c[len(c) - 3:] == "..."
		selectSpread(c) isSpread(c) ? {spread: c} : c
	)

	let groupSpread fold(fn (item, groups) {
		let (
			i             len(groups) - 1
			isSpread      has("spread", item)
			groupIsSpread i >= 0 && has("spread", groups[i])
		)

		fn (
			appendNewSimple() [groups..., {simple: [item]}]
			appendNewSpread() [groups..., {spread: [item.spread]}]
			appendSimple()    [groups[:i]..., {simple: [groups[i].simple..., item]}]
			appendSpread()    [groups[:i]..., {spread: [groups[i].spread..., item.spread]}]
		)

		switch {
		case (i < 0 || groupIsSpread) && !isSpread:
			return appendNewSimple()
		case (i < 0 || !groupIsSpread) && isSpread:
			return appendNewSpread()
		case !groupIsSpread && !isSpread:
			return appendSimple()
		case groupIsSpread && isSpread:
			return appendSpread()
		}
	}, [])

	fn (
		appendSimples(code, group) formats("append(%s, %s)", code, join(", ", group))
		appendSpread(item, code)   formats("append(%s, %s)", code, item)
		appendSpreads(code, group) fold(appendSpread, code, group)
		appendGroups(groups)       fold(appendGroup, "[]interface{}{}", groups)
	)

	fn appendGroup(group, code) has("spread", group) ?
		appendSpreads(code, group.spread) :
		appendSimples(code, group.simple)

	return l.values
		-> map(do)
		-> map(selectSpread)
		-> groupSpread
		-> appendGroups
		-> fn (c) formats("&mml.List{Values: %s}", c)
}

fn expressionKey(k) do(k.value)

fn struct(s) {
	fn entry(e) {
		let v do(e.value)
		switch e.type {
		case "spread":
			let (
				var    formats("sp := %s.(*mml.Struct);", v)
				assign "for k, v := range sp.Values { s.Values[k] = v };"
			)

			return formats("func() { %s; %s }();\n", var, assign)
		default:
			switch e.key.type {
			case "string":
				return formats("s.Values[%s] = %s;", do(e.key), v)
			case "symbol":
				return formats("s.Values[\"%s\"] = %s;", e.key.name, v)
			default:
				return formats("s.Values[%s.(string)] = %s;", do(e.key), v)
			}
		}
	}

	return formats(
		"func() interface{} { s := &mml.Struct{Values: make(map[string]interface{})}; %s; return s }()"
		s.entries -> map(entry) -> join("")
	)
}

fn getDefinitions(statementList) {
	let definitions = statementList.statements
		-> filter(is({type: "definition"}))

	let definitionsFromGroups = statementList.statements
		-> filter(is({type: "definition-group"}))
		-> map(structs.get("definitions"))
		-> flat
	
	return [
		definitions...
		definitionsFromGroups...
	]
}

fn getScope(statementList) {
	let definitions = statementList -> getDefinitions -> map(structs.get("symbol"))
	
	let uses = statementList.statements
		-> filter(is({type: "use-list"}))
		-> map(structs.get("uses"))
		-> flat
	
	let (
		unnamedUses = uses -> filter(is(not({capture: any}))) -> map(structs.get("path")) -> map(structs.get("value"))
		namedUses   = uses -> filter(is({capture: not(".")})) -> map(structs.get("capture"))
	)

	let inlineUses = uses
		-> filter(is({capture: "."}))
		-> map(structs.get("module"))
		-> map(structs.get("body"))
		-> map(getDefinitions)
		-> flat
		-> filter(is({exported: true}))
		-> map(structs.get("symbol"))
	
	return flats(
		definitions
		unnamedUses
		namedUses
		inlineUses
	)
}

fn paramList(params, collectParam) {
	let (
		paramFormat        = "var _%s = a[%d]"
		collectParamFormat = "var _%s interface{}; _%s = &mml.List{a[%d:]}"
		paramsString       = params -> lists.indexes -> map(fn (i) formats(paramFormat, params[i], i))
		collectParamString = formats(collectParamFormat, collectParam, collectParam, len(params))
	)

	return join(";\n", [paramsString..., collectParamString])
}

fn functionLiteral(f) {
	let paramNames f.collectParam == "" ? f.params : [f.params..., f.collectParam]

	let statementListFormat = "&mml.Function{
		F: func(a []interface{}) interface{} {
			var c interface{}
			mml.Nop(c)
			%s;
			mml.Nop(%s);
			%s;
			return nil
		},
		FixedArgs: %d,
	}"

	let expressionFormat = "&mml.Function{
		F: func(a []interface{}) interface{} {
			var c interface{}
			mml.Nop(c)
			%s;
			mml.Nop(%s);
			return %s
		},
		FixedArgs: %d,
	}"

	return formats(
		is({type: "statement-list"}, f.body) ? statementListFormat : expressionFormat
		paramList(f.params, f.collectParam)
		join(", ", map(strings.formatOne("_%s"), [paramNames...]))
		do(f.body)
		len(f.params)
	)
}

fn indexer(i) {
	switch {
	case is({type: "range"}, i.index):
		return formats(
			"mml.RefRange(%s, %s, %s)"
			do(i.expression)
			is({from: any}, i.index) ? do(i.index.from) : "nil"
			is({to: any}, i.index) ? do(i.index.to) : "nil"
		)
	case is({type: "symbol-index"}, i.index):
		return formats(
			"mml.Ref(%s, \"%s\")"
			do(i.expression)
			i.index.symbol.name
		)
	default:
		return formats(
			"mml.Ref(%s, %s)"
			do(i.expression)
			do(i.index)
		)
	}
}

fn application(a) formats(
	is({function: {type: "function"}}, a) ?
		"(%s).Call((%s).Values)" :
		"%s.(*mml.Function).Call((%s).Values)"
	do(a.function)
	list({values: a.args})
)

fn unary(u)
	u.op == code.logicalNot ?
	formats(is({type: "bool"}, u.arg) ? "!%s" : "!%s.(bool)", do(u.arg)) :
	formats("mml.UnaryOp(%d, %s)", u.op, do(u.arg))

fn binary(b) {
	if !is(or(code.logicalAnd, code.logicalOr), b.op) {
		return formats(
			"mml.BinaryOp(%d, %s, %s)"
			b.op
			do(b.left)
			do(b.right)
		)
	}

	fn isBoolOp(c) is({
		type: or("unary", "binary")
		op:   or(code.logicalNot, code.logicalAnd, code.logicalOr)
	}, c)

	fn (
		isBoolValue(c)         is({type: "bool"}, c)
		convertIfNotBool(c, s) isBoolValue(c) || isBoolOp(c) ? s : s + ".(bool)"
	)

	let (
		left  = b.left -> do -> convertIfNotBool(b.left)
		right = b.right -> do -> convertIfNotBool(b.right)
		op    = b.op == code.logicalAnd ? "&&" : "||"
	)

	return formats("(%s %s %s)", left, op, right)
}

fn ternary(c) formats(
	"func () interface{} { c = %s; if c.(bool) { return %s } else { return %s } }()"
	do(c.condition)
	do(c.consequent)
	do(c.alternative)
)

fn ifStatement(c)
	is({alternative: any}, c) ?
	formats(
		"c = %s; if c.(bool) { %s } else { %s }"
		do(c.condition)
		do(c.consequent)
		do(c.alternative)
	) :
	formats(
		"c = %s; if c.(bool) { %s }"
		do(c.condition)
		do(c.consequent)
	)

fn cond(c) c.ternary ? ternary(c) : ifStatement(c)

fn caseBlock(c) formats("case %s:\n%s", do(c.expression), do(c.body))

fn switchStatement(s) {
	let (
		hasDefault  len(s.defaultStatements.statements) > 0
		cases       s.cases -> map(do)
		def         hasDefault ? do(s.defaultStatements) : ""
		defaultCode hasDefault ? formats("default:\n%s", def) : ""
	)

	return formats(
		"switch %s {\n%s\n}"
		is({expression: any}, s) ? do(s.expression) : ""
		(hasDefault ? [cases..., defaultCode] : cases) -> join("\n")
	)
}

fn sendStatement(s) formats("%s <- %s", do(s.channel), do(s.value))

fn receiveExpression(r) formats("<-%s", do(r.channel))

fn goStatement(g) formats("go %s", do(g.application))

fn deferStatement(d) formats(
	is({application: {function: {type: "function"}}}, d) ?
		"c = (%s); defer c.Call((%s).Values)" :
		"defer %s.(*mml.Function).Call((%s).Values)"
	do(d.application.function)
	list({values: d.application.args})
)

fn selectStatement(s)
	s.cases
	-> map(do)
	-> fn (c) (
		s.hasDefault ?
		[
			c...
			s.defaultStatements
				-> do
				-> strings.formatOne("default:\n%s")
		] :
		c
	)
	-> join("\n")
	-> strings.formatOne("func() interface{} {\nselect {\n%s\n} }()")

fn rangeOver(r) {
	fn infiniteCounter() formats(
		"_%s := 0; true; _%s++"
		r.symbol
		r.symbol
	)

	fn withRangeExpression() formats(
		"_%s := %s; %s; _%s++"
		r.symbol
		has("from", r.expression) ? do(r.expression.from) : "0"
		has("to", r.expression) ?
			formats("_%s < %s.(int)", r.symbol, do(r.expression.to)) :
			"true"
		r.symbol
	)

	// TODO:
	// - should work for struct, too
	// - the arg should be called with nop() (only if don't check in advance?)
	fn listStyleRange() formats(
		"_, _%s := range %s.(*mml.List).Values"
		r.symbol
		do(r.expression)
	)

	switch {
	case !has("expression", r):
		return infiniteCounter()
	case is({type: "range"}, r.expression):
		return withRangeExpression()
	default:
		return listStyleRange()
	}
}

fn (
	breakStatement(_)    "break"
	continueStatement(_) "continue"
)

fn loop(l) formats(
	"for %s {\n%s\n}"
	has("expression", l) ? do(l.expression) : ""
	do(l.body)
)

fn definition(d)
	d.exported ?
	formats(
		"_%s = %s; exports[\"%s\"] = _%s"
		d.symbol
		do(d.expression)
		d.symbol
		d.symbol
	) :
	formats(
		"_%s = %s"
		d.symbol
		do(d.expression)
	)

fn definitionGroup(g) g.definitions -> map(do) -> join(";\n")

fn assign(a)
	a.capture.type == "symbol" ?
	formats(
		"%s = %s"
		do(a.capture)
		do(a.value)
	) :
	formats(
		"mml.SetRef(%s, %s, %s)"
		do(a.capture.expression)
		do(a.capture.index)
		do(a.value)
	)

fn ret(r) has("value", r) ?
	formats("return %s", do(r.value)) :
	"return"

fn checkRet(r) formats(
	"if v := %s; mml.IsError.F([]interface{}{v}).(bool) { return v }"
	do(r.value)
)

fn useStatement(u) {
	switch {
	case is({capture: "."}, u):
		let statement formats(
			"var __%s = mml.Modules.Use(\"%s\");"
			code.getModuleName(u.path.value)
			u.path.value
		)

		let assigns map(fn (name)
			formats(
				"_%s = __%s.Values[\"%s\"]"
				name
				code.getModuleName(u.path.value)
				name
			)
			u.module.body
			-> getDefinitions
			-> filter(is({exported: true}))
			-> map(structs.get("symbol"))
		)
		-> join(";\n")

		return joins(";", statement, assigns)
	case is({capture: any}, u):
		return formats(
			"_%s = mml.Modules.Use(\"%s\")"
			u.capture
			u.path.value
		)
	default:
		return formats(
			"_%s = mml.Modules.Use(\"%s\")"
			code.getModuleName(u.path.value)
			u.path.value
		)
	}
}

fn useList(u) u.uses -> map(do) -> join(";\n")

fn module(m) joins(
	"\n"
	formats("modulePath = \"%s\"", m.path)
	snippets.moduleHead
	do(m.body)
	snippets.moduleFooter
)

fn statementList(l) {
	let (
		scope      getScope(l)
		scopeNames join(", ", map(bind(strings.formats, "_%s"), scope))
		statements map(do, l.statements) -> join(";\n")
	)

	let scopeDefs scope
		-> map(fn (s) formats("var _%s interface{}", s))
		-> join(";\n")

	return formats(
		"%s;\nmml.Nop(%s);\n%s"
		scopeDefs
		scopeNames
		statements
	)
}

fn do(code) {
	switch {
	case code.type == "int":
		return intLiteral(code)
	case code.type == "float":
		return floatLiteral(code)
	case code.type == "string":
		return stringLiteral(code)
	case code.type == "bool":
		return boolLiteral(code)
	}

	switch code.type {
	case "comment":
		return ""
	case "symbol":
		return symbol(code)
	case "list":
		return list(code)
	case "expression-key":
		return expressionKey(code)
	case "struct":
		return struct(code)
	case "function":
		return functionLiteral(code)
	case "indexer":
		return indexer(code)
	case "spread":
		return spread(code)
	case "application":
		return application(code)
	case "unary":
		return unary(code)
	case "binary":
		return binary(code)
	case "cond":
		return cond(code)
	case "switch-case":
		return caseBlock(code)
	case "switch-statement":
		return switchStatement(code)
	case "send-statement":
		return sendStatement(code)
	case "receive-expression":
		return receiveExpression(code)
	case "go-statement":
		return goStatement(code)
	case "defer-statement":
		return deferStatement(code)
	case "select-case":
		return caseBlock(code)
	case "select-statement":
		return selectStatement(code)
	case "range-over":
		return rangeOver(code)
	case "break":
		return breakStatement(code)
	case "continue":
		return continueStatement(code)
	case "loop":
		return loop(code)
	case "definition":
		return definition(code)
	case "definition-group":
		return definitionGroup(code)
	case "assign":
		return assign(code)
	case "ret":
		return ret(code)
	case "check-ret":
		return checkRet(code)
	case "use":
		return useStatement(code)
	case "use-list":
		return useList(code)
	case "module":
		return module(code)
	default:
		return statementList(code)
	}
}

fn allModules(module) module
	-> codetree.filter(is({type: "use"}))
	-> map(structs.get("module"))
	-> map(allModules)
	-> flat
	-> bind(concats, [module])
	-> uniq(eq)

export fn toGo(module) joins(
	""
	snippets.head
	code.builtin
		-> keys
		-> sort(fn (left, right) left < right)
		-> map(fn (k) formats("var _%s interface{} = mml.%s", k, code.builtin[k]))
		-> join(";\n")
	snippets.initHead
	module
		-> allModules
		-> map(do)
		-> join("\n")
	snippets.initFooter
	snippets.mainHead
	module.path
	snippets.mainFooter
)