//! User calls, targeted handoff, and timer preemption of busy loops.

export mod abi;

export mod sys;

/// RV64 direct-call intrinsic used to check the machine ABI.

@intrinsic fn ecall(number: u32, a0: i64, a1: i64, a2: i64, a3: i64) -> i64;

/// Local capabilities supplied to the user fixture.

record Arguments: Copy {

    /// Local capability for the stack allocation.

    stack: u64,

    /// Local capability for the resident user package.

    image: u64,

    /// Local self-Domain capability with allocation authority.

    domain: u64,

    /// Future window that the user can partition between its contexts.

    future: u64,

    /// Completion checker with authority to receive child lifecycle events.

    parent: u64,

}

/// Startup environment supplied by the kernel.

record Env: Copy {

    /// Readable startup capabilities.

    argsPointer: *Arguments,

    /// Size of the startup word.

    argsSize: u64,

    /// Installed event handle.

    eventsHandle: u64,

    /// Shared event ring address.

    eventsPointer: u64,

}

/// Private query output used to check writable package-state authority.

static INFO: [u64; 2] = [0; 2];

/// Private progress counter observed by the machine fixture.

export static count: u64 = 0;

/// Additional-context progress in the same private package state.

export static extraCount: u64 = 0;

/// Successful user-side return and destruction checks.

export static destroyed: u64 = 0;

/// Generation-bearing identity of the child that returns normally.

export static childId: u64 = 0;

/// Local self-Domain authority shared by both user contexts.

static SELF: abi::Handle = abi::Handle(0);

/// Update shared private state and return from an additional context.

export fn worker(args: *opaque, size: u64) {

    assert size == 0;

    set extraCount += 1;

    try! sys::timeout(2000000, 77);

    sys::wait();

    set extraCount += 1;

    set count += 1;

}

/// Check direct calls and handoff, then exercise independently bound contexts.

@default unsafe fn main(env: *Env) {

    if env.argsSize == 0 {

        try! sys::timeout(10000, 88);

        sys::wait();

        return;

    }

    assert env.argsSize == 40;

    set SELF = abi::Handle(env.argsPointer.domain);

    let handle = env.argsPointer.stack as i64;

    let info = sys::queryPage(abi::Handle(handle as u64));

    assert info.base <> 0 and info.count == 1;

    let mut rejected = false;

    try sys::pageAllocate(abi::Handle(0), 0) catch error {

        assert error == abi::Error::InvalidArg;

        set rejected = true;

    };

    assert rejected;

    let allocated = try! sys::pageAllocate(abi::Handle(0), 1);

    assert sys::queryPage(allocated).count == 1;

    let narrowed = try! sys::capabilityGrant(allocated, abi::Handle(0), abi::READ as u64);

    try! sys::capabilityDrop(narrowed);

    try! sys::capabilityDrop(allocated);

    assert sys::queryEvents(abi::Handle(env.eventsHandle)).capacity == 256;

    let domain = sys::queryDomain(abi::Handle(env.argsPointer.domain));

    assert domain.id <> 0 and domain.state == 1;

    let image = try! sys::queryImage(abi::Handle(env.argsPointer.image));

    assert image.entry <> 0 and image.codeBase <> 0 and image.codeBytes > 0 and image.dataBytes > 0;

    let child = try! sys::domainCreate(abi::Handle(0), abi::Handle(env.argsPointer.image));

    set childId = sys::queryDomain(child).id;

    try! sys::domainReparent(child, abi::Handle(env.argsPointer.parent));

    let stack = try! sys::pageAllocate(abi::Handle(0), 1);

    let granted = try! sys::capabilityGrant(stack, child, (abi::READ | abi::WRITE) as u64);

    let childStack = sys::queryPage(stack);

    try! sys::domainActivate(child, childStack.base + 4096, (&*env) as *unsafe opaque, 0);

    assert sys::queryDomain(child).state == 1;

    set rejected = false;

    try sys::domainActivate(child, childStack.base + 4096, (&*env) as *unsafe opaque, 0) catch error {

        assert error == abi::Error::NotPending;

        set rejected = true;

    };

    assert rejected;

    set rejected = false;

    try sys::imageLoad(abi::Handle(0), stack, 0, 0) catch error {

        assert error == abi::Error::InvalidArg;

        set rejected = true;

    };

    assert rejected;

    let current = sys::currentContext();

    assert current.context <> 0 and current.hart == 0 and current.budget <> 0;

    let window = try! sys::queryBudget(abi::Handle(current.budget));

    assert window.context == current.context and window.hart == current.hart and window.start < window.end;

    let extraStack = try! sys::pageAllocate(abi::Handle(0), 1);

    let extraMemory = sys::queryPage(extraStack);

    let extra = try! sys::contextCreate(abi::Handle(env.argsPointer.domain), abi::ContextStart {

        entry: worker as u64, stack: extraMemory.base + 4096, args: 0, size: 0,

    });

    let context = try! sys::queryContext(abi::Handle(env.argsPointer.domain), extra);

    assert context.context == extra and context.domain == domain.id;

    assert context.stackBase == extraMemory.base and context.stackTop == extraMemory.base + 4096;

    let future = abi::Handle(env.argsPointer.future);

    let later = try! sys::queryBudget(future);

    let tail = try! sys::budgetSplit(future, later.start + (later.end - later.start) / 2);

    let childWindow = try! sys::budgetSplit(tail, later.start + (later.end - later.start) * 5 / 8);

    let resumption = try! sys::budgetSplit(childWindow, later.start + (later.end - later.start) * 11 / 16);

    let awakened = try! sys::budgetSplit(resumption, later.start + (later.end - later.start) * 3 / 4);

    let finalWindow = try! sys::budgetSplit(awakened, later.start + (later.end - later.start) * 13 / 16);

    let bound = try! sys::budgetBind(tail, abi::Handle(env.argsPointer.domain), extra);

    let resumed = try! sys::budgetBind(awakened, SELF, extra);

    let initial = try! sys::queryContext(child, 0);

    let childBound = try! sys::budgetBind(childWindow, child, initial.context);

    let mut local: [u64; 2] = [0; 2];

    assert ecall(44, handle, (&mut local[0]) as i64, 16, 0) == 0;

    assert local[0] <> 0 and local[1] == 1;

    assert ecall(44, handle, (&mut INFO[0]) as i64, 16, 0) == 0;

    assert INFO[0] == local[0] and INFO[1] == local[1];

    assert ecall(44, handle, 0, 16, 0) == -4;

    assert ecall(0xffffffff, 0, 0, 0, 0) == -4;

    set rejected = false;

    try sys::yield(SELF) catch error {

        assert error == abi::Error::Busy;

        set rejected = true;

    };

    assert rejected and sys::currentContext().budget == current.budget;

    set count = 1;

    try! sys::yield(child);

    let continued = sys::currentContext();

    assert continued.context == current.context and continued.budget == *future;

    while extraCount == 0 { set count += 1; }

    let waiting = try! sys::queryContext(SELF, extra);

    assert waiting.state == 2 and waiting.hart == 0xffffffffffffffff;

    try! sys::wakeup(SELF, 123);

    assert extraCount == 1 or extraCount == 2;

    while extraCount == 1 { set count += 1; }

    let stopped = try! sys::queryContext(abi::Handle(env.argsPointer.domain), extra);

    assert stopped.state == 1 and stopped.hart == 0xffffffffffffffff;

    try! sys::contextDestroy(abi::Handle(env.argsPointer.domain), extra);

    set rejected = false;

    try sys::queryContext(abi::Handle(env.argsPointer.domain), extra) catch error {

        assert error == abi::Error::BadHandle;

        set rejected = true;

    };

    assert rejected;

    set destroyed = 1;

    while true { set count += 1; }

}