//! Native timer preemption across user execution, idle, and machine continuations.

use std::mem;

use std::arch::rv64::shared;

use kernel::abi;

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::events;

use kernel::sync;

use kernel::dispatchinput;

/// Bootstrap authority used to create fixture domains and CPU windows.

unsafe static TABLE: capability::Table = undefined;

/// Domain handles used for budget binding.

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

/// Initial contexts for the user, machine worker, and completion check.

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

/// View a validated allocated source page.

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

/// Current kernel package-state base.

fn kernelGp() -> u64;

/// Native entry for retained M-mode work.

fn worker() -> u64;

/// Native entry for the final assertion callback.

fn completion() -> u64;

/// Complete the machine fixture with a passing status.

fn finish();

/// Complete the fixture with a distinct failed invariant code.

fn failed(code: u64);

/// Prepare real private domains before enabling dispatch on hart zero.

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 = try! pages::allocate(&mut pages::STORE, &mut TABLE, authority, (dispatchinput::INPUT.len as u64 + 4095) / 4096);

    let sourceEntry = try! capability::get(&TABLE, source);

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

    let bytes = @sliceOf(memory(page.base), page.count * 4096);

    let length = try! mem::copy(&mut bytes[..], &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: length as u64 });

    for i in 0..3 {

        set HANDLES[i] = try! domains::create(&mut domains::STORE, &mut pages::STORE.backings, &registry::STORE, &mut TABLE, authority, image);

        let cap = try! capability::get(&TABLE, HANDLES[i]);

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

        set CONTEXTS[i] = child.initial;

        if i > 0 {

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

            set domains::STORE.contexts[child.initial.index].frame.status = 0x1880;

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

            set domains::STORE.contexts[child.initial.index].frame.registers[3] = kernelGp();

        }

    }

    let cap = try! capability::get(&TABLE, HANDLES[0]);

    let mut user = try! domains::get(&domains::STORE, cap.object);

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

        kind: abi::Kind::Domain, object: cap.object, rights: abi::Rights(abi::CREATE | abi::ALLOCATE | abi::EXECUTE | abi::WAKE | abi::DESTROY),

    });

    let root = user.image;

    let executable = try! registry::install(&registry::STORE, &mut user.memory.table, root);

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

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

    let stackCap = try! capability::get(&TABLE, stack);

    let stackPage = try! pages::get(&pages::STORE, stackCap.object);

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

        kind: abi::Kind::Domain, object: domains::STORE.contexts[CONTEXTS[2].index].owner, rights: abi::Rights(abi::WAKE),

    });

    let args = @sliceOf(memory(stackPage.base), 40);

    let words = [*granted, *executable, *selfAuthority];

    for word in 0..3 {

        for byte in 0..8 {

            set args[word * 8 + byte] = (words[word] >> (byte as u64 * 8)) as u8;

        }

    }

    for byte in 0..8 {

        set args[32 + byte] = (*parent >> (byte as u64 * 8)) as u8;

    }

    try! domains::activate(&mut domains::STORE, &pages::STORE, &TABLE, HANDLES[0], stackPage.base + 4096, stackPage.base, 40);

    let imageRef = try! registry::image(&registry::STORE, &TABLE, image, abi::Rights(abi::EXECUTE));

    let target = try! registry::exported(&registry::STORE, imageRef, &"spin::count"[..]);

    let case shared::Target::Data(data) = target else panic "counter";

    let timer = try! dispatch::timer(&boot::PLATFORM, 0);

    let clock = dispatch::now(timer);

    let start = clock + 1000000;

    let span: u64 = 8000000;

    set domains::STORE.contexts[CONTEXTS[1].index].frame.pc = worker();

    set domains::STORE.contexts[CONTEXTS[1].index].frame.registers[10] = user.graph.table[data.slot] + data.offset as u64;

    set domains::STORE.contexts[CONTEXTS[1].index].frame.registers[11] = timer.clock;

    set domains::STORE.contexts[CONTEXTS[1].index].frame.registers[12] = start + 3 * span;

    set domains::STORE.contexts[CONTEXTS[1].index].frame.registers[13] = start + 4 * span;

    set domains::STORE.contexts[CONTEXTS[2].index].frame.pc = completion();

    let mut windows: [abi::Handle; 6] = undefined;

    let mut remaining = try! budgets::seed(&mut budgets::STORE, &mut TABLE, 0, start, start + 6 * span);

    for i in 0..6 {

        set windows[i] = remaining;

        if i < 5 {

            set remaining = try! budgets::split(&mut budgets::STORE, &mut TABLE, remaining, start + (i as u64 + 1) * span, clock);

        }

    }

    let owners = &[0 as u32, 0, 1, 0, 1, 2];

    for i in 0..6 {

        if i == 1 {

            continue;

        }

        let owner = owners[i];

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

            budgets::Binding { budget: windows[i], domain: HANDLES[owner], context: CONTEXTS[owner] }, clock);

        if i == 3 {

            for byte in 0..8 {

                set args[24 + byte] = (*handle >> (byte as u64 * 8)) as u8;

            }

        }

    }

}

/// Check state captured by production timer handling after both resumptions.

export unsafe fn verify() {

    let user = domains::STORE.contexts[CONTEXTS[0].index].frame;

    let machine = domains::STORE.contexts[CONTEXTS[1].index].frame;

    assert (user.status & 0x1800) == 0 and (machine.status & 0x1800) == 0x1800;

    assert machine.registers[8] > 0 and machine.registers[9] == 1 and machine.registers[18] > 0;

    let mut domain = try! domains::get(&domains::STORE, domains::STORE.contexts[CONTEXTS[0].index].owner);

    let target = try! registry::exported(&registry::STORE, domain.image, &"spin::extraCount"[..]);

    let case shared::Target::Data(data) = target else panic "extra counter";

    let bytes = @sliceOf(memory(domain.graph.table[data.slot] + data.offset as u64), 8);

    let mut progress: u64 = 0;

    for byte in 0..8 {

        set progress |= bytes[byte] as u64 << (byte as u64 * 8);

    }

    if progress == 0 {

        failed(6);

    }

    let checked = try! registry::exported(&registry::STORE, domain.image, &"spin::destroyed"[..]);

    let case shared::Target::Data(flag) = checked else panic "destruction flag";

    if *memory(domain.graph.table[flag.slot] + flag.offset as u64) <> 1 {

        failed(7);

    }

    let child = try! registry::exported(&registry::STORE, domain.image, &"spin::childId"[..]);

    let case shared::Target::Data(identity) = child else panic "child identity";

    let idBytes = @sliceOf(memory(domain.graph.table[identity.slot] + identity.offset as u64), 8);

    let mut childId: u64 = 0;

    for byte in 0..8 {

        set childId |= idBytes[byte] as u64 << (byte as u64 * 8);

    }

    let owner = domains::STORE.contexts[CONTEXTS[2].index].owner;

    let guard = sync::enter();

    let mut checker = try! domains::get(&domains::STORE, owner);

    assert try! events::flush(&mut domains::STORE.events, owner, &mut checker.memory.ring) == 0;

    assert not try! events::acknowledged(&domains::STORE.events, abi::reference(childId));

    let exited = try! events::pop(&mut checker.memory.ring) else panic "child exit";

    assert exited.kind == events::CHILD_EXIT and exited.code == 0 and exited.value == childId;

    try! events::refresh(&mut domains::STORE.events, owner, &checker.memory.ring);

    assert try! events::acknowledged(&domains::STORE.events, abi::reference(childId));

    sync::leave(guard);

    let wake = try! events::pop(&mut domain.memory.ring) else panic "wake token";

    assert wake.kind == events::WAKEUP and wake.code == 123;

    let timeout = try! events::pop(&mut domain.memory.ring) else panic "timeout token";

    assert timeout.kind == events::TIMEOUT and timeout.code == 77 and timeout.value == 0;

    assert try! events::pop(&mut domain.memory.ring) == nil;

    finish();

}