#include "aine.h"

#include "ne-neuron.h"

namespace aine
{
	///////////////////////////////////////////////////////////////////////////
	//	NeuronObjectComponent
	unsigned int NeuronObjectComponent::counter = 0;
	map<unsigned int,NeuronObjectComponent *> NeuronObjectComponent::objList;

	NeuronObjectComponent::NeuronObjectComponent( void )
	: id( (++counter == 0 ? ++counter : counter) ) , value( 0.0 )
	{
		objList.insert( make_pair( GetId() , this ) );
	}

	NeuronObjectComponent::~NeuronObjectComponent( void )
	{
		map<unsigned int,NeuronObjectComponent *>::iterator pos = objList.find( GetId() );
		if( pos != objList.end() )
			objList.erase( pos );
	}

	NeuronObjectComponent *NeuronObjectComponent::GetObject( const unsigned int id )
	{
		map<unsigned int,NeuronObjectComponent *>::iterator pos = objList.find( id );

		if( pos != objList.end() )	
			return pos->second;
		return 0;
	}
	///////////////////////////////////////////////////////////////////////////
	//	Dendrite
	bool Dendrite::ReceptorSite( const double v )
	{
		valReceived = max( 0.0 , min( 1.0 , v ) );
		return soma.ActionPotential( v * GetValue() );
	}

	bool Dendrite::Adjust( const double delta )
	{
		if( valReceived != 0 )
		{
			SetValue( GetValue() + delta );
		
			return ReceptorSite( valReceived );
		}
		return false;
	}

	bool Dendrite::Trace( ostream *out )	
	{	
		*out << "\t--> D[" << GetId() << "]: weight = " << GetValue() << endl;	
		return true;	
	}

	///////////////////////////////////////////////////////////////////////////
	//	SynapticKnob
	bool SynapticKnob::Depolarization( const double v )
	{
		double val = v;
		if( skConnectId )
		{
			SynapticKnob *sk = dynamic_cast<SynapticKnob *>( NeuronObjectComponent::GetObject( skConnectId ) );
			sk->soma.Depolarization();
			if( val )
				val = max( 0.0 , val - GetValue() );
			else
				val = GetValue();
		}
		BaseLink *b = dynamic_cast<BaseLink *>( NeuronObjectComponent::GetObject( GetLinkId() ) );
		if( b )
			return b->ReceptorSite( cb( val ) );
		return false;
	}

	bool SynapticKnob::Trace( ostream *out )	
	{	
		*out << "\tSK[" << GetId() << "]"  << endl;	
		return true;	
	}

	///////////////////////////////////////////////////////////////////////////
	//	Soma
	bool Soma::ActionPotential( const double nv )
	{
		SetValue( GetValue() + nv );	
		return GetValue() > threshold;
	}

	bool Soma::Depolarization( void )
	{
		const double v = max( 0.0 , GetValue() - GetThreshold() );
		Refractory();
		const bool ans = ForEach( axon.begin() , axon.end() , bind2nd( mem_fun( &SynapticKnob::Depolarization ) , v ) ) > 0;
		return ans;
	}

	///////////////////////////////////////////////////////////////////////////
	//	Neuron
	Neuron::~Neuron( void )
	{
		for( vector<SynapticKnob *>::iterator it = axon.begin() ; it != axon.end() ; ++it )
			delete *it;
		for( vector<Dendrite *>::iterator jt = begin() ; jt != end() ; ++jt )
			delete *jt;
	}

	SynapticKnob *Neuron::ConnectWith( Neuron *n2 )
	{
		SynapticKnob *ans = GetSynapticKnob();
		ans->LinkD( n2->GetDendrite() );
		return ans;
	}

	SynapticKnob *Neuron::ConnectTo( Neuron *n2 )
	{
		SynapticKnob *ans = GetSynapticKnob();
		ans->Link( n2 );
		return ans;
	}

	SynapticKnob *Neuron::ConnectTo( SynapticKnob *sk )
	{
		SynapticKnob *ans = GetSynapticKnob();
		ans->LinkSK( sk );
		return ans;
	}

	Dendrite *Neuron::GetDendrite( const unsigned int id )
	{
		Dendrite *d = dynamic_cast<Dendrite *>( NeuronObjectComponent::GetObject( id ) );
		if( d == 0 )
			push_back( d = new Dendrite( *this ) );
		return d;
	}

	SynapticKnob *Neuron::GetSynapticKnob( const unsigned int id )
	{
		SynapticKnob *d = dynamic_cast<SynapticKnob *>( NeuronObjectComponent::GetObject( id ) );
		if( d == 0 )
			axon.push_back( d = new SynapticKnob( *this ) );
		return d;
	}

	double Neuron::GetResult( void )
	{
		if( ActionPotential() )
			return GetValue() - GetThreshold();
		return 0.0;
	}

	///////////////////////////////////////////////////////////////////////////////////////////////////////////
	//	ADJUSTING  PROCEDURE
	bool Neuron::Adjust( const double v )
	{
		const double sv = GetValue();
		Refractory();
		return ForEach( begin() , end() , Adjusting( this , v , sv )  ) > 0;
	}

	double Adjusting::GetRatio( void )
	{
		const double lr = 1.0;
		if( !soma->empty() )
			return lr / (double)count_if( soma->begin() , soma->end() , mem_fun( &Dendrite::ValReceivedNotNull ) );
		return 0.0;
	}

	bool Adjusting::operator()( Dendrite *d )
	{
		double Delta = 0.0;

		if( d->GetValue() != 0.0 )
			Delta = GetRatio() * (expected - somaValue) / d->GetValue();
		
		if( Delta != 0.0 )
			return d->Adjust( Delta );
		
		return false;
	}
}