//! Runtime compiler ownership across scheduled windows and domain destruction.

use std::mem;

use kernel::abi;

use kernel::frames;

use kernel::slots;

use kernel::backing;

use kernel::pages;

use kernel::capability;

use kernel::registry;

use kernel::loader;

use kernel::domains;

use kernel::budgets;

use kernel::dispatch;

use kernel::boot;

use kernel::sync;

use kernel::calls;

use kernel::lifecycle;

use kernel::remote;

use kernel::dispatchinput;

/// Bootstrap resource capabilities.

unsafe static TABLE: capability::Table = undefined;

/// First loader, retry loader, witness, and controller domain handles.

unsafe static HANDLES: [abi::Handle; 4] = undefined;

/// Generation-bearing domain identities for each actor.

unsafe static ACTORS: [abi::Ref; 4] = undefined;

/// Initial context identities for each actor.

unsafe static CONTEXTS: [abi::Ref; 4] = undefined;

/// Controller capability for the first loader.

unsafe static VICTIM: abi::Handle = undefined;

/// Controller capability for the binary input page.

unsafe static SOURCE: abi::Handle = undefined;

/// Shared user progress and published package identity.

unsafe static PROGRESS: *mut u64 = undefined;

/// Start of the controller's final execution window.

static FINAL: u64 = 0;

/// Write one diagnostic byte to the fixture UART.

fn put(byte: u8);

/// Write a fixed-width hexadecimal diagnostic value.

fn number(value: u64) {

    let digits = "0123456789abcdef";

    for i in 0..16 { put(digits[((value >> ((15 - i) as u64 * 4)) & 15) as u32]); }

}

/// Map a validated physical page.

fn memory(address: u64) -> *mut u8;

/// Current kernel package-state base.

fn kernelGp() -> u64;

/// Native controller entry address.

fn completion() -> u64;

/// Execute published code with one private package-state table.

fn invoke(address: u64, table: u64) -> i64;

/// Signal native fixture completion.

fn finish();

/// Copy trusted package bytes into a bootstrap-owned page allocation.

unsafe fn input(authority: abi::Handle, bytes: &[u8]) -> abi::Handle {

    let handle = try! pages::allocate(&mut pages::STORE, &mut TABLE, authority, (bytes.len as u64 + 4095) / 4096);

    let page = try! pages::get(&pages::STORE, (try! capability::get(&TABLE, handle)).object);

    let copied = try! mem::copy(@sliceOf(memory(page.base), page.count * 4096), bytes);

    assert copied == bytes.len;

    return handle;

}

/// Install user actors and disjoint windows that interrupt two compiler calls.

export unsafe fn setup() {

    let pending = try! slots::reserve(&mut domains::STORE.slots[..]);

    let owner = try! slots::commit(&mut domains::STORE.slots[..], pending);

    capability::initialize(&mut TABLE, owner);

    try! backing::registerDomain(&mut pages::STORE.backings, owner);

    let authority = try! capability::install(&mut TABLE, capability::Entry {

        kind: abi::Kind::Domain, object: owner, rights: abi::Rights(abi::CREATE | abi::ALLOCATE),

    });

    let source = input(authority, &dispatchinput::INPUT[..]);

    let image = try! loader::load(&mut loader::STATE, &mut pages::STORE, &mut registry::STORE, &mut TABLE,

        loader::Request { authority, source, offset: 0, length: dispatchinput::INPUT.len as u64 });

    let payload = input(authority, &dispatchinput::PAYLOAD[..]);

    let progress = try! pages::allocate(&mut pages::STORE, &mut TABLE, authority, 1);

    let shared = try! pages::get(&pages::STORE, (try! capability::get(&TABLE, progress)).object);

    set PROGRESS = memory(shared.base) as *mut u64;

    for i in 0..4 {

        let handle = try! domains::create(&mut domains::STORE, &mut pages::STORE.backings, &registry::STORE, &mut TABLE, authority, image);

        let object = (try! capability::get(&TABLE, handle)).object;

        let mut child = try! domains::get(&domains::STORE, object);

        let mut rights = abi::ALLOCATE;

        if i == 3 { set rights |= abi::CREATE; }

        let self = try! capability::install(&mut child.memory.table, capability::Entry {

            kind: abi::Kind::Domain, object, rights: abi::Rights(rights),

        });

        set HANDLES[i] = handle; set ACTORS[i] = object; set CONTEXTS[i] = child.initial;

        let readable = try! pages::grant(&mut pages::STORE, &TABLE, &mut child.memory.table, payload, abi::READ as u64);

        let writable = try! pages::grant(&mut pages::STORE, &TABLE, &mut child.memory.table, progress, (abi::READ | abi::WRITE) as u64);

        if i == 3 {

            set SOURCE = readable;

            set VICTIM = try! capability::install(&mut child.memory.table, capability::Entry {

                kind: abi::Kind::Domain, object: ACTORS[0], rights: abi::Rights(abi::DESTROY),

            });

            set domains::STORE.records[object.index].state = domains::Lifecycle::Active;

            let frame = &mut domains::STORE.contexts[child.initial.index].frame;

            set frame.pc = completion(); set frame.status = 0x1880;

            set frame.registers[2] = domains::STORE.contexts[child.initial.index].kernelStack.end;

            set frame.registers[3] = kernelGp();

            continue;

        }

        let stack = try! pages::allocate(&mut pages::STORE, &mut TABLE, authority, 1);

        let granted = try! pages::grant(&mut pages::STORE, &TABLE, &mut child.memory.table, stack, (abi::READ | abi::WRITE) as u64);

        let storage = try! pages::get(&pages::STORE, (try! capability::get(&TABLE, stack)).object);

        let args = @sliceOf(memory(storage.base) as *mut u64, 3);

        set args[0] = *readable; set args[1] = dispatchinput::PAYLOAD.len as u64; set args[2] = shared.base;

        try! domains::activate(&mut domains::STORE, &pages::STORE, &TABLE, handle, storage.base + 4096, storage.base, i as u64);

    }

    for byte in "runtime actors ready\n" { put(byte); }

    let now = dispatch::clock();

    let start = now + 1000000;

    set FINAL = start + 300000000;

    let mut remaining = try! budgets::seed(&mut budgets::STORE, &mut TABLE, 0, start, FINAL + 10000000);

    let actors = [0 as u32, 3, 1, 2, 1];

    let ends = [10000000 as u64, 50000000, 60000000, 62000000, 300000000];

    for i in 0..5 {

        let next = try! budgets::split(&mut budgets::STORE, &mut TABLE, remaining, start + ends[i], now);

        let actor = actors[i];

        let bound = try! budgets::bind(&mut budgets::STORE, &domains::STORE, &mut TABLE,

            budgets::Binding { budget: remaining, domain: HANDLES[actor], context: CONTEXTS[actor] }, now);

        set remaining = next;

    }

    let bound = try! budgets::bind(&mut budgets::STORE, &domains::STORE, &mut TABLE,

        budgets::Binding { budget: remaining, domain: HANDLES[3], context: CONTEXTS[3] }, now);

}

/// Verify cancellation, competing admission, progress, and resident code reuse.

export unsafe fn verify() {

    for byte in "runtime admission metadata instructions: " { put(byte); }

    number(sync::maximum()); put(10);

    let admissionWait = sync::maximumWait();

    assert admissionWait > 0;

    for byte in "runtime admission acquisition instructions: " { put(byte); }

    number(admissionWait); put(10);

    let progress = @sliceOf(PROGRESS, 4);

    let guard = sync::enter();

    let first = CONTEXTS[0];

    for byte in "runtime first progress and owner: " { put(byte); }

    number(progress[0]); put(32); number(abi::id(loader::STATE.owner)); put(10);

    assert progress[0] == 1 and loader::STATE.busy and loader::STATE.owner == ACTORS[0];

    assert domains::STORE.contexts[first.index].reservation;

    assert (domains::STORE.contexts[first.index].frame.status & 0x1800) == 0x1800;

    let allocation = lifecycle::CALLS.records[first.index].allocation;

    let mut loading: lifecycle::Loading = undefined;

    match allocation {

        case lifecycle::Allocation::Load(value) => { set loading = value; },

        else => panic "loader reservation required",

    }

    let output = loading.output else panic "compilation output required";

    sync::leave(guard);

    let mut busy = false;

    try calls::synchronized(ACTORS[3], 51, &[0, *SOURCE, 0, dispatchinput::PAYLOAD.len as u64], dispatch::clock()) catch error {

        assert error == abi::Error::Busy; set busy = true;

    };

    assert busy;

    for byte in "runtime competing load rejected\n" { put(byte); }

    let destroyed = try! calls::synchronized(ACTORS[3], 22, &[*VICTIM, 0, 0, 0], dispatch::clock());

    assert destroyed == 0;

    let checking = sync::enter();

    let request = try! dispatch::request(0, remote::Action::Reschedule);

    sync::leave(checking);

    let result = try! dispatch::awaitRequest(0, request);

    assert result == 0;

    let cancelled = sync::enter();

    assert not loader::STATE.busy;

    assert (lifecycle::CALLS.active[first.index / 32] & (1 << (first.index % 32))) == 0;

    assert registry::STORE.slots[output.object.index].state == slots::State::Free;

    sync::leave(cancelled);

    let mut reclaimed = false;

    for attempt in 0..10000 {

        let guard = sync::enter();

        set reclaimed = pages::STORE.backings.pool.retiredCount == 0;

        if reclaimed { sync::leave(guard); break; }

        let request = try! dispatch::request(0, remote::Action::Reschedule);

        sync::leave(guard);

        let result = try! dispatch::awaitRequest(0, request);

        assert result == 0;

    }

    assert reclaimed;

    for run in [loading.input.frames, output.code, output.metadata] {

        let mut offset: u32 = 0;

        while offset < run.count {

            let mut count = run.count - offset;

            if count > 256 { set count = 256; }

            let recovered = sync::enter();

            for i in run.first + offset..run.first + offset + count { assert frames::available(&pages::STORE.backings.pool, i); }

            sync::leave(recovered);

            set offset += count;

        }

    }

    for byte in "runtime cancellation passed\n" { put(byte); }

    while dispatch::clock() < FINAL {}

    let complete = sync::enter();

    for byte in "runtime final progress: " { put(byte); }

    for i in 0..4 { number(progress[i]); put(32); }

    put(10);

    assert progress[0] == 1 and progress[1] == 2 and progress[2] == 1;

    assert not loader::STATE.busy;

    let package = try! registry::get(&registry::STORE, abi::reference(progress[3]));

    let entry = package.entry else panic "published entry required";

    let mut controller = try! domains::get(&domains::STORE, ACTORS[3]);

    let image = try! registry::install(&registry::STORE, &mut controller.memory.table, abi::reference(progress[3]));

    sync::leave(complete);

    let handle = abi::Handle(try! calls::synchronized(ACTORS[3], 20, &[0, *image, 0, 0], dispatch::clock()));

    let created = sync::enter();

    let object = (try! capability::get(&controller.memory.table, handle)).object;

    let domain = try! domains::get(&domains::STORE, object);

    sync::leave(created);

    assert invoke(entry, domain.graph.table.ptr as u64) == 43;

    assert invoke(entry, domain.graph.table.ptr as u64) == 85;

    for byte in "runtime retry published executable code\n" { put(byte); }

    let maximum = sync::maximum();

    for byte in "runtime metadata instructions: " { put(byte); }

    number(maximum); put(10);

    assert maximum > 0 and maximum < 1000000;

    let waiting = sync::maximumWait();

    assert waiting > 0;

    for byte in "runtime acquisition instructions: " { put(byte); }

    number(waiting); put(10);

    finish();

}