using System;
using System.Collections.Generic;
using Assistance.Drawing;

namespace Assistance {
	public class Track {
		public interface IOwner { }

		public class Handler {
			public readonly IOwner owner;
			public readonly Track original;
			public readonly List<Track> tracks = new List<Track>();
			public Handler(IOwner owner, Track original) {
				this.owner = owner;
				this.original = original;
			}
		}

		public class Modifier {
			public readonly Handler handler;
			public readonly double timeOffset;

			public Modifier(Handler handler, double timeOffset = 0.0)
				{ this.handler = handler; this.timeOffset = timeOffset; }
			public IOwner owner
				{ get { return handler.owner; } }
			public Track original
				{ get { return handler.original; } }
			public virtual Point calcPoint(double originalIndex) {
				Point p = original.calcPoint(originalIndex);
				p.originalIndex = originalIndex;
				return p;
			}
		}

		public struct Point {
			public Assistance.Point position;
			public double pressure;
			public Assistance.Point tilt;

			public double originalIndex;
			public double time;
			public double length;
			
			public bool final;
	
			public Point(
				Assistance.Point position,
				double pressure = 0.5,
				Assistance.Point tilt = new Assistance.Point(),
				double originalIndex = 0.0,
				double time = 0.0,
				double length = 0.0,
				bool final = false
			) {
				this.position = position;
				this.pressure = pressure;
				this.tilt = tilt;
				this.originalIndex = originalIndex;
				this.time = time;
				this.length = length;
				this.final = final;
			}
		}
		

		private static long lastId;
		private readonly List<Point> privatePoints = new List<Point>();
		private int privatePointsRemoved;
		private int privatePointsAdded;
		
		public readonly long id;
		public readonly Gdk.Device device;
		public readonly long touchId;
		public readonly KeyHistory<Gdk.Key>.Holder keyHistory;
		public readonly KeyHistory<uint>.Holder buttonHistory;

		public readonly Modifier modifier;
		
		public Handler handler;

		public Track(
			Gdk.Device device = null,
			long touchId = 0,
			KeyHistory<Gdk.Key>.Holder keyHistory = null,
			KeyHistory<uint>.Holder buttonHistory = null
		) {
			this.id = ++lastId;
			this.device = device;
			this.touchId = touchId;
			this.keyHistory = keyHistory;
			this.buttonHistory = buttonHistory;
		}
		
		public Track(Modifier modifier):
			this( modifier.original.device,
				  modifier.original.touchId,
				  modifier.original.keyHistory.offset( modifier.timeOffset ),
				  modifier.original.buttonHistory.offset( modifier.timeOffset ) )
			{ this.modifier = modifier; }

		public Track original
			{ get { return modifier != null ? modifier.original : null; } }
		public double timeOffset
			{ get { return modifier != null ? modifier.timeOffset : 0.0; } }
		public long ticks
			{ get { return keyHistory.ticks; } }
			
		public int pointsAdded
			{ get { return privatePointsAdded; } }
		public int pointsRemoved
			{ get { return privatePointsRemoved; } }
		public void resetRemoved()
			{ privatePointsRemoved = 0; }
		public void resetAdded()
			{ privatePointsAdded = 0; }
		public void resetCounters()
			{ resetRemoved(); resetAdded(); }
		public void forceRemoved(int pointsRemoved)
			{ privatePointsRemoved = pointsRemoved; }
		public void forceAdded(int pointsAdded)
			{ privatePointsAdded = pointsAdded; }
		
		public bool wasRemoved
			{ get { return pointsRemoved > 0; } }
		public bool wasAdded
			{ get { return pointsAdded > 0; } }
		public bool wasChanged
			{ get { return wasRemoved || wasAdded; } }

		public bool isEmpty
			{ get { return count == 0; } }
		public int count
			{ get { return privatePoints.Count; } }
		public void remove(int count = 1) {
			if (count > this.count) count = this.count;
			if (count <= 0) return;
			privatePoints.RemoveRange(this.count - count, count);
			privatePointsRemoved += count;
		}
		public void truncate(int count)
			{ remove(this.count - count); }
		public void add(Point p) {
			if (!isEmpty) {
				Point previous = getLast();
				// fix originalIndex
				if (p.originalIndex < previous.originalIndex)
					p.originalIndex = previous.originalIndex;
				// fix time
				p.time = Math.Max(p.time, previous.time + Timer.step);
				// calculate length
				p.length = previous.length + (p.position - previous.position).len();
			}
			privatePoints.Add(p);
			++privatePointsAdded;
		}
		
		public Point this[int index]
			{ get { return getPoint(index); } }
		public IEnumerable<Point> points
			{ get { return privatePoints; } }

		public Track getRoot()
			{ return original == null ? this : original.getRoot(); }
		public int getLevel()
			{ return original == null ? 0 : original.getLevel() + 1; }
		
		public Point getFirst()
			{ return getPoint(0); }
		public Point getLast()
			{ return getPoint(count - 1); }
		public bool isFinished()
			{ return count > 0 && getLast().final; }
		
		public int clampIndex(int index)
			{ return Math.Min(Math.Max(index, 0), count - 1); }
		public int floorIndex(double index, out double frac) {
			int i = (int)Math.Floor(index + Geometry.precision);
			if (i > count - 1)
				{ frac = 0.0; return count - 1; }
			if (i < 0)
				{ frac = 0.0; return 0; }
			frac = Math.Max(0.0, index - (double)i);
			return i;
		}
		public int floorIndexNoClamp(double index)
			{ return (int)Math.Floor(index + Geometry.precision); }
		public int floorIndex(double index)
			{ return clampIndex(floorIndexNoClamp(index)); }
		public int ceilIndexNoClamp(double index)
			{ return (int)Math.Ceiling(index - Geometry.precision); }
		public int ceilIndex(double index)
			{ return clampIndex(ceilIndexNoClamp(index)); }
		
		public Point getPoint(int index) {
			index = clampIndex(index);
			return index < 0 ? new Point() : privatePoints[index];
		}
		public Point floorPoint(double index, out double frac)
			{ return getPoint(floorIndex(index, out frac)); }
		public Point floorPoint(double index)
			{ return getPoint(floorIndex(index)); }
		public Point ceilPoint(double index)
			{ return getPoint(ceilIndex(index)); }
		
		private delegate double PointFieldGetter(Point p);
		private double binarySearch(double value, PointFieldGetter getter) {
			// points[a].value <= value < points[b].value
			
			if (isEmpty) return 0.0;
			int a = 0;
			double aa = getter(privatePoints[a]);
			if (value - aa <= 0.5*Geometry.precision) return (double)a;

			int b = count - 1;
			double bb = getter(privatePoints[b]);
			if (bb - value <= 0.5*Geometry.precision) return (double)b;
			
			while(true) {
				int c = (a + b)/2;
				if (a == c) break;
				double cc = getter(privatePoints[c]);
				if (cc - value > 0.5*Geometry.precision)
					{ b = c; bb = cc; } else { a = c; aa = cc; }
			}

			return bb - aa >= 0.5*Geometry.precision ? (double)a + (value - aa)/(bb - aa) : (double)a;
		}
			
		public double indexByOriginalIndex(double originalIndex)
			{ return binarySearch(originalIndex, delegate(Point p) { return p.originalIndex; }); }
		public double indexByTime(double time)
			{ return binarySearch(time, delegate(Point p) { return p.time; }); }
		public double indexByLength(double length)
			{ return binarySearch(length, delegate(Point p) { return p.length; }); }
		
		public double originalIndexByIndex(double index) {
			double frac;
			Point p0 = floorPoint(index, out frac), p1 = ceilPoint(index);
			return Geometry.interpolationLinear(p0.originalIndex, p1.originalIndex, frac);
		}
		public double timeByIndex(double index) {
			double frac;
			Point p0 = floorPoint(index, out frac), p1 = ceilPoint(index);
			return Geometry.interpolationLinear(p0.time, p1.time, frac);
		}
		public double lengthByIndex(double index) {
			double frac;
			Point p0 = floorPoint(index, out frac), p1 = ceilPoint(index);
			return Geometry.interpolationLinear(p0.length, p1.length, frac);
		}

		public Point calcPoint(double index) {
			return modifier == null
			     ? interpolateLinear(index)
			     : modifier.calcPoint( originalIndexByIndex(index) );
		}
		
		public Assistance.Point calcTangent(double index, double distance = 0.1) {
			double minDistance = 10.0*Geometry.precision;
			if (distance < minDistance) distance = minDistance;
			Point p = calcPoint(index);
			Point pp = calcPoint(indexByLength(p.length - distance));
			Assistance.Point dp = p.position - pp.position;
			double lenSqr = dp.lenSqr();
			return lenSqr > Geometry.precisionSqr ? dp*Math.Sqrt(1.0/lenSqr) : new Assistance.Point();
		}
		
		public Point interpolateLinear(double index) {
			double frac;
			Point p0 = floorPoint(index, out frac);
			Point p1 = ceilPoint(index);
			return interpolateLinear(p0, p1, frac);
		}

		public static Point interpolateLinear(Point p0, Point p1, double l) {
			if (l <= Geometry.precision) return p0;
			if (l >= 1.0 - Geometry.precision) return p1;
			return new Point(
				Geometry.interpolationLinear(p0.position, p1.position, l),
				Geometry.interpolationLinear(p0.pressure, p1.pressure, l),
				Geometry.interpolationLinear(p0.tilt, p1.tilt, l),
				Geometry.interpolationLinear(p0.originalIndex, p1.originalIndex, l),
				Geometry.interpolationLinear(p0.time, p1.time, l),
				Geometry.interpolationLinear(p0.length, p1.length, l) );
		}
		
		public void print() {
			foreach(Point wp in privatePoints)
				Console.Write(
					"{2:f1}, ",
					wp.position.x,
					wp.position.y,
					wp.originalIndex );
			Console.WriteLine();
		}

		public void verify(string message) {
			bool error = false;
			for(int i = 1; i < count; ++i) {
				Point pp = privatePoints[i-1];
				Point p = privatePoints[i];
				if ( Geometry.isGreater(pp.originalIndex, p.originalIndex)
				  /*|| Geometry.isGreater(pp.length, p.length)
				  || Geometry.isGreater(pp.time, p.time)
				  || pp.final*/ )
				{
					if (!error) Console.WriteLine("Track error: " + message);
					error = true;
					Console.WriteLine("--- index: " + (i-1) + " / " + i);
					Console.WriteLine("    originalIndex: " + pp.originalIndex + " / " + p.originalIndex);
					Console.WriteLine("    length: " + pp.length + " / " + p.length);
					Console.WriteLine("    time: " + pp.time + " / " + p.time);
					Console.WriteLine("    final: " + pp.final + " / " + p.final);
				}	
			}
			if (error) print();
		}
	}
}