#ifndef SOCKS_SCHED_H_
#define SOCKS_SCHED_H_

#include <socks/pmap.h>
#include <socks/locks.h>
#include <socks/queue.h>
#include <socks/object.h>
#include <socks/btree.h>
#include <socks/status.h>

#define TASK_NAME_MAX 64
#define PRIO_MAX 32

#ifdef __cplusplus
extern "C" {
#endif

enum task_state {
	TASK_RUNNING,
	TASK_STOPPED,
};

enum thread_state {
	THREAD_READY    = 1,
	THREAD_SLEEPING = 2,
	THREAD_STOPPED  = 3,
};

enum thread_flags {
	THREAD_F_NEED_RESCHED = 0x01u,
	THREAD_F_NO_PREEMPT   = 0x02u,
};

enum sched_priority {
	PRIO_IDLE        = 4,
	PRIO_SUBNORMAL   = 6,
	PRIO_NORMAL      = 10,
	PRIO_SUPERNORMAL = 14,
	PRIO_HIGH        = 18,
	PRIO_REALTIME    = 24,
};

struct task {
	struct task *t_parent;
	unsigned int t_id;
	enum task_state t_state;
	char t_name[TASK_NAME_MAX];

	pmap_t t_pmap;

	struct btree_node t_tasklist;
	struct queue t_threads;
	struct queue t_children;
};

struct thread {
	enum thread_state tr_state : 8;
	enum thread_flags tr_flags : 8;
	struct task *tr_parent;

	unsigned int tr_id;
	unsigned int tr_prio;

	struct queue_entry tr_threads;
	struct queue_entry tr_rqentry;
	void *tr_kstack;
};

struct runqueue {
	struct queue rq_queues[PRIO_MAX];
	uint32_t rq_readybits;
	spin_lock_t rq_lock;
};

extern kern_status_t sched_init(void);
extern void schedule(void);
extern void preempt_disable(void);
extern void preempt_enable(void);

extern void runqueue_init(struct runqueue *rq);

extern struct task *task_alloc(void);
static inline struct task *task_ref(struct task *task) { return (struct task *)object_data(object_ref(object_header(task))); }
static inline void task_deref(struct task *task) { object_deref(object_header(task)); }
extern struct task *task_from_pid(unsigned int pid);
extern struct task *kernel_task(void);

extern bool need_resched(void);
extern struct task *current_task(void);
extern struct thread *current_thread(void);

static inline void task_lock_irqsave(struct task *task, unsigned long *flags)
{
	object_lock(object_header(task), flags);
}

static inline void task_unlock_irqrestore(struct task *task, unsigned long flags)
{
	object_unlock(object_header(task), flags);
}

extern struct thread *thread_alloc(void);

#ifdef __cplusplus
}
#endif

#endif