using System;
using System.Collections.Generic;

namespace EllipseTruncate {
	public class Ellipse {
		public Matrix matrix;
		public Matrix matrixInv;
	
		public Ellipse(Point p0, Point p1, Point p2) {
			Point d = p1 - p0;
			double r1 = d.len();
			double r2 = Math.Abs( (d.rotate90()*(p2 - p0))/r1 );
			matrix = Matrix.identity()
					.translate(p0)
			        .rotate(d.atan())
			        .scale(r1, r2);
			matrixInv = matrix.invert();
		}

		public Ellipse(Matrix matrix) {
			this.matrix = matrix;
			matrixInv = matrix.invert();
		}
				
		public Ellipse(Matrix matrix, Matrix matrixInv) {
			this.matrix = matrix;
			this.matrixInv = matrixInv;
		}

		public Ellipse(Ellipse ellipse):
			this(ellipse.matrix, ellipse.matrixInv) { }
		
		public void drawFull(Cairo.Context context, bool grid = false) {
    		int segments = 100;
    		double da = 2.0*Math.PI/segments;
    		double s = Math.Sin(da);
    		double c = Math.Cos(da);
    		Point r = new Point(1.0, 0.0);

			if (!grid) {
				context.Save();
				context.Matrix = (new Matrix(context.Matrix)*matrix).toCairo();
				context.SetSourceRGBA(1.0, 0.0, 0.0, 0.1);
				context.Arc(0.0, 0.0, 1.0, 0.0, 2.0*Math.PI);
				context.ClosePath();
				context.Fill();
				context.Restore();
			}

    		context.Save();
			context.LineWidth = 0.5;
			context.SetSourceRGBA(1.0, 0.0, 0.0, 0.5);
			if (grid) context.SetSourceRGBA(0.0, 0.0, 0.0, 0.2);
			Point p = matrix*r;
			for(int i = 0; i < segments; ++i) {
				r = new Point(r.x*c - r.y*s, r.y*c + r.x*s);
  				p = matrix*r;
				context.LineTo(p.x, p.y);
			}
			context.ClosePath();
			context.Stroke();
    		context.Restore();
		}
		
		private static void swap(ref double a, ref double b)
			{ double c = a; a = b; b = c; }
		private static void swap(ref int a, ref int b)
			{ int c = a; a = b; b = c; }

		private bool cutRange(AngleRange range, uint da, double h) {
			if (h <= Geometry.precision - 1.0)
				return true;
			if (h >= 1.0 - Geometry.precision)
				return false;
			uint a = AngleRange.toUInt(Math.Asin(h));
			range.subtract(new AngleRange.Entry(
				da - a, (da + a)^AngleRange.half ));
			return !range.isEmpty();
		}
		
		public void putSegment(Cairo.Context context, double da, double s, double c, double a0, double a1) {
			int cnt = (int)Math.Floor((a1 - a0)/da);
			Point r = new Point(1.0, 0.0).rotate(a0);
			Point p = matrix*r;
			context.MoveTo(p.x, p.y);
			for(int j = 0; j < cnt; ++j) {
				r = new Point(r.x*c - r.y*s, r.y*c + r.x*s);
  				p = matrix*r;
				context.LineTo(p.x, p.y);
			}
			r = new Point(1.0, 0.0).rotate(a1);
			p = matrix*r;
			context.LineTo(p.x, p.y);
		}

		public void drawTruncated(Cairo.Context context, Point b0, Point b1, Point b2, bool grid = false) {
			Point dx = matrixInv.turn(b1 - b0);
			Point dy = matrixInv.turn(b2 - b0);
			Point nx = dx.rotate90().normalize();
			Point ny = dy.rotate90().normalize();
			Point o = matrixInv*b0;
			
			uint ax = AngleRange.toUInt(dx.atan());
			uint ay = AngleRange.toUInt(dy.atan());

			double sign = nx*dy;
			if (Math.Abs(sign) <= Geometry.precision) return;
			if (sign < 0.0) {
				nx *= -1.0; ny *= -1.0;
				ax ^= AngleRange.half; ay ^= AngleRange.half;
			}

			if (!grid) {
				// draw bounds
				context.Save();
				context.Matrix = (new Matrix(context.Matrix)*matrix).toCairo();
				context.SetSourceRGBA(1.0, 0.0, 0.0, 0.1);
				context.MoveTo(o.x, o.y);
				context.RelLineTo(dx.x, dx.y);
				context.RelLineTo(dy.x, dy.y);
				context.RelLineTo(-dx.x, -dx.y);
				context.ClosePath();
				context.Fill();
				context.Restore();
			}
			
			// build ranges
			AngleRange range = new AngleRange(true);
			if ( !cutRange(range, ax, o*nx) ) return;
			if ( !cutRange(range, ax^AngleRange.half, -((o+dx+dy)*nx)) ) return;
			if ( !cutRange(range, ay, (o+dx)*ny) ) return;
			if ( !cutRange(range, ay^AngleRange.half, -((o+dy)*ny)) ) return;
			
			// draw
    		int segments = 100;
    		double da = 2.0*Math.PI/segments;
    		double s = Math.Sin(da);
    		double c = Math.Cos(da);

    		context.Save();
			context.LineWidth = 2.0;
			context.SetSourceRGBA(0.0, 0.0, 1.0, 1.0);
			if (grid) context.LineWidth = 1.0;
			if (grid) context.SetSourceRGBA(0.0, 0.0, 0.0, 1.0);
			if (range.isFull()) {
				putSegment(context, da, s, c, 0.0, AngleRange.period);
			} else {
				bool f = range.flip;
				uint prev = range.angles[range.angles.Count - 1];
				foreach(uint a in range.angles) {
					if (f) {
						double a0 = AngleRange.toDouble(prev);
						double a1 = AngleRange.toDouble(a);
						if (a < prev) a1 += AngleRange.period;
						putSegment(context, da, s, c, a0, a1);
					}
					prev = a; f = !f;
				}
			}
			context.Stroke();
			context.Restore();
		}
	}
}