#include <kernel/sched.h>
#include <kernel/thread.h>
#include <kernel/util.h>
#include <kernel/vm-controller.h>

kern_status_t vm_controller_type_init(void)
{
	return KERN_UNIMPLEMENTED;
}

struct vm_controller *vm_controller_cast(struct object *obj)
{
	return NULL;
}

struct vm_controller *vm_controller_create(void)
{
	return NULL;
}

kern_status_t vm_controller_create_object(
	struct vm_controller *ctrl,
	const char *name,
	size_t name_len,
	equeue_key_t key,
	size_t data_len,
	vm_prot_t prot,
	struct vm_object **out)
{
	return KERN_UNIMPLEMENTED;
}

kern_status_t vm_controller_detach_object(
	struct vm_controller *ctrl,
	struct vm_object *vmo)
{
	return KERN_UNIMPLEMENTED;
}

static kern_status_t try_enqueue(struct btree *tree, struct page_request *req)
{
	if (!tree->b_root) {
		tree->b_root = &req->req_node;
		btree_insert_fixup(tree, &req->req_node);
		return true;
	}

	struct btree_node *cur = tree->b_root;
	while (1) {
		struct page_request *cur_node
			= BTREE_CONTAINER(struct page_request, req_node, cur);
		struct btree_node *next = NULL;

		if (req->req_id > cur_node->req_id) {
			next = btree_right(cur);

			if (!next) {
				btree_put_right(cur, &req->req_node);
				break;
			}
		} else if (req->req_id < cur_node->req_id) {
			next = btree_left(cur);

			if (!next) {
				btree_put_left(cur, &req->req_node);
				break;
			}
		} else {
			return false;
		}

		cur = next;
	}

	btree_insert_fixup(tree, &req->req_node);
	return true;
}

static void wait_for_reply(
	struct vm_controller *ctrl,
	struct page_request *req,
	unsigned long *lock_flags)
{
	struct wait_item waiter;
	struct thread *self = current_thread();

	wait_item_init(&waiter, self);
	for (;;) {
		self->tr_state = THREAD_SLEEPING;
		if (req->req_status == PAGE_REQUEST_COMPLETE) {
			break;
		}

		vm_controller_unlock_irqrestore(ctrl, *lock_flags);
		schedule(SCHED_NORMAL);
		vm_controller_lock_irqsave(ctrl, lock_flags);
	}

	self->tr_state = THREAD_READY;
}

kern_status_t vm_controller_send_request(
	struct vm_controller *ctrl,
	struct page_request *req)
{
	fill_random(&req->req_id, sizeof req->req_id);
	while (!try_enqueue(&ctrl->vc_requests, req)) {
		req->req_id++;
	}

	return KERN_OK;
}