import cast = unsafe::reinterpret_cast;

native "rust" mod rustrt {
    fn task_sleep(time_in_us: uint);
    fn task_yield();
    fn task_join(t: task) -> int;
    fn unsupervise();
    fn pin_task();
    fn unpin_task();
    fn get_task_id() -> task_id;
    fn clone_chan(c: *rust_chan) -> *rust_chan;

    type rust_chan;
    type rust_task;

    fn set_min_stack(stack_size: uint);

    fn new_task() -> task_id;
    fn get_task_pointer(id : task_id) -> *rust_task;
    fn get_task_context(id : task_id) -> *x86_registers;
    fn start_task(id : task_id);
    fn get_task_trampoline() -> u32;
}

type task_id = int;

fn get_task_id() -> task_id {
    rustrt::get_task_id()
}

/**
 * Hints the scheduler to yield this task for a specified ammount of time.
 *
 * arg: time_in_us maximum number of microseconds to yield control for
 */
fn sleep(time_in_us: uint) { ret rustrt::task_sleep(time_in_us); }

fn yield() { ret rustrt::task_yield(); }

tag task_result { tr_success; tr_failure; }

fn join(t: task) -> task_result {
    alt rustrt::task_join(t) { 0 { tr_success } _ { tr_failure } }
}

fn unsupervise() { ret rustrt::unsupervise(); }

fn pin() { rustrt::pin_task(); }

fn unpin() { rustrt::unpin_task(); }

// FIXME: remove this
fn clone_chan[T](c: chan[T]) -> chan[T] {
    let cloned = rustrt::clone_chan(unsafe::reinterpret_cast(c));
    ret unsafe::reinterpret_cast(cloned);
}

fn send[T](c: chan[T], v: &T) { c <| v; }

fn recv[T](p: port[T]) -> T { let v; p |> v; v }

fn set_min_stack(stack_size : uint) {
    rustrt::set_min_stack(stack_size);
}

// FIXME: make this a fn~ once those are supported.
fn _spawn(thunk : -fn() -> ()) -> task_id {
    let id = rustrt::new_task();

    // the order of arguments are outptr, taskptr, envptr.

    // In LLVM fastcall puts the first two in ecx, edx, and the rest on the
    // stack.
    let regs = rustrt::get_task_context(id);

    // set up the task pointer
    let task_ptr : u32 = cast(rustrt::get_task_pointer(id));
    (*regs).edx = task_ptr;

    let raw_thunk : { code: u32, env: u32 } = cast(thunk);
    (*regs).eip = raw_thunk.code;

    log_err #fmt("{ %u, %u }", raw_thunk.code as uint, raw_thunk.env as uint);

    // okay, now we align the stack and add the environment pointer and a fake
    // return address.

    // -12 for the taskm output location, the env pointer
    // -4 for the return address.
    (*regs).esp = align_down((*regs).esp - 12u32) - 4u32;

    let ra : *mutable u32 = cast((*regs).esp);
    let env : *mutable u32 = cast((*regs).esp+4u32);
    let tptr : *mutable u32 = cast((*regs).esp+12u32);

    // put the return pointer in ecx.
    (*regs).ecx = (*regs).esp + 8u32;

    *tptr = task_ptr;
    *env = raw_thunk.env;
    *ra = rustrt::get_task_trampoline();

    rustrt::start_task(id);

    ret id;
}

// Who says we can't write an operating system in Rust?
type x86_registers = {
    // This needs to match the structure in context.h
    mutable eax : u32,
    mutable ebx : u32,
    mutable ecx : u32,
    mutable edx : u32,
    mutable ebp : u32,
    mutable esi : u32,
    mutable edi : u32,
    mutable esp : u32,

    mutable cs : u16,
    mutable ds : u16,
    mutable ss : u16,
    mutable es : u16,
    mutable fs : u16,
    mutable gs : u16,

    mutable eflags : u32,
    mutable eip : u32
};

fn align_down(x : u32) -> u32 {
    // Aligns x down to 16 bytes
    x & !(15u32)
}

// Local Variables:
// mode: rust;
// fill-column: 78;
// indent-tabs-mode: nil
// c-basic-offset: 4
// buffer-file-coding-system: utf-8-unix
// compile-command: "make -k -C $RBUILD 2>&1 | sed -e 's/\\/x\\//x:\\//g'";
// End: