package moe.nea.lisp

sealed class LispData {

	object LispNil : LispData()
	data class Atom(val label: String) : LispData()
	data class LispString(val string: String) : LispData()
	data class LispNumber(val value: Double) : LispData()
	data class LispNode(val node: LispAst.LispNode) : LispData()
	data class LispHash(val map: Map<String, LispData>) : LispData()
	data class ForeignObject<T : Any?>(val obj: T) : LispData()
	data class LispList(val elements: List<LispData>) : LispData()
	sealed class LispExecutable() : LispData() {
		abstract fun execute(
			executionContext: LispExecutionContext,
			callsite: LispAst.LispNode,
			stackFrame: StackFrame,
			args: List<LispAst.LispNode>
		): LispData
	}

	abstract class JavaExecutable(val name: String) : LispExecutable()

	data class LispInterpretedCallable(
		val declarationStackFrame: StackFrame,
		val argNames: List<String>,
		val body: LispAst.Parenthesis,
		val name: String?,
	) : LispExecutable() {
		override fun execute(
			executionContext: LispExecutionContext,
			callsite: LispAst.LispNode,
			stackFrame: StackFrame,
			args: List<LispAst.LispNode>
		): LispData {

			val invocationFrame = declarationStackFrame.fork()
			if (argNames.lastOrNull() == "...") {
				for ((name, value) in argNames.dropLast(1).zip(args)) {
					invocationFrame.setValueLocal(name, executionContext.resolveValue(stackFrame, value))
				}
				invocationFrame.setValueLocal(
					"...",
					LispList(
						args.drop(argNames.size - 1).map { executionContext.resolveValue(stackFrame, it) })
				)
			} else if (argNames.size != args.size) {
				return stackFrame.reportError(
					"Expected ${argNames.size} arguments, got ${args.size} instead",
					callsite
				)
			} else
				for ((name, value) in argNames.zip(args)) {
					invocationFrame.setValueLocal(name, executionContext.resolveValue(stackFrame, value))
				}
			return executionContext.executeLisp(invocationFrame, body)
		}
	}

	companion object {
		fun externalRawCall(
			name: String,
			callable: (context: LispExecutionContext, callsite: LispAst.LispNode, stackFrame: StackFrame, args: List<LispAst.LispNode>) -> LispData
		): LispExecutable {
			return object : JavaExecutable(name) {
				override fun execute(
					executionContext: LispExecutionContext,
					callsite: LispAst.LispNode,
					stackFrame: StackFrame,
					args: List<LispAst.LispNode>
				): LispData {
					return callable.invoke(executionContext, callsite, stackFrame, args)
				}
			}
		}

		fun externalCall(
			name: String,
			callable: (args: List<LispData>, reportError: (String) -> LispData) -> LispData
		): LispExecutable {
			return object : JavaExecutable(name) {
				override fun execute(
					executionContext: LispExecutionContext,
					callsite: LispAst.LispNode,
					stackFrame: StackFrame,
					args: List<LispAst.LispNode>
				): LispData {
					val mappedArgs = args.map { executionContext.resolveValue(stackFrame, it) }
					return callable.invoke(mappedArgs) { stackFrame.reportError(it, callsite) }
				}
			}
		}


		fun createLambda(
			declarationStackFrame: StackFrame,
			args: List<String>,
			body: LispAst.Parenthesis,
			nameHint: String? = null,
		): LispExecutable {
			return LispInterpretedCallable(declarationStackFrame, args, body, nameHint)
		}

		fun boolean(b: Boolean): Atom {
			return if (b) {
				CoreBindings.trueValue
			} else {
				CoreBindings.falseValue
			}
		}
	}
}