//! Native fixed-width MMIO and authority rejection before register access.

use std::mem;

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;

use kernel::devices;

use kernel::platform;

/// Register storage exposed only through a synthetic Device capability.

static REGISTERS: [u64; 512] = [0; 512];

/// Bootstrap creation, allocation, and budget authority.

unsafe static TABLE: capability::Table = undefined;

/// Child domain identities retained by terminal events.

unsafe static CHILDREN: [abi::Ref; 9] = undefined;

/// Surviving event receiver and native completion checker.

unsafe static PARENT: abi::Ref = undefined;

/// Map a validated physical page.

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

/// Current kernel package-state base.

fn kernelGp() -> u64;

/// Native entry for the completion checker.

fn completion() -> u64;

/// Signal successful completion to the machine fixture.

fn finish();

/// Give each child a disjoint window, followed by the surviving parent.

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 page = try! pages::get(&pages::STORE, (try! capability::get(&TABLE, source)).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 });

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

    set PARENT = (try! capability::get(&TABLE, parentHandle)).object;

    let parent = try! domains::get(&domains::STORE, PARENT);

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

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

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

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

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

    let scratch = devices::STORE.count;

    set devices::STORE.regions[scratch] = {

        kind: platform::Kind::Uart,

        info: { base: (&mut REGISTERS[0]) as u64, size: 4096 },

        rights: abi::Rights(abi::READ | abi::WRITE | abi::GRANT | abi::TRANSFER),

    };

    set devices::STORE.count += 1;

    let mut clockDevice: u32 = 0;

    let mut finish: u32 = 0;

    for i in 0..scratch {

        if devices::STORE.regions[i].kind == platform::Kind::Clint {

            set clockDevice = i;

        }

        if devices::STORE.regions[i].kind == platform::Kind::Finish {

            set finish = i;

        }

    }

    let mut handles: [abi::Handle; 9] = undefined;

    let mut contexts: [abi::Ref; 9] = undefined;

    for i in 0..9 {

        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);

        set CHILDREN[i] = object;

        set handles[i] = handle;

        set contexts[i] = child.initial;

        try! domains::reparent(&mut domains::STORE, &TABLE, handle, parentHandle);

        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 mut region = scratch;

        if i == 2 or i == 6 {

            set region = finish;

        }

        let mut device = try! devices::install(&devices::STORE, &mut child.memory.table, region);

        let slot = (try! abi::decode(device)).object.index;

        if i == 2 {

            set child.memory.table.entries[slot].rights = abi::Rights(abi::READ);

        }

        if i == 3 {

            set child.memory.table.entries[slot].rights = abi::Rights(abi::WRITE);

        }

        if i == 1 {

            set device = abi::Handle(0);

        }

        if i == 7 {

            set device = granted;

        }

        let timerHandle = try! devices::install(&devices::STORE, &mut child.memory.table, clockDevice);

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

        set args[0] = *device; set args[1] = *timerHandle;

        let size = 16 + i as u64;

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

    }

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

    let clock = dispatch::now(timer);

    let start = clock + 1000000;

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

    for i in 0..9 {

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

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

            budgets::Binding { budget: remaining, domain: handles[i], context: contexts[i] }, clock);

        set remaining = next;

    }

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

        budgets::Binding { budget: remaining, domain: parentHandle, context: parent.initial }, clock);

}

/// Check each terminal kind, status, and generation while the parent continues to run.

export unsafe fn verify() {

    let guard = sync::enter();

    let mut parent = try! domains::get(&domains::STORE, PARENT);

    let codes = [61 as u32, 256, 256, 256, 256, 256, 256, 256, 256];

    for i in 0..9 {

        let event = try! events::pop(&mut parent.memory.ring) else panic "missing termination event";

        assert event.value == abi::id(CHILDREN[i]) and event.code == codes[i];

        if i == 0 {

            assert event.kind == events::CHILD_EXIT;

        }

        else {

            assert event.kind == events::FAULT;

        }

        assert domains::STORE.records[CHILDREN[i].index].state == domains::Lifecycle::Dead;

    }

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

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

    sync::leave(guard);

    finish();

}