export * as CodeMode from "./codemode"

import { Context, Effect, Layer, Scope } from "effect"

import { makeLocationNode } from "@opencode-ai/util/effect/app-node"

import { PermissionV2 } from "./permission"

import { ExecuteTool } from "./tool/execute"

import type { Any, Registration } from "./tool/tool"

import { Wildcard } from "./util/wildcard"

export interface Materialization {

readonly tool?: Any

readonly instructions?: string

}

export interface Interface {

readonly register: (

registrations: ReadonlyArray<Registration & { readonly key: string }>,

) => Effect.Effect<void, never, Scope.Scope>

readonly materialize: (permissions?: PermissionV2.Ruleset) => Effect.Effect<Materialization>

}

export class Service extends Context.Service<Service, Interface>()("@opencode/v2/CodeMode") {}

const layer = Layer.effect(

Service,

Effect.gen(function* () {

const local = new Map<string, Array<{ readonly token: object; readonly registration: ExecuteTool.Registration }>>()

return Service.of({

register: Effect.fn("CodeMode.register")(function* (registrations) {

if (registrations.length === 0) return

yield* Effect.uninterruptible(

Effect.gen(function* () {

const token = {}

for (const registration of registrations)

local.set(registration.key, [

...(local.get(registration.key) ?? []),

{

token,

registration,

},

])

yield* Effect.addFinalizer(() =>

Effect.sync(() => {

for (const registration of registrations) {

const remaining = local.get(registration.key)?.filter((item) => item.token !== token) ?? []

if (remaining.length > 0) local.set(registration.key, remaining)

else local.delete(registration.key)

}

}),

)

}),

)

}),

materialize: Effect.fn("CodeMode.materialize")(function* (permissions) {

const registrations = new Map<string, ExecuteTool.Registration>()

const rules = permissions ?? []

for (const [name, entries] of local) {

const registration = entries.at(-1)?.registration

if (!registration) continue

const rule = rules.findLast((rule) => Wildcard.match(registration.permission, rule.action))

if (rule?.resource === "*" && rule.effect === "deny") continue

registrations.set(name, registration)

}

if (registrations.size === 0) return {}

const executeRule = rules.findLast((rule) => Wildcard.match("execute", rule.action))

if (executeRule?.resource === "*" && executeRule.effect === "deny") return {}

return {

tool: ExecuteTool.create(registrations),

instructions: ExecuteTool.instructions(registrations),

}

}),

})

}),

)

export const node = makeLocationNode({ service: Service, layer, deps: [] })