import { Actor, Assertion, Turn } from './actor.js';
import { Dictionary, Record } from 'preserves';
import { Dataspace, Observe } from './dataspace.js';
import { Worker } from 'worker_threads';
import { Relay, spawnRelay } from './relay.js';
import { BoxState, SetBox } from './box-protocol.js';
import { attenuate, CRec, Lit, Pattern, PCompound, rfilter } from './rewrite.js';
import path from 'path';

const Instance = Record.makeConstructor<{moduleName: string, arg: Assertion}>()(
    Symbol.for('Instance'), ['moduleName', 'arg']);

function spawnWorker(t: Turn, moduleName: string, arg: Assertion) {
    const w = new Worker(path.join(__dirname, 'wload.js'));
    spawnRelay(t, {
        packetWriter: bs => w.postMessage(bs),
        setup(t: Turn, r: Relay) {
            w.on('message', bs => r.accept(bs));
            w.on('error', err => Turn.for(t.actor, t => t.crash(err)));
            w.on('exit', code => Turn.for(t.actor, t => {
                if (code === 0) {
                    t.quit();
                } else {
                    t.crash(new Error(`Worker crashed with code ${code}`));
                }
            }));
        },
        initialOid: 0,
    }).then(factory => Turn.for(new Actor(), t => {
        t.assert(factory!, Instance(moduleName, arg));
    }));
}

function spawnModule(t: Turn, moduleName: string, arg: Assertion) {
    import(moduleName).then(m => t.freshen(t => t.spawn(t => m.default(t, arg))));
}

// __setNextActorId(1000);

Turn.for(new Actor(), async (t: Turn) => {
    const ds_unproxied = t.ref(new Dataspace());

    const ds = ds_unproxied;
    // const { proxy: ds, revoker } = forwarder(t, ds_unproxied);
    // t.spawn(t => {
    //     t.assert(ds, Observe(SetBox.constructorInfo.label, t.ref({
    //         message(t: Turn, [newValue]: [number]): void {
    //             if (newValue === 30000) {
    //                 console.log('BOOM!');
    //                 t.message(revoker, true);
    //             }
    //         }
    //     })));
    // });

    const ds_for_box = attenuate(
        ds,
        rfilter(PCompound(CRec(BoxState.constructorInfo.label,
                               BoxState.constructorInfo.arity),
                          new Dictionary()),
                PCompound(CRec(Observe.constructorInfo.label,
                               Observe.constructorInfo.arity),
                          new Dictionary<Pattern, never>([
                              [0, Lit(SetBox.constructorInfo.label)]]))));

    const ds_for_client = attenuate(
        ds_unproxied,
        rfilter(PCompound(CRec(SetBox.constructorInfo.label,
                               SetBox.constructorInfo.arity),
                          new Dictionary()),
                PCompound(CRec(Observe.constructorInfo.label,
                               Observe.constructorInfo.arity),
                          new Dictionary<Pattern, never>([
                              [0, Lit(BoxState.constructorInfo.label)]]))));


    const boxpath = path.join(__dirname, 'box.js');
    const clientpath = path.join(__dirname, 'client.js');

    // spawnModule(t, boxpath, [ds_for_box, 500000, 25000]);
    spawnWorker(t, boxpath, [ds_for_box, 50000, 2500]);

    spawnModule(t, clientpath, ds_for_client);
    // spawnWorker(t, clientpath, ds_for_client);
});