package data;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;

import net.imglib2.FinalInterval;
import net.imglib2.FinalRealInterval;
import net.imglib2.Interval;
import net.imglib2.IterableRealInterval;
import net.imglib2.KDTree;
import net.imglib2.RealCursor;
import net.imglib2.RealInterval;
import net.imglib2.RealLocalizable;
import net.imglib2.neighborsearch.KNearestNeighborSearch;
import net.imglib2.neighborsearch.KNearestNeighborSearchOnKDTree;
import net.imglib2.util.Util;

public class STDataUtils
{
	static class DistanceStats
	{
		public double avgDist, medianDist, minDist, maxDist;
	}

	public static List< String > commonGeneNames( final List< String > names0, final List< String > names1 )
	{
		final ArrayList< String > commonGeneNames = new ArrayList<>();
		final HashSet< String > names0Hash = new HashSet<>( names0 );

		for ( final String name1 : names1 )
			if ( names0Hash.contains( name1 ) )
				commonGeneNames.add( name1 );

		return commonGeneNames;
	}

	public static Interval getCommonInterval( final STData stDataA, final STData stDataB )
	{
		final ArrayList< STData > list = new ArrayList<>();
		list.add( stDataA );
		list.add( stDataB );

		return getCommonInterval( list );
	}

	public static Interval getCommonIterableInterval( final Collection< ? extends RealInterval > datasets )
	{
		double[] min = null, max = null;

		for ( final RealInterval dataset : datasets )
		{
			if ( min == null )
			{
				min = new double[ dataset.numDimensions() ];
				max = new double[ dataset.numDimensions() ];
				
				dataset.realMin( min );
				dataset.realMax( max );
			}
			else
			{
				for ( int d = 0; d < min.length; ++d )
				{
					min[ d ] = Math.min( min[ d ], dataset.realMin( d ) );
					max[ d ] = Math.max( max[ d ], dataset.realMax( d ) );
				}
			}
		}

		if ( min != null )
		{
			final long[] minL = new long[ min.length ];
			final long[] maxL = new long[ max.length ];

			for ( int d = 0; d < minL.length; ++d )
			{
				minL[ d ] = Math.round( Math.floor( min[ d ] ) );
				maxL[ d ] = Math.round( Math.ceil( max[ d ] ) );
			}

			return new FinalInterval( minL, maxL );
		}
		else
			return null;
	}

	public static Interval getIterableInterval( final RealInterval dataset )
	{
		final long[] minL = new long[ dataset.numDimensions() ];
		final long[] maxL = new long[ dataset.numDimensions() ];

		for ( int d = 0; d < minL.length; ++d )
		{
			minL[ d ] = Math.round( Math.floor( dataset.realMin( d ) ) );
			maxL[ d ] = Math.round( Math.ceil( dataset.realMax( d ) ) );
		}

		return new FinalInterval( minL, maxL );
	}

	public static Interval getCommonInterval( final Collection< STData > datasets )
	{
		long[] min = null, max = null;

		for ( final STData dataset : datasets )
		{
			if ( min == null )
			{
				min = new long[ dataset.getRenderInterval().numDimensions() ];
				max = new long[ dataset.getRenderInterval().numDimensions() ];
				
				dataset.getRenderInterval().min( min );
				dataset.getRenderInterval().max( max );
			}
			else
			{
				for ( int d = 0; d < min.length; ++d )
				{
					min[ d ] = Math.min( min[ d ], dataset.getRenderInterval().min( d ) );
					max[ d ] = Math.max( max[ d ], dataset.getRenderInterval().max( d ) );
				}
			}
		}

		if ( min != null )
			return new FinalInterval( min, max );
		else
			return null;
	}

	public static < R extends RealLocalizable > DistanceStats distanceStats( final KDTree< R > tree )
	{
		final KNearestNeighborSearch< R > search =  new KNearestNeighborSearchOnKDTree<>( tree, 2 );

		final double[] values = new double[ (int)tree.size() ];
		double min = Double.MAX_VALUE;
		double max = -Double.MAX_VALUE;

		int i = 0;

		for ( final R p : tree )
		{
			search.search( p );
			values[ i ] = search.getDistance( 1 );
			min = Math.min( values[ i ], min );
			max = Math.max( values[ i ], max );

			++i;
		}

		final DistanceStats stats = new DistanceStats();

		stats.medianDist = Util.median( values );
		stats.avgDist = Util.average( values );
		stats.minDist = min;
		stats.maxDist = max;

		return stats;
	}

	public static RealInterval computeRealInterval( final IterableRealInterval< ? > coord )
	{
		if ( coord.size() == 0 )
			return null;

		final int n = coord.numDimensions();

		final RealCursor< ? > cursor = coord.localizingCursor();
		cursor.fwd();

		final double[] min = new double[ n ];
		final double[] max = min.clone();

		cursor.localize( min );
		cursor.localize( max );


		while( cursor.hasNext() )
		{
			cursor.fwd();

			for ( int d = 0; d < n; ++d )
			{
				final double pos = cursor.getDoublePosition( d );

				min[ d ] = Math.min( pos, min[ d ] );
				max[ d ] = Math.max( pos, max[ d ] );
			}
		}

		return new FinalRealInterval( min, max );
	}
}