using System;

using System.Collections.Generic;

namespace Assistance {

	public class DynamicSurface: IDisposable {

		private readonly double incrementScale;

		private int offsetX;

		private int offsetY;

		private Cairo.ImageSurface surface;

		private Cairo.Context privateContext;

		public DynamicSurface(double incrementScale = 1.2)

			{ this.incrementScale = incrementScale; }

		public bool isEmpty

			{ get { return surface == null; } }

		public int left

			{ get { return isEmpty ? 0 : offsetX; } }

		public int top

			{ get { return isEmpty ? 0 : offsetY; } }

		public int width

			{ get { return isEmpty ? 0 : surface.Width; } }

		public int height

			{ get { return isEmpty ? 0 : surface.Height; } }

		public Cairo.Context context

			{ get { return privateContext; } }

		public Rectangle getBounds() {

			return isEmpty ? new Rectangle()

			     : new Rectangle((double)offsetX, (double)offsetY, (double)(offsetX + surface.Width), (double)(offsetY + surface.Height));

		}

		public void flush()

			{ if (surface != null) surface.Flush(); }

		public void draw(Cairo.Context context, double alpha = 1.0) {

			if (isEmpty) return;

			flush();

			context.Save();

			context.Translate(offsetX, offsetY);

			context.SetSource(surface);

			if (alpha >= 1.0 - Geometry.precision)

				context.Paint(); else context.PaintWithAlpha(alpha);

			context.Restore();

		}

		public void clear() {

			if (isEmpty) return;

			privateContext.Dispose();

			privateContext = null;

			surface.Dispose();

			surface = null;

        }

		public bool expand(Rectangle rect, bool noScale = false) {

			rect = new Rectangle(rect.p0).expand(rect.p1);

			int rl = (int)Math.Floor(rect.x0 + Geometry.precision);

			int rt = (int)Math.Floor(rect.y0 + Geometry.precision);

			int rr = Math.Max(rl, (int)Math.Ceiling(rect.x1 - Geometry.precision)) + 1;

			int rb = Math.Max(rt, (int)Math.Ceiling(rect.y1 - Geometry.precision)) + 1;

		    int l, t, r, b;

		    if (surface == null) {

				l = rl; t = rt; r = rr; b = rb;

		    } else {

				l = offsetX;

				t = offsetY;

				r = l + surface.Width;

				b = t + surface.Height;

			}

		    int incX = noScale ? 0 : Math.Max(0, (int)Math.Ceiling( (incrementScale - 1.0)*(Math.Max(r, rr) - Math.Min(l, rl)) ));

		    int incY = noScale ? 0 : Math.Max(0, (int)Math.Ceiling( (incrementScale - 1.0)*(Math.Max(b, rb) - Math.Min(t, rt)) ));

		    if (rl < l) l = rl - incX;

		    if (rt < t) t = rt - incY;

		    if (rr > r) r = rr + incX;

		    if (rb > b) b = rb + incY;

		    int w = r - l;

		    int h = b - t;

		    if (surface != null && l == offsetX && t == offsetY && w == surface.Width && h == surface.Height)

		    	return false;

		    if (w <= 0 || h <= 0)

		    	return false;

			Cairo.ImageSurface newSurface = new Cairo.ImageSurface(Cairo.Format.ARGB32, w, h);

			Cairo.Context newContext = new Cairo.Context(newSurface);

	    	if (!isEmpty) {

	    		flush();

	    		newContext.Save();

		    	newContext.Translate(offsetX - l, offsetY - t);

		    	newContext.SetSource(surface);

		    	newContext.Paint();

		    	newContext.Restore();

				clear();

			}

			offsetX = l;

			offsetY = t;

			surface = newSurface;

			privateContext = newContext;

			privateContext.Antialias = Cairo.Antialias.Gray;

			privateContext.Translate(-offsetX, -offsetY);

			return true;

		}

		public void Dispose()

			{ Dispose(true); GC.SuppressFinalize(this); }

		protected virtual void Dispose(bool disposing)

			{  clear(); }

		~DynamicSurface()

			{ Dispose(false); }

	}

}