// World extension snapshots, staged services, lifecycle, and last-good recovery.
import * as durable from '@earendil-works/pi-durable';
import * as tools from '@earendil-works/pi-durable/tools';
import * as ai from '@earendil-works/pi-ai';
import * as modelApi from '@earendil-works/pi-ai/models';
import * as chord from '@earendil-works/chord';
import * as contextApi from '@earendil-works/chord/context';
import * as schema from '@earendil-works/pi-schema';
const ops = Deno.core.ops;
const encoder = new TextEncoder();
const decoder = new TextDecoder();
export const ExtensionState = durable.defineDoc({ kind: 'sausage.extensions', version: 1, scope: 'session', checkpointWhen: () => false, initial: () => ({good:null, current:null, error:null}) });
export const Metadata = durable.defineDoc({ kind: 'sausage.metadata', version: 1, scope: 'conversation', history:'latest', fork:'current', initial:()=>({label:'',title:''}), checkpointWhen:()=>false });
export type Host = {
  harness(): durable.Harness; storage: Pick<durable.Storage, 'scanSubmissions'>;
  models(): modelApi.Models; settings(): durable.JsonObject; metadata: typeof Metadata;
  fs: typeof fs; exec: typeof exec; git: typeof git;
  implement<S>(api: {name:string;readonly service?:S}, value:NoInfer<S>):void;
  need<S>(api:{name:string;readonly service?:S}):S; want<S>(api:{name:string;readonly service?:S}):S|undefined;
  resource<T>(key:string, create:()=>T):T;
  onOpen(cb:()=>Promise<void>):void; onClose(cb:()=>Promise<void>):void;
  notice(message:string):void;
  // P3-d adds emit/react/eventLog here, with atomic events and durable cursors.
};
async function file(kind:string, path:string, bytes:number[]=[]):Promise<any> {
  const result = await ops.op_file(kind,path,bytes);
  if (!result.ok) throw Object.assign(new Error(result.error.message), result.error);
  return result.value;
}
export const fs = {
  read: async (path:string) => decoder.decode(new Uint8Array(await file('read',path))),
  write: (path:string, text:string) => file('write',path,Array.from(encoder.encode(text))),
  append: (path:string, text:string) => file('append',path,Array.from(encoder.encode(text))),
  list: (path:string) => file('list',path), stat: (path:string) => file('stat',path),
  lstat: (path:string) => file('lstat',path), mkdir: (path:string) => file('mkdir',path),
  remove: (path:string) => file('remove',path),
  rename: (from:string,to:string) => file('rename',from,Array.from(encoder.encode(to))),
};
export async function exec(command:string|string[], options:{cwd:string;env?:[string,string][];timeout?:number;conversations?:string[];signal?:AbortSignal;onOutput?:(text:string,stream:string)=>void}) {
  options.signal?.throwIfAborted();
  const rid = ops.op_exec(command, options.cwd, options.timeout, undefined, options.env, options.conversations);
  const abort = () => Deno.core.close(rid);
  options.signal?.addEventListener('abort',abort,{once:true});
  const decoders:any = {stdout:new TextDecoder(),stderr:new TextDecoder()};
  const result = {code:0,stdout:'',stderr:''};
  try {
    for (;;) {
      const chunk = await ops.op_exec_next(rid);
      if (!chunk.stream) {
        if (chunk.error) throw new Error(chunk.error);
        result.code = chunk.exitCode;
        for (const stream of ['stdout','stderr']) { const text = decoders[stream].decode(); result[stream] += text; if(text) options.onOutput?.(text,stream); }
        return result;
      }
      const text = decoders[chunk.stream].decode(new Uint8Array(chunk.bytes),{stream:true});
      result[chunk.stream] += text;
      options.onOutput?.(text,chunk.stream);
    }
  } finally { options.signal?.removeEventListener('abort',abort); }
}
export async function git(cwd:string,...args:string[]) {
  const result = await exec(['git',...args],{cwd,timeout:30});
  if (result.code) throw new Error(result.stderr || `git exited ${result.code}`);
  return result.stdout.trim();
}
export function registerModules() {
  const modules = {'@earendil-works/pi-schema':schema,'@earendil-works/pi-durable':durable,'@earendil-works/pi-durable/tools':tools,'@earendil-works/pi-ai':ai,'@earendil-works/pi-ai/models':modelApi,'@earendil-works/chord':chord,'@earendil-works/chord/context':contextApi};
  globalThis.__sausage = {modules};
  ops.op_modules(Object.fromEntries(Object.entries(modules).map(([name,value])=>[name,Object.keys(value)])));
}
export async function loadExtensions(harness:any, registry:any, storage:any, models:any, context:any, builtins:any[]=[]) {
  registerModules();
  const repo = '/src/sausage';
  let providers = new Map<string,any>();
  const resources = new Map<string,any>();
  let facets:any[] = [];
  let state = {...(await harness.snapshot(ExtensionState,context) ?? {good:null,current:null,error:null})};
  let settings:any = {};
  let active = true;
  let queue = Promise.resolve();
  const publish = async () => {
    await harness.commit(async (tx:any)=>Object.assign(await tx.doc(ExtensionState),state),context);
    ops.op_extension_status(JSON.stringify(state));
    await fs.write('/src/sausage/.git/sausage-last-good',state.good ?? '');
  };
  const dispose = async (entries:any[]) => { for(const facet of entries) for(const cleanup of facet.close) { try {await cleanup();} catch(error) {ops.op_output(`Extension cleanup: ${String(error)}\n`);} } };
  const scope = (name:string, staged:Map<string,any>) => {
    const open:any[] = [], close:any[] = [];
    const handle = (api:any) => new Proxy({}, {get:(_,key)=> {
      if (typeof key === 'symbol' || key === 'then') return undefined;
      const value = providers.get(api.name);
      if(!value) throw new Error(`No provider for ${api.name}`);
      const member = value[key];
      return typeof member === 'function' ? (...args:any[]) => {
        const current = providers.get(api.name);
        if(!current) throw new Error(`No provider for ${api.name}`);
        return Reflect.apply(current[key],current,args);
      } : member;
    }});
    const host:Host = {
      harness:()=>harness, storage, models:()=>models, settings:()=>settings, metadata:Metadata, fs,exec,git,
      implement:(api,value)=>{staged.set(api.name,value);}, need:handle,
      want:(api)=>providers.has(api.name)?handle(api):undefined,
      resource:(key,create)=>{const id=`${name}/${key}`;if(!resources.has(id))resources.set(id,create());return resources.get(id);},
      onOpen:cb=>open.push(cb),onClose:cb=>close.push(cb),notice:message=>{state.notice=`${name}: ${message}`;ops.op_extension_status(JSON.stringify(state));ops.op_output(`${name}: ${message}\n`);},
    };
    return {host,open,close};
  };
  const load = async (sha:string) => {
    const next:any[] = [];
    const staged = new Map<string,any>();
    try {
      const snapshot = `/run/sausage/extensions/${sha}`;
      for(const path of ['/run/sausage','/run/sausage/extensions']) {try {await fs.mkdir(path);} catch(error) {if((error as any).code!=='already_exists')throw error;} }
      try {await fs.stat(snapshot);} catch {await git(repo,'worktree','prune');await git(repo,'worktree','add','--detach',snapshot,sha);}
      const modules:any[] = [];
      for(const entry of await fs.list(`${snapshot}/extensions`).catch(error=>{if(error.code==='not_found')return [];throw error;})) {
        if(entry.kind!=='directory')continue;
        const path = `${snapshot}/extensions/${entry.name}/server.ts`;
        try {await fs.stat(path);} catch(error) {if((error as any).code==='not_found')continue;throw error;}
        const module = await import(/* @vite-ignore */ `file://${path}`);
        modules.push({name:entry.name,module});
      }
      modules.sort((a,b)=>(a.module.order??0)-(b.module.order??0)||a.name.localeCompare(b.name));
      for(const {name,module} of modules) {
        const facet = scope(name,staged); next.push(facet);
        facet.extension = typeof module.default==='function'?await module.default(facet.host):module.default;
        if(!facet.extension || facet.extension.name!==name)throw new Error(`Extension name must match ${name}`);
      }
      // Validate the complete commit before the live registry changes.
      const probe = durable.createRegistry();
      for(const extension of [...builtins,...next.map(f=>f.extension)])probe.install(extension);
      for(const old of facets)registry.uninstall(old.extension);
      for(const extension of [...builtins,...next.map(f=>f.extension)])registry.install(extension);
      const old = facets; facets=next; providers=staged;
      await dispose(old);
      for(const facet of next)for(const cb of facet.open) {try {await cb();} catch(error) {facet.host.notice(`onOpen: ${String(error)}`);} }
      state.good=sha;
      return null;
    } catch(error) {await dispose(next); return String(error);}
  };
  const reload = async () => {
    let tip:string;
    try {tip=await git(repo,'rev-parse','refs/heads/main');} catch(error) {state.error=String(error);ops.op_extension_status(JSON.stringify(state));return;}
    try {settings=JSON.parse(await fs.read(`${repo}/settings.json`));} catch(error) {if((error as any).code==='not_found')settings={};else {state.notice=`Settings: ${String(error)}`;ops.op_extension_status(JSON.stringify(state));ops.op_output(`${state.notice}\n`);}}
    if(state.current===tip && facets.length)return;
    state.current=tip;
    state.error=await load(tip);
    if(state.error && !facets.length && state.good && state.good!==tip) {
      const failed=state.error;
      const fallback=await load(state.good);
      state.error=fallback?`${failed}\nLast good: ${fallback}`:failed;
    }
    await publish();
  };
  const enqueue = () => queue=queue.then(reload);
  const rid = ops.op_watch([`${repo}/.git/refs/heads/main`,`${repo}/.git/packed-refs`,`${repo}/settings.json`]);
  await enqueue();
  const pending = (async()=> {while(active){await ops.op_watch_next(rid);if(active)await enqueue();}})();
  return {reload:enqueue, state:()=>({...state}), close:async()=>{active=false;Deno.core.close(rid);await pending;await queue;await dispose(facets);}};
}