module State = Script_state.State
module Selection = Script_state.Selection

type t = { position : float * float
         ; timer  : Elements.Timer.t }

let process { position; timer } state =
  match state.State.mode with

  | Out ->
    let x, y = position in
    Elements.Timer.start timer 0.3;

    let width = state.width
    and angle = state.angle in

    let stamp = 0. in
    let point =
      match Selection.get_from_paths position state.paths with
      | _, None ->
        (* Start a new path with the point clicked *)
        Path.Point.create ~x ~y ~angle ~width ~stamp
      | _, Some (p, _, _, _) ->
        (* If the point is close to an existing path, we use the closest
           point in the path instead *)
        let x, y = Gg.V2.to_tuple p in
        Path.Point.create ~x ~y ~angle ~width ~stamp
    in

    let current = Path.Path_Builder.add_point
        point
        state.current in
    { state with
      current
    ; mode = Edit
    ; mouse_down_position = Gg.V2.of_tuple (x, y)}

  | (Selection (Path id))
  | (Selection (Point (id, _))) ->

    let get_any () =
      begin match Selection.get_from_paths position state.paths with
        | _, None ->
          { state with
            mode = Out
          ; mouse_down_position = Gg.V2.of_tuple position }
        | dist, Some selection ->
          let _, outline, _, _ = selection in
          if outline.Outline.id != id then (
            let mouse_down_position = Gg.V2.of_tuple position in
            State.select_segment position selection { state with mouse_down_position } dist
          ) else
            (* On the same segment, check for a point *)
            let selection = Selection.select_point outline (Gg.V2.of_tuple position) in
            match selection with
            | Path _ ->
              { state with
                mode = Selection selection
              ; mouse_down_position = Gg.V2.of_tuple position }
            | Point (_, pt) ->
              (* In order to handle the point move, start the timer *)
              Elements.Timer.start timer 0.3;
              { state with
                mode = Selection selection
              ; angle = Path.Point.get_angle pt
              ; width = Path.Point.get_width pt
              ; mouse_down_position = Gg.V2.of_tuple position }
      end
    in
    (* First, check for a point in the selected path. If any of them in
       found, check anything to select in all the elements *)
    begin match Outline.find state.paths id with
      | None -> get_any ()
      | Some outline ->
        begin match Selection.select_point outline (Gg.V2.of_tuple position) with
          | Path _ -> get_any ()
          | other ->
            Elements.Timer.start timer 0.3;
            {state with
             mode = Selection other
           ; mouse_down_position = Gg.V2.of_tuple position }
        end
    end
  | Edit -> state