#include "locks.hfa"
#include "kernel_private.hfa"
#include <stdlib.h>
#include <stdio.h>

#include <kernel.hfa>
#include <stdlib.hfa>
#include <thread.hfa>

///////////////////////////////////////////////////////////////////
//// info_thread
///////////////////////////////////////////////////////////////////

forall(dtype L | is_blocking_lock(L)) {
	void ?{}( info_thread(L) & this, $thread * t ) {
		((Seqable &) this){};
		this.t = t;
		this.lock = 0p;
		this.listed = false;
	}

	void ?{}( info_thread(L) & this, $thread * t, uintptr_t info ) {
		((Seqable &) this){};
		this.t = t;
		this.info = info;
		this.lock = 0p;
		this.listed = false;
	}

	void ^?{}( info_thread(L) & this ){ }
}

///////////////////////////////////////////////////////////////////
//// Blocking Locks
///////////////////////////////////////////////////////////////////

void ?{}( blocking_lock & this, bool multi_acquisition, bool strict_owner ) {
	this.lock{};
	this.blocked_threads{};
	this.wait_count = 0;
	this.multi_acquisition = multi_acquisition;
	this.strict_owner = strict_owner;
	this.owner = 0p;
	this.recursion_count = 0;
}

void ^?{}( blocking_lock & this ) {}
void ?{}( single_acquisition_lock & this ) {((blocking_lock &)this){ false, false };}
void ^?{}( single_acquisition_lock & this ) {}
void ?{}( owner_lock & this ) {((blocking_lock &)this){ true, true };}
void ^?{}( owner_lock & this ) {}
void ?{}( multiple_acquisition_lock & this ) {((blocking_lock &)this){ true, false };}
void ^?{}( multiple_acquisition_lock & this ) {}

void lock( blocking_lock & this ) with( this ) {
	lock( lock __cfaabi_dbg_ctx2 );
	if ( owner == active_thread() && !multi_acquisition) {
		abort("A single acquisition lock holder attempted to reacquire the lock resulting in a deadlock.");
	} else if ( owner != 0p && owner != active_thread() ) {
		append( blocked_threads, active_thread() );
		wait_count++;
		unlock( lock );
		park( );
	} else if ( owner == active_thread() && multi_acquisition ) {
		recursion_count++;
		unlock( lock );
	} else {
		owner = active_thread();
		recursion_count = 1;
		unlock( lock );
	}
}

bool try_lock( blocking_lock & this ) with( this ) {
	bool ret = false;
	lock( lock __cfaabi_dbg_ctx2 );
	if ( owner == 0p ) {
		owner = active_thread();
		recursion_count = 1;
		ret = true;
	} else if ( owner == active_thread() && multi_acquisition ) {
		recursion_count++;
		ret = true;
	}
	unlock( lock );
	return ret;
}

void unlock_error_check( blocking_lock & this ) with( this ) {
	if ( owner == 0p ){ // no owner implies lock isn't held
		abort( "There was an attempt to release a lock that isn't held" ); 
	} else if ( strict_owner && owner != active_thread() ) {
		abort( "A thread other than the owner attempted to release an owner lock" ); 
	}
}

void pop_and_set_new_owner( blocking_lock & this ) with( this ) {
	$thread * t = pop_head( blocked_threads );
	owner = t;
	recursion_count = ( t ? 1 : 0 );
	wait_count--;
	unpark( t );
}

void unlock( blocking_lock & this ) with( this ) {
	lock( lock __cfaabi_dbg_ctx2 );
	unlock_error_check( this );
	recursion_count--;
	if ( recursion_count == 0 ) {
		pop_and_set_new_owner( this );
	}
	unlock( lock );
}

size_t wait_count( blocking_lock & this ) with( this ) {
	return wait_count;
}

void set_recursion_count( blocking_lock & this, size_t recursion ) with( this ) {
	recursion_count = recursion;
}

size_t get_recursion_count( blocking_lock & this ) with( this ) {
	return recursion_count;
}

void add_( blocking_lock & this, $thread * t ) with( this ) {
    lock( lock __cfaabi_dbg_ctx2 );
	if ( owner != 0p ) {
		append( blocked_threads, t );
		wait_count++;
		unlock( lock );
	} else {
		owner = t;
		recursion_count = 1;
		unpark( t );
		unlock( lock );
	}
}

void remove_( blocking_lock & this ) with( this ) {
    lock( lock __cfaabi_dbg_ctx2 );
	unlock_error_check( this );
	pop_and_set_new_owner( this );
	unlock( lock );
}

///////////////////////////////////////////////////////////////////
//// Overloaded routines for traits
///////////////////////////////////////////////////////////////////

// This is temporary until an inheritance bug is fixed

void lock( single_acquisition_lock & this ){ lock( (blocking_lock &)this ); }
void unlock( single_acquisition_lock & this ){ unlock( (blocking_lock &)this ); }
void add_( single_acquisition_lock & this, struct $thread * t ){ add_( (blocking_lock &)this, t ); }
void remove_( single_acquisition_lock & this ){ remove_( (blocking_lock &)this ); }
void set_recursion_count( single_acquisition_lock & this, size_t recursion ){ set_recursion_count( (blocking_lock &)this, recursion ); }
size_t get_recursion_count( single_acquisition_lock & this ){ return get_recursion_count( (blocking_lock &)this ); }

void lock( owner_lock & this ){ lock( (blocking_lock &)this ); }
void unlock( owner_lock & this ){ unlock( (blocking_lock &)this ); }
void add_( owner_lock & this, struct $thread * t ){ add_( (blocking_lock &)this, t ); }
void remove_( owner_lock & this ){ remove_( (blocking_lock &)this ); }
void set_recursion_count( owner_lock & this, size_t recursion ){ set_recursion_count( (blocking_lock &)this, recursion ); }
size_t get_recursion_count( owner_lock & this ){ return get_recursion_count( (blocking_lock &)this ); }

void lock( multiple_acquisition_lock & this ){ lock( (blocking_lock &)this ); }
void unlock( multiple_acquisition_lock & this ){ unlock( (blocking_lock &)this ); }
void add_( multiple_acquisition_lock & this, struct $thread * t ){ add_( (blocking_lock &)this, t ); }
void remove_( multiple_acquisition_lock & this ){ remove_( (blocking_lock &)this ); }
void set_recursion_count( multiple_acquisition_lock & this, size_t recursion ){ set_recursion_count( (blocking_lock &)this, recursion ); }
size_t get_recursion_count( multiple_acquisition_lock & this ){ return get_recursion_count( (blocking_lock &)this ); }

///////////////////////////////////////////////////////////////////
//// condition variable
///////////////////////////////////////////////////////////////////

forall(dtype L | is_blocking_lock(L)) {

	void timeout_handler ( alarm_node_wrap(L) & this ) with( this ) {
    	// This condition_variable member is called from the kernel, and therefore, cannot block, but it can spin.
	    lock( cond->lock __cfaabi_dbg_ctx2 );
	    
	    if ( i->listed ) {			// is thread on queue
	    	cond->last_thread = i;		// REMOVE THIS AFTER DEBUG
			remove( cond->blocked_threads, *i );		 //remove this thread O(1)
			cond->count--;
			if( !i->lock ) {
				unpark( i->t );
	    	} else {
	    		add_(*i->lock, i->t);			// call lock's add_
	    	}
	    }
	    unlock( cond->lock );
	}

	void alarm_node_wrap_cast( alarm_node_t & a ) { timeout_handler( (alarm_node_wrap(L) &)a ); }

	void ?{}( condition_variable(L) & this ){
		this.lock{};
		this.blocked_threads{};
		this.count = 0;
		this.last_thread = 0p; // REMOVE AFTER DEBUG
	}

	void ^?{}( condition_variable(L) & this ){ }

	void ?{}( alarm_node_wrap(L) & this, $thread * thrd, Time alarm, Duration period, Alarm_Callback callback ) {
		this.alarm_node{ thrd, alarm, period, callback };
	}

	void ^?{}( alarm_node_wrap(L) & this ) { }

	void process_popped( condition_variable(L) & this, info_thread(L) & popped ) with( this ) {
		if(&popped != 0p) {
			popped.listed = false;
			count--;
			if (popped.lock) {
				add_(*popped.lock, popped.t);
			} else {
				unpark(popped.t);
			}
		}
	}

	bool notify_one( condition_variable(L) & this ) with( this ) {
		lock( lock __cfaabi_dbg_ctx2 );
		bool ret = !empty(blocked_threads);
		process_popped(this, dropHead( blocked_threads ));
		unlock( lock );
		return ret;
	}

	bool notify_all( condition_variable(L) & this ) with(this) {
		lock( lock __cfaabi_dbg_ctx2 );
		bool ret = !empty(blocked_threads);
		while( !empty(blocked_threads) ) {
			process_popped(this, dropHead( blocked_threads ));
		}
		unlock( lock );
		return ret;
	}

	uintptr_t front( condition_variable(L) & this ) with(this) {
		return empty(blocked_threads) ? NULL : head(blocked_threads).info;
	}

	bool empty( condition_variable(L) & this ) with(this) { return empty(blocked_threads); }

	int counter( condition_variable(L) & this ) with(this) { return count; }

	size_t queue_and_get_recursion( condition_variable(L) & this, info_thread(L) * i ) with(this) {
		addTail( blocked_threads, *i );
		count++;
		i->listed = true;
		size_t recursion_count = 0;
		if (i->lock) {
			i->t->link.next = 1p;
			recursion_count = get_recursion_count(*i->lock);
			remove_( *i->lock );
		}
		return recursion_count;
	}

	// helper for wait()'s' with no timeout
	void queue_info_thread( condition_variable(L) & this, info_thread(L) & i ) with(this) {
		lock( lock __cfaabi_dbg_ctx2 );
		size_t recursion_count = queue_and_get_recursion(this, &i);
		unlock( lock );
		park( ); // blocks here
		if (i.lock) set_recursion_count(*i.lock, recursion_count); // resets recursion count here after waking
	}

	// helper for wait()'s' with a timeout
	void queue_info_thread_timeout( condition_variable(L) & this, info_thread(L) & info, Time t ) with(this) {
		lock( lock __cfaabi_dbg_ctx2 );
		size_t recursion_count = queue_and_get_recursion(this, &info);
		alarm_node_wrap(L) node_wrap = { info.t, t, 0`s, alarm_node_wrap_cast };
		node_wrap.cond = &this;
		node_wrap.i = &info;
		register_self( &node_wrap.alarm_node );
		unlock( lock );
		park();
		unregister_self( &node_wrap.alarm_node );
		if (info.lock) set_recursion_count(*info.lock, recursion_count);
	}

	void wait( condition_variable(L) & this ) with(this) {
		info_thread( L ) i = { active_thread() };
		queue_info_thread( this, i );
	}

	void wait( condition_variable(L) & this, uintptr_t info ) with(this) {
		info_thread( L ) i = { active_thread(), info };
		queue_info_thread( this, i );
	}
	
	void wait( condition_variable(L) & this, Duration duration ) with(this) {
		info_thread( L ) i = { active_thread() };
		queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
	}

	void wait( condition_variable(L) & this, uintptr_t info, Duration duration ) with(this) { 
		info_thread( L ) i = { active_thread(), info };
		queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
	}

	void wait( condition_variable(L) & this, Time time ) with(this) {
		info_thread( L ) i = { active_thread() };
		queue_info_thread_timeout(this, i, time);
	}

	void wait( condition_variable(L) & this, uintptr_t info, Time time ) with(this) {
		info_thread( L ) i = { active_thread(), info };
		queue_info_thread_timeout(this, i, time);
	}

	void wait( condition_variable(L) & this, L & l ) with(this) {
		info_thread(L) i = { active_thread() };
		i.lock = &l;
		queue_info_thread( this, i );
	}

	void wait( condition_variable(L) & this, L & l, uintptr_t info ) with(this) {
		info_thread(L) i = { active_thread(), info };
		i.lock = &l;
		queue_info_thread( this, i );
	}
	
	void wait( condition_variable(L) & this, L & l, Duration duration ) with(this) {
		info_thread(L) i = { active_thread() };
		i.lock = &l;
		queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
	}
	
	void wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ) with(this) {
		info_thread(L) i = { active_thread(), info };
		i.lock = &l;
		queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
	}
	
	void wait( condition_variable(L) & this, L & l, Time time ) with(this) {
		info_thread(L) i = { active_thread() };
		i.lock = &l;
		queue_info_thread_timeout(this, i, time );
	}
	
	void wait( condition_variable(L) & this, L & l, uintptr_t info, Time time ) with(this) {
		info_thread(L) i = { active_thread(), info };
		i.lock = &l;
		queue_info_thread_timeout(this, i, time );
	}
}