using System;
using System.Collections.Generic;

namespace Assistance {
	public class InputModifierTangents: InputManager.Modifier {
		public struct Tangent {
			public Point position;
			public double pressure;
			public Point tilt;
			
			public Tangent(
				Point position,
				double pressure = 0.0,
				Point tilt = new Point() )
			{
				this.position = position;
				this.pressure = pressure;
				this.tilt = tilt;
			}
		}
	
		public class Modifier: Track.Modifier {
			public Modifier(Track.Handler handler):
				base(handler) { }
			
			public InputManager.KeyPoint.Holder holder = null;
			public readonly List<Tangent> tangents = new List<Tangent>();
			
			public override Track.Point calcPoint(double originalIndex) {
				double frac;
				int i0 = original.floorIndex(originalIndex, out frac);
				int i1 = original.ceilIndex(originalIndex);
				Track.Point p = i0 < 0 ? new Track.Point()
				              : interpolateSpline(
									original[i0],
									original[i1],
									i0 < tangents.Count ? tangents[i0] : new Tangent(),
									i1 < tangents.Count ? tangents[i1] : new Tangent(),
									frac );
				p.originalIndex = originalIndex;
				return p;
			}
		}

		public static Track.Point interpolateSpline(Track.Point p0, Track.Point p1, Tangent t0, Tangent t1, double l) {
			if (l <= Geometry.precision) return p0;
			if (l >= 1.0 - Geometry.precision) return p1;
			return new Track.Point(
				Geometry.interpolationSpline(p0.position, p1.position, t0.position, t1.position, l),
				Geometry.interpolationSpline(p0.pressure, p1.pressure, t0.pressure, t1.pressure, l),
				Geometry.interpolationSpline(p0.tilt, p1.tilt, t0.tilt, t1.tilt, l),
				Geometry.interpolationLinear(p0.originalIndex, p1.originalIndex, l),
				Geometry.interpolationLinear(p0.time, p1.time, l),
				Geometry.interpolationLinear(p0.length, p1.length, l) );
		}

		public override void modify(Track track, InputManager.KeyPoint keyPoint, List<Track> outTracks) {
			if (track.handler == null) {
				track.handler = new Track.Handler(this, track);
				track.handler.tracks.Add(new Track( new Modifier(track.handler) ));
			}
			
			Track subTrack = track.handler.tracks[0];
			Modifier modifier = (Modifier)subTrack.modifier;
			outTracks.Add(subTrack);
			
			if ( !track.wasChanged
			  && track.count == subTrack.count
			  && track.count == modifier.tangents.Count )
			  	return;
			
			if (!track.wasChanged && subTrack.count == track.count - 1) {
				// add temporary point
				modifier.tangents.Add(new Tangent());
				subTrack.add(track.getLast());
			} else {
				// apply permanent changes
				
				// remove points
				int start = track.count - track.pointsAdded;
				if (start < 0) start = 0;
				if (start > 1) --start;
				subTrack.truncate(start);
				if (start < modifier.tangents.Count)
					modifier.tangents.RemoveRange(start, modifier.tangents.Count - start);
				
				// add first point
				int index = start;
				if (index == 0) {
					modifier.tangents.Add(new Tangent());
					subTrack.add(track.getLast());
					++index;
				}
				
				// add points with tangents
				if (track.count > 2) {
					while(index < track.count) {
						Track.Point p0 = track[index-1];
						Track.Point p1 = track[index];
						Track.Point p2 = track[index+1];
						double dt = p2.time - p0.time;
						double k = dt > Geometry.precision ? (p1.time - p0.time)/dt : 0.0;
						Tangent tangent = new Tangent(
							(p2.position - p0.position)*k,
							(p2.pressure - p0.pressure)*k,
							(p2.tilt - p0.tilt)*k );
						modifier.tangents.Add(tangent);
						subTrack.add(p1);
						++index;
					}
				}
				
				track.resetCounters();
				
				// release previous key point
				if (modifier.holder != null) {
					modifier.holder.Dispose();
					modifier.holder = null;
				}
				
				if (track.isFinished()) {
					// finish
					modifier.tangents.Add(new Tangent());
					subTrack.add(track.getLast());
				} else {
					// save key point
					modifier.holder = keyPoint.hold();
				}
			}
		}
	}
}