// SPDX-FileCopyrightText: 2025 The Project Pterodactyl Developers
//
// SPDX-License-Identifier: MPL-2.0

import Testing

@testable import PterodactylBuild
@testable import PterodactylSyntax
@testable import llbuild2fx

struct BuildTests {
	@Test
	func testBlockLayout() async throws {
		let code = """
			theory Foo where
				 foo : bar
				 baz : sdf
			"""

		var lexer = PterodactylSyntax.Lexer(input: code)
		let flatTokens = lexer.tokenize()
		let blockTokens = BlockLayoutProcessor(tokens: flatTokens).layout()

		#expect(
			blockTokens.map(\.kind) == [
				.keyword(.theory), .whitespace, .identifier, .whitespace, .keyword(.where), .blockBegin, .newline, .whitespace, .blockSep, .identifier, .whitespace,
				.punctuation(.colon),
				.whitespace, .identifier, .newline, .whitespace, .blockSep, .identifier, .whitespace, .punctuation(.colon), .whitespace, .identifier, .blockEnd, .eof
			])
	}

	@Test
	func testParse() async throws {
		let code = """
			theory Foo where
				asdf : asdf
			"""

		var lexer = PterodactylSyntax.Lexer(input: code)
		let flatTokens = lexer.tokenize()
		let blockTokens = BlockLayoutProcessor(tokens: flatTokens).layout()
		var parser = Parser(source: code, tokens: blockTokens)
		Document.parse(&parser, recovery: [])

		#expect(parser.diagnostics.isEmpty)
	}

	@Test
	func testImports() async throws {
		let group = LLBMakeDefaultDispatchGroup()
		let db = LLBInMemoryCASDatabase(group: group)
		let functionCache = FXInMemoryFunctionCache(group: group)
		let executor = FXLocalExecutor()
		let engine = FXEngine(group: group, db: db, functionCache: functionCache, executor: executor)
		let client = LLBCASFSClient(db)
		let ctx = Context()

		let declTree = LLBDeclFileTree.dir(
			[
				"src": .dir([
					"bar.ext": .file(contents: Array("hello world".utf8)),
					"foo.ext": .file(contents: Array("import bar".utf8)),
					"baz.ext": .file(contents: Array("import foo".utf8))
				])
			]
		)

		let treeID: LLBDataID = try await client.store(declTree, ctx).get()
		let dependencyGraph = try await engine.build(key: Keys.SourceTree.GetDependencyGraph(sourceTreeId: treeID), ctx).get()
		let foo = UnitName(basename: "foo")
		let bar = UnitName(basename: "bar")
		let baz = UnitName(basename: "baz")

		#expect(
			dependencyGraph.edges == [
				bar: [],
				foo: [bar],
				baz: [foo]
			]
		)

		let dependenciesOfBaz = try await engine.build(key: Keys.SourceTree.GetDependencies(sourceTreeId: treeID, unitName: baz), ctx).get()
		#expect(dependenciesOfBaz == [foo, bar])
		return
	}
}