using System;

namespace EllipseTruncate {
	public struct Matrix {
		public double m00, m01, m02,
		              m10, m11, m12,
		              m20, m21, m22;
		
		public Matrix(Point p0, Point p1, Point p2 = new Point()) {
			m00 = p0.x; m01 = p0.y; m02 = 0.0;
			m10 = p1.x; m11 = p1.y; m12 = 0.0;
			m20 = p2.x; m21 = p2.y; m22 = 1.0;
		}

		public Matrix(Cairo.Matrix m) {
			m00 = m.Xx; m01 = m.Yx; m02 = 0.0;
			m10 = m.Xy; m11 = m.Yy; m12 = 0.0;
			m20 = m.X0; m21 = m.Y0; m22 = 1.0;
		}

		public Point row0()
			{ return new Point(m00, m01); }
		public Point row1()
			{ return new Point(m10, m11); }
		public Point row2()
			{ return new Point(m20, m21); }

		public Point row(int index) {
			switch(index) {
			case 0: return row0();
			case 1: return row1();
			case 2: return row2();
			}
			return new Point();
		}

		public static Matrix zero()
			{ return new Matrix(); }

		public static Matrix identity() {
			Matrix m = new Matrix();
			m.m00 = m.m11 = m.m22 = 1.0;
			return m;
		}

		public static Matrix rotation(double angle) {
			double s = Math.Sin(angle);
			double c = Math.Cos(angle);
			Matrix m = identity();
			m.m00 = c; m.m01 = s;
			m.m10 =-s; m.m11 = c;
			return m;
		}

		public static Matrix translation(double x, double y) {
			Matrix m = identity();
			m.m20 = x; m.m21 = y;
			return m;
		}

		public static Matrix scaling(double x, double y) {
			Matrix m = identity();
			m.m00 = x; m.m11 = y;
			return m;
		}
		
		public static Matrix translation(Point t)
			{ return translation(t.x, t.y); }
		public static Matrix scaling(Point s)
			{ return scaling(s.x, s.y); }
		public static Matrix scaling(double s)
			{ return scaling(s, s); }
		
		public Matrix rotate(double angle)
			{ return this*rotation(angle); }
		public Matrix translate(double x, double y)
			{ return this*translation(x, y); }
		public Matrix translate(Point t)
			{ return this*translation(t); }
		public Matrix scale(double x, double y)
			{ return this*scaling(x, y); }
		public Matrix scale(Point s)
			{ return this*scaling(s); }
		public Matrix scale(double s)
			{ return this*scaling(s, s); }
			
		public Point transform(Point p) {
			return new Point( m00*p.x + m10*p.y + m20,
			                  m01*p.x + m11*p.y + m21 );
		}

		public Point turn(Point p) {
			return new Point( m00*p.x + m10*p.y,
			                  m01*p.x + m11*p.y );
		}

		public static Point operator* (Matrix m, Point p)
			{ return m.transform(p); }
		
		public static Matrix operator* (Matrix a, Matrix b) {
			Matrix m = new Matrix();
			
			m.m00 = a.m00*b.m00 + a.m10*b.m01 + a.m20*b.m02;
			m.m01 = a.m01*b.m00 + a.m11*b.m01 + a.m21*b.m02;
			m.m02 = a.m02*b.m00 + a.m12*b.m01 + a.m22*b.m02;
		
			m.m10 = a.m00*b.m10 + a.m10*b.m11 + a.m20*b.m12;
			m.m11 = a.m01*b.m10 + a.m11*b.m11 + a.m21*b.m12;
			m.m12 = a.m02*b.m10 + a.m12*b.m11 + a.m22*b.m12;

			m.m20 = a.m00*b.m20 + a.m10*b.m21 + a.m20*b.m22;
			m.m21 = a.m01*b.m20 + a.m11*b.m21 + a.m21*b.m22;
			m.m22 = a.m02*b.m20 + a.m12*b.m21 + a.m22*b.m22;
		
			return m;
		}
		
		public bool isEqual(Matrix other) {
			return Math.Abs(m00 - other.m00) <= Geometry.precision
			    && Math.Abs(m01 - other.m01) <= Geometry.precision
			    && Math.Abs(m02 - other.m02) <= Geometry.precision
			    && Math.Abs(m10 - other.m10) <= Geometry.precision
			    && Math.Abs(m11 - other.m11) <= Geometry.precision
			    && Math.Abs(m12 - other.m12) <= Geometry.precision
			    && Math.Abs(m20 - other.m20) <= Geometry.precision
			    && Math.Abs(m21 - other.m21) <= Geometry.precision
			    && Math.Abs(m22 - other.m22) <= Geometry.precision;
		}
		
		static double det2x2(double m00, double m01, double m10, double m11)
			{ return m00*m11 - m10*m01; }
		
		public double det() {
			return m00*m11*m22 - m00*m12*m21
			     + m01*m12*m20 - m01*m10*m22
			     + m02*m10*m21 - m02*m11*m20;
		}
		
		public Matrix invert() {
			double d = det();
			Matrix m = new Matrix();
			if (Math.Abs(d) > Geometry.precision) {
				d = 1.0/d;
				double e = -d;
				m.m00 = det2x2(m11, m12, m21, m22)*d;
				m.m10 = det2x2(m10, m12, m20, m22)*e;
				m.m20 = det2x2(m10, m11, m20, m21)*d;

				m.m01 = det2x2(m01, m02, m21, m22)*e;
				m.m11 = det2x2(m00, m02, m20, m22)*d;
				m.m21 = det2x2(m00, m01, m20, m21)*e;

				m.m02 = det2x2(m01, m02, m11, m12)*d;
				m.m12 = det2x2(m00, m02, m10, m12)*e;
				m.m22 = det2x2(m00, m01, m10, m11)*d;
			}
			return m;
		}

		public Cairo.Matrix toCairo()
			{ return new Cairo.Matrix(m00, m01, m10, m11, m20, m21); }
	}
}