namespace Circuit

open System
open UnityEngine
open UnityEditor

module private GUI =

  open Utils
  open EditorUtils

  let mutable private mouseUp : (unit -> unit) option array = [| None; None; None |]
  let mutable private mouseMove : (Vector2 -> unit) option array = [| None; None; None |]
  let mutable private mouseAllow : bool = true

  let private MouseHandlers b up down =
    match mouseUp.[b] with
    | None -> ()
    | Some _ -> logWarn (sprintf "Mouse button %i got it's up callback overriden" b)

    match mouseMove.[b] with
    | None -> ()
    | Some _ -> logWarn (sprintf "Mouse button %i got it's move callback overriden" b)

    mouseUp.[b] <- up
    mouseMove.[b] <- down

  let MouseState allow (f:unit -> unit) =
    let mouseAllow' = mouseAllow
    //let mouseMove' = mouseMove
    //let mouseUp' = mouseUp

    mouseAllow <- allow
    //mouseMove <- move
    //mouseUp <- up

    try
      f()

    finally
      mouseAllow <- mouseAllow'
      //mouseMove <- mouseMove'
      //mouseUp <- mouseUp'

  let MouseDown b down =
    if mouseAllow then
      let ev = Event.current

      if ev.``type`` = EventType.MouseDown && ev.button = b then
        down()
        ev.Use()
        MouseHandlers b None None

  let MouseUp b up =
    if mouseAllow then
      let ev = Event.current

      if ev.``type`` = EventType.MouseUp && ev.button = b then
        up()
        ev.Use()
        MouseHandlers b None None

  let MouseScroll scroll =
    if mouseAllow then
      let ev = Event.current

      if ev.``type`` = EventType.ScrollWheel then
        scroll ev.delta
        ev.Use()

  let MouseDrag b move =
    if mouseAllow then
      let ev = Event.current

      if ev.``type`` = EventType.MouseDrag && ev.button = b then
        move ev.delta
        ev.Use()

  let MouseDownUp b down up =
    if mouseAllow then
      let ev = Event.current

      if ev.``type`` = EventType.MouseDown && ev.button = b then
        down()
        ev.Use()
        MouseHandlers b (Some up) None

  let MouseDownUpMove b down up move =
    if mouseAllow then
      let ev = Event.current

      if ev.``type`` = EventType.MouseDown && ev.button = b then
        down()
        ev.Use()
        MouseHandlers b (Some up) (Some move)

  let TextureButton rect style color =
    GUI.color <- color

    let result =
      if mouseAllow then
        GUI.Button(rect, "", style)

      else
        GUI.DrawTexture(rect, style.normal.background)
        false

    GUI.color <- Color.white
    result

  let KeyUp (kc:KeyCode) f =
    let ev = Event.current

    if ev.``type`` = EventType.KeyUp && ev.keyCode = kc then
      f()

  let KeyDown (kc:KeyCode) f =
    let ev = Event.current

    if ev.``type`` = EventType.KeyDown && ev.keyCode = kc then
      f()

  let MouseHandleEvents () =
    if mouseAllow then
      let ev = Event.current
      let b = ev.button

      match ev.``type`` with
      | EventType.MouseDrag ->
        match mouseMove.[b] with
        | None -> ()
        | Some f ->
          f ev.delta
          ev.Use()

      | EventType.MouseUp ->
        match mouseUp.[b] with
        | None -> ()
        | Some f ->
          f()
          ev.Use()

        mouseUp.[b] <- None
        mouseMove.[b] <- None

      | _ ->
        ()

  let ZoomBegin (w, h, z) =
    GUI.EndGroup()
    GUI.BeginGroup(new Rect(0.0f, 21.0f / z, w / z, h / z))
    GUI.matrix <- Matrix4x4.Scale(new Vector3(z, z, 1.0f)) * GUI.matrix

  let ZoomEnd (w, h) =
    GUI.matrix <- Matrix4x4.identity
    GUI.EndGroup()
    GUI.BeginGroup(new Rect(0.0f, 21.0f, w, h))

  let rec DrawLine (from:float2) (to':float2) (tangent:float32) (width:float32) (clr:Color) =
    if from.x > to'.x then
      DrawLine to' from tangent width clr

    else
      let tangent = min tangent ((from.x-to'.x) * 0.45f)
      let fromPos = from
      let fromTan = fromPos + new float2(-tangent, 0.0f)
      let toPos = to'
      let toTan = toPos + new float2(tangent, 0.0f)

      Handles.DrawBezier(
        new float3(fromPos.x, fromPos.y, 0.0f),
        new float3(toPos.x, toPos.y, 0.0f),
        new float3(fromTan.x, fromTan.y, 0.0f),
        new float3(toTan.x, toTan.y, 0.0f),
        clr, null, width
      )

  let Group (r:Rect, f) =
    GUI.BeginGroup(r)
    f (int r.width) (int r.height)
    GUI.EndGroup()

  let Toolbox (x, y, w, h, c, s, f) =
    // main group
    GUI.BeginGroup(rect x y w h)

    // background
    GUI.color <- c
    GUI.Box(rect 0 0 w h, "", s)
    GUI.color <- Color.white

    // content
    f w h

    // end main group
    GUI.EndGroup()

  let Grid (r:Rect, s:int, sizeh:int, m:int, items:'a list, pos:Vector2, draw) =
    GUI.BeginGroup(r)

    let s = f s
    let m = f m
    let w = r.width
    let h = r.height
    let l = f items.Length

    // how many nodes we can have in one row with fraction
    let n = max 1.0f ((w - m) / (s + m))

    // how many whole nodes we can have in one row
    let y = floor n

    // how much extra space we got left over
    let x = n - y

    // how much extra space we need to add
    let xs = ((w - m) * (x / n)) / y

    // final size of each element
    let s = s + xs

    // calculate scroll height
    let sh = (ceil (l / y)) * ((f sizeh) + m)

    // scroll position rect
    let sr = rect 0 0 (int (w + 20.0f)) (int h)

    // scroll view rect
    let sv = rect 0 0 (int w) (int sh)

    // draw our scrollview
    let pos = GUI.BeginScrollView(sr, pos, sv)

    let mutable r = 0
    let mutable c = 0

    for i in items do

      if c = int n then
        c <- 0
        r <- r + 1

      let x_pos = m + ((f c) * (s + m)) |> int
      let y_pos = (f r) * ((f sizeh) + m) |> int

      let size = s |> int

      // item group
      GUI.BeginGroup(rect x_pos y_pos size sizeh)

      // draw item
      draw i size sizeh

      // end item group
      GUI.EndGroup()

      // step column
      c <- c + 1

    GUI.EndScrollView()
    GUI.EndGroup()

    pos