package com.axe.path;

import com.axe.core.Attribute;
import com.axe.io.InputModel;
import com.axe.io.OutputModel;
import com.axe.math.Scalari;

public class KramerPath<T> implements Path<T> 
{
	
	public static final float DEFAULT_LOOSENESS = 0.0575f;
	
	protected Attribute<T>[] points;
	protected Attribute<T> temp0;
	protected Attribute<T> temp1;
	protected int depth;
	protected float looseness;
	protected boolean loops;
	
	public KramerPath()
	{
	}
	
	public KramerPath( int depth, boolean loops, Attribute<T> ... points )
	{
		this( depth, loops, DEFAULT_LOOSENESS, points );
	}
	
	public KramerPath( int depth, boolean loops, float looseness, Attribute<T> ... points ) 
	{
		this.depth = depth;
		this.loops = loops;
		this.looseness = looseness;
		this.points = points;
		this.temp0 = points[0].create();
		this.temp1 = points[0].create();
	}
	
	@Override
	public T set(Attribute<T> subject, float delta) 
	{
		final int n = points.length;
		final float a = delta * n;
		final int i = Scalari.clamp( (int)a, 0, n - 1 );
		float d = a - i;
		
		// v0 and v5 are used to calculate the next v1 or v4, at the next level.
		T v0 = points[ getActualIndex( i - 2 ) ].get();
		T v1 = points[ getActualIndex( i - 1 ) ].get();
		T v2 = points[ getActualIndex( i ) ].get();
		T v3 = points[ getActualIndex( i + 1 ) ].get();
		T v4 = points[ getActualIndex( i + 2 ) ].get();
		T v5 = points[ getActualIndex( i + 3 ) ].get();
		
		for (int k = 0; k < depth; k++)
		{
			// Get mid point
			T mid = getPoint( v1, v2, v3, v4 );
			
			// If the desired point is closer to v2...
			if (d < 0.5f)
			{
				// shift all surrounding points one-level closer to v2
				T newEnd = v1;
				v5 = v4;
				v4 = v3;
				v3 = mid;
				v1 = getPoint( v0, v1, v2, v3 );
				v0 = newEnd;
				// adjust d so it's between 0.0 an 1.0
				d = d * 2.0f;
			}
			// else, the desired point is closer to v3...
			else
			{
				// shift all surrounding points one-level closer to v3
				T newEnd = v4;
				v0 = v1;
				v1 = v2;
				v2 = mid;
				v4 = getPoint( v2, v3, v4, v5 );
				v5 = newEnd;
				// adjust d so it's between 0.0 an 1.0
				d = (d - 0.5f) * 2.0f;
			}
		}
		
		// subject = (v3 - v2) * d + v2
		subject.interpolate( v2, v3, d );
		
		return subject.get();
	}
	
	public T getPoint( T v1, T v2, T v3, T v4 )
	{
		// p = (0.5f + looseness) * (v2 + v3) - looseness * (v1 + v4)
		
		temp0.set( v2 );
		temp0.add( v3, 1f );
		temp0.scale( 0.5f + looseness );
		
		temp1.set( v1 );
		temp1.add( v4, 1f );
		temp0.add( temp1.get(), -looseness );
		
		return temp0.clone();
	}
	
	public int getActualIndex( int index )
	{
		final int n = points.length;
		
		return ( loops ? (index + n) % n : Scalari.clamp( index, 0, n - 1 ) );
	}

	@Override
	public int getAttributeCount()
	{
		return points.length;
	}

	@Override
	public Attribute<T> getAttribute(int index)
	{
		return points[ index ];
	}

	@Override
	public T get(int index)
	{
		return points[ index ].get();
	}
	
	public Attribute<T>[] points() 
	{
		return points;
	}

	@Override
	public void read( InputModel input )
	{
		depth = input.readInt( "depth" );
		loops = input.readBoolean( "loops" );
		looseness = input.readFloat( "looseness" );
		points = input.readModelArray( "point", "point-type" );
		temp0 = points[0].create();
		temp1 = points[0].create();
	}

	@Override
	public void write( OutputModel output )
	{
		output.write( "depth", depth );
		output.write( "loops", loops );
		output.write( "looseness", looseness );
		output.writeModelArray( "point", points, "point-type" );
	}
	
}