/*
	Copyright (C) 2015 Johan Mattsson

	This library is free software; you can redistribute it and/or modify 
	it under the terms of the GNU Lesser General Public License as 
	published by the Free Software Foundation; either version 3 of the 
	License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful, but 
	WITHOUT ANY WARRANTY; without even the implied warranty of 
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 
	Lesser General Public License for more details.
*/

using Math;
using Cairo;

namespace BirdFont {

/** Create Bezier curves. */
public class BezierTool : Tool {
	
	public const uint NONE = 0;
	public const uint MOVE_POINT = 1;
	public const uint MOVE_HANDLES = 2;
	public const uint MOVE_LAST_HANDLE_RIGHT = 3;
	public const uint MOVE_LAST_HANDLE_LEFT = 4;
	public const uint MOVE_FIRST_HANDLE = 5;
	public const uint MOVE_HANDLE_ON_AXIS = 6;
	
	uint state = NONE;
	
	Path current_path = new Path ();
	EditPoint current_point = new EditPoint ();

	int last_x = 0;
	int last_y = 0;

	double last_release_time = 0;
	double last_press_time = 0;
	bool button_down = false;
	
	/** Create a corner instead of a control point with reflective handles. */
	bool corner_node = false;
	
	/** Swap right and left handles if orientation changes */
	bool swap = false; 
	
	public BezierTool (string name) {
		base (name, "");

		select_action.connect ((self) => {
			state = NONE;
			MainWindow.set_cursor (NativeWindow.VISIBLE);
		});

		deselect_action.connect ((self) => {
			state = NONE;
			MainWindow.set_cursor (NativeWindow.VISIBLE);
		});
		
		press_action.connect ((self, b, x, y) => {
			press (b, x, y);
		});

		double_click_action.connect ((self, b, x, y) => {
		});

		release_action.connect ((self, b, x, y) => {
			release (b, x, y);
		});

		move_action.connect ((self, x, y) => {
			move (x, y);
		});
		
		key_press_action.connect ((self, keyval) => {
		});
		
		key_release_action.connect ((self, keyval) => {
		});
		
		draw_action.connect ((tool, cairo_context, glyph) => {
			if (PenTool.can_join (current_point)) {
				PenTool.draw_join_icon (cairo_context, last_x, last_y);
			}
		});
	}
	
	public override string get_tip () {
		string tip = t_ ("Create Bézier curves") + "\n";
		
		tip += HiddenTools.bezier_line.get_key_binding ();
		tip += " - ";
		tip += t_ ("line") + "\n";

		tip += HiddenTools.bezier_corner.get_key_binding ();
		tip += " - ";
		tip += t_ ("corner") + "\n";

		tip += HiddenTools.move_along_axis.get_key_binding ();
		tip += " - ";
		tip += t_ ("on axis") + "\n";
				
		return tip;
	}
	
	public void press (int b, int x, int y) {
		Glyph g = MainWindow.get_current_glyph ();
		double px, py;
		Path? p;
		Path path;

		if (button_down) {
			warning ("Discarding event.");
			return;
		}
				
		button_down = true;

		if (state == MOVE_HANDLES
			|| state == MOVE_LAST_HANDLE_RIGHT
			|| state == MOVE_LAST_HANDLE_LEFT) {
			return;	
		}
				
		if (b == 2) {
			if (g.is_open ()) {
				stop_drawing ();
				g.close_path ();
			} else {
				g.open_path ();
			}
			
			MainWindow.set_cursor (NativeWindow.VISIBLE);
			state = NONE;

			return;
		}

		// ignore double clicks
		if ((GLib.get_real_time () - last_press_time) / 1000000.0 < 0.2) {
			last_press_time = GLib.get_real_time ();
			return;
		}
		last_press_time = GLib.get_real_time ();
				
		g.store_undo_state ();
		
		PenTool.update_orientation ();
		
		MainWindow.set_cursor (NativeWindow.HIDDEN);
		g.open_path ();
		
		px = Glyph.path_coordinate_x (x);
		py = Glyph.path_coordinate_y (y);		

		if (GridTool.is_visible ()) {
			GridTool.tie_coordinate (ref px, ref py);
		}
		
		if (state == MOVE_HANDLE_ON_AXIS) {
			current_point = current_path.add (px, py);
			current_path.hide_end_handle = true;
			current_point.get_left_handle ().convert_to_line ();
			current_path.recalculate_linear_handles_for_point (current_point);
			set_point_type ();
			corner_node = false;
			state = MOVE_POINT;
		} else if (corner_node) {
			if (current_path.is_open ()) {
				current_point = current_path.add (px, py);
				current_path.hide_end_handle = true;
				current_point.get_left_handle ().convert_to_line ();
				current_path.recalculate_linear_handles_for_point (current_point);
				set_point_type ();
				g.clear_active_paths ();
				g.add_active_path (null, current_path);
				GlyphCanvas.redraw ();
				state = MOVE_POINT;
			} else {
				state = NONE;
			}
		} else if (state == NONE) {
			g.open_path ();
			current_path = new Path ();
			current_path.reopen ();
			current_path.hide_end_handle = true;
			current_point = current_path.add (px, py);
			current_point.get_left_handle ().convert_to_line ();
			current_path.recalculate_linear_handles_for_point (current_point);
			g.add_path (current_path);
			
			set_point_type ();
			
			if (StrokeTool.add_stroke) {
				current_path.stroke = StrokeTool.stroke_width;
				current_path.line_cap = StrokeTool.line_cap;
			}
			
			BirdFont.get_current_font ().touch ();
			
			GlyphCanvas.redraw ();
			state = MOVE_POINT;
		} else if (state == MOVE_POINT) {
			if (PenTool.can_join (current_point)) {
				EditPoint first = current_path.get_first_point ();
				
				p = PenTool.join_paths (current_point);
				return_if_fail (p != null);
				path = (!) p;
				swap = path.get_first_point () != first;
				
				if (current_path.points.size == 1) {
					return_if_fail (path.is_open ());
					current_path = path;
					current_point = path.get_last_point ();
					state = MOVE_POINT;
				} else {
					g.open_path ();
					current_path = path;
					current_point = !swap ? path.get_first_point () : path.get_last_point ();
					state = !swap ? MOVE_LAST_HANDLE_RIGHT : MOVE_LAST_HANDLE_LEFT;
				}
			} else {
				state = MOVE_HANDLES;
			}
		}
	}

	void set_point_type () {
		PointType pt;
		
		pt = DrawingTools.get_selected_point_type ();
		
		current_point.type = pt; 
		current_point.get_left_handle ().type = pt;
		current_point.get_right_handle ().type = pt;
		current_point.get_left_handle ().convert_to_line ();
		
		current_point.get_right_handle ().convert_to_line ();	
	}
	
	public void release (int b, int x, int y) {
		double px, py;
		Glyph g;
		
		if (!button_down) {
			warning ("Discarding event.");
			return;
		}
		
		button_down = false;
		
		if (state == NONE || state == MOVE_POINT) {
			return;
		}
		
		convert_zero_length_handles_to_lines ();	
		corner_node = false;
		
		// ignore double clicks
		if ((GLib.get_real_time () - last_release_time) / 1000000.0 < 0.2) {
			last_release_time = GLib.get_real_time ();
			return;
		}
		last_release_time = GLib.get_real_time ();
			
		px = Glyph.path_coordinate_x (x);
		py = Glyph.path_coordinate_y (y);

		if (GridTool.is_visible ()) {
			GridTool.tie_coordinate (ref px, ref py);
		}
		
		g = MainWindow.get_current_glyph ();
		
		if (state == MOVE_HANDLES) {
			current_point = current_path.add (px, py);
			current_path.hide_end_handle = true;
			current_point.get_left_handle ().convert_to_line ();
			current_path.recalculate_linear_handles_for_point (current_point);
			set_point_type ();
			g.clear_active_paths ();
			g.add_active_path (null, current_path);
			
			GlyphCanvas.redraw ();
			state = MOVE_POINT;
		} else if (state == MOVE_LAST_HANDLE_LEFT || state == MOVE_LAST_HANDLE_RIGHT) {
			current_path.update_region_boundaries ();
			g.close_path ();
			MainWindow.set_cursor (NativeWindow.VISIBLE);
			
			if (Path.is_counter (g.get_visible_path_list (), current_path)) {
				current_path.force_direction (Direction.COUNTER_CLOCKWISE);
			} else {
				current_path.force_direction (Direction.CLOCKWISE);
			}
						
			current_path.reset_stroke ();
			
			state = NONE;
		}
		
		convert_zero_length_handles_to_lines ();
	}
	
	void convert_zero_length_handles_to_lines () {
		EditPoint first, last;
		
		first = current_path.get_first_point ();

		first.tie_handles = false;
		first.reflective_point = false;

		if (first.get_left_handle ().length == 0) {
			first.get_left_handle ().length = 0.001;
		}
				
		if (first.get_right_handle ().length == 0) {
			first.get_right_handle ().convert_to_line ();
		}
		
		last = current_path.get_last_point ();

		last.tie_handles = false;
		last.reflective_point = false;

		if (last.get_left_handle ().length == 0) {
			last.get_left_handle ().length = 0.001;
		}
		
		if (last.get_right_handle ().length == 0) {
			last.get_right_handle ().convert_to_line ();
		}
	}
			
	public void move (int x, int y) {
		double px, py;
		
		last_x = x;
		last_y = y;
		
		px = Glyph.path_coordinate_x (x);
		py = Glyph.path_coordinate_y (y);	

		if (GridTool.is_visible ()) {
			GridTool.tie_coordinate (ref px, ref py);
		}
				
		if (state == MOVE_POINT) {
			current_point.x = px;
			current_point.y = py;
			current_path.hide_end_handle = true;
			current_path.recalculate_linear_handles_for_point (current_point);
			current_path.reset_stroke ();

			if (current_point.type == PointType.QUADRATIC) {
				current_path.create_list ();
				current_point.get_prev ().get_right_handle ().process_connected_handle ();
			}
				
			GlyphCanvas.redraw ();
		} else if (state == MOVE_HANDLES 
			|| state == MOVE_LAST_HANDLE_LEFT
			|| state == MOVE_LAST_HANDLE_RIGHT) {
				
			current_path.hide_end_handle = false;
			
			if (!corner_node) {
				current_point.set_reflective_handles (true);
				current_point.convert_to_curve ();
			}
			
			if (state == MOVE_LAST_HANDLE_LEFT) {
				current_point.get_left_handle ().move_to_coordinate (px, py);
			} else {
				current_point.get_right_handle ().move_to_coordinate (px, py);
			}
			
			current_path.reset_stroke ();
			GlyphCanvas.redraw ();
		} else if (state == MOVE_HANDLE_ON_AXIS) {
			EditPointHandle h = current_point.get_right_handle ();

			current_path.hide_end_handle = false;
			current_point.set_reflective_handles (true);
			current_point.convert_to_curve ();
			
			double tied_x = 0;
			double tied_y = 0;
			 
			PointTool.tie_angle (h.parent.x, h.parent.y,
					px, py, out tied_x, out tied_y);
					
			h.x = tied_x;
			h.y = tied_y;
			
			current_path.reset_stroke ();
			GlyphCanvas.redraw ();
		}
		
		if (current_path.points.size > 0) {
			current_path.get_first_point ().set_reflective_handles (false);
			current_path.get_last_point ().set_reflective_handles (false);
		}
		
		convert_zero_length_handles_to_lines ();
	}
	
	public void switch_to_line_mode () {
		int s = current_path.points.size;
		EditPoint p;
		
		if (s > 2) {
			p = current_path.points.get (s - 2);
			p.set_tie_handle (false);
			p.set_reflective_handles (false);
			p.get_right_handle ().convert_to_line ();
			current_point.get_left_handle ().convert_to_line ();
			current_path.recalculate_linear_handles_for_point (p);
			current_path.recalculate_linear_handles_for_point (current_point);
			current_path.reset_stroke ();
			GlyphCanvas.redraw ();
			
			state = MOVE_POINT;
		}
	}
	
	public void stop_drawing () {
		if (state == MOVE_POINT
			&& current_path.points.size > 0
			&& current_path.is_open ()) {
				
			current_path.delete_last_point ();
			current_path.reset_stroke ();
			current_path.create_full_stroke (); // cache better stroke
		}
		
		state = NONE;
	}

	public override void before_undo () {
	}

	public override void after_undo () {
		if (state != NONE) {
			MainWindow.set_cursor (NativeWindow.VISIBLE);
			state = NONE;
		}
	}
	
	public void create_corner () {
		Glyph g = MainWindow.get_current_glyph ();
		
		corner_node = true;
		g.open_path ();
		
		if (current_path.is_open ()) {
			current_path.delete_last_point ();
			current_path.reset_stroke ();
			current_point = current_path.get_last_point ();
			current_point.set_tie_handle (false);
			current_point.set_reflective_handles (false);
			state = MOVE_HANDLES;
		} else {
			state = swap ? MOVE_LAST_HANDLE_RIGHT : MOVE_LAST_HANDLE_LEFT;
		}
		
		current_point.set_reflective_handles (false);
		current_point.get_right_handle ().convert_to_curve ();
	}
	
	public void move_handle_on_axis () {
		state = MOVE_HANDLE_ON_AXIS;
	}
}

}
