# defmodule FloUI.Scrollable.ScrollBars do
#   use Scenic.Component
#   # use FloUI.Scrollable.SceneInspector, env: [:test, :dev]

#   import FloUI.Scrollable.Components, only: [scroll_bar: 3]

#   alias Scenic.Graph

#   alias FloUI.Scrollable.ScrollBar
#   alias FloUI.Scrollable.Direction

#   @moduledoc """
#   The scroll bars component can be used to add a horizontal, and a vertical scroll bar pair to the graph. This component is used internally by the `Scenic.Scrollable` component, and for most cases it is recommended to use the `Scenic.Scrollable` component instead.

#   ## Data

#   `t:Scenic.Scrollable.ScrollBars.settings/0`

#   The scroll bars require the following data for initialization:

#   - width: number
#   - height: number
#   - content_size: `t:Scenic.Scrollable.ScrollBars.v2/0`
#   - scroll_position: number
#   - direction: :horizontal | :vertical

#   With and height define the size of the frame, and thus correspond to the width of the horizontal, and the height of the vertical scroll bars.

#   ## Styles

#   `t:Scenic.Scrollable.ScrollBars.styles/0`

#   The scroll bars can be customized by using the following styles:

#   ### scroll_bar

#   `t:Scenic.Scrollable.ScrollBar.styles/0`

#   The styles to customize both scrollbars as defined in the corresponding module `Scenic.Scrollable.Scrollbar`.
#   If different styles for the horizontal and vertical scroll bars are preffered, use the horizontal_scroll_bar and vertical_scroll_bar styles instead.

#   ### horizontal_scroll_bar

#   `t:Scenic.Scrollable.ScrollBar.styles/0`

#   The styles to customize the horizontal scroll bar.

#   ### vertical_scroll_bar

#   `t:Scenic.Scrollable.ScrollBar.styles/0`

#   The styles to customize the vertical scroll bar.

#   ### scroll_drag

#   `t:Scenic.Scrollable.Drag/0`

#   Settings to specify which mouse buttons can be used in order to drag the scroll bar sliders.

#   ### scroll_bar_thickness

#   number

#   Specify the height of the horizontal, and the width of the vertical scroll bars.

#   ## Examples

#       iex> graph = Scenic.Scrollable.Components.scroll_bars(
#       ...>   Scenic.Graph.build(),
#       ...>   %{
#       ...>     width: 200,
#       ...>     height: 200,
#       ...>     content_size: {1000, 1000},
#       ...>     scroll_position: {0, 0}
#       ...>   },
#       ...>   [
#       ...>     scroll_bar: [
#       ...>       scroll_buttons: true,
#       ...>       scroll_bar_theme: Scenic.Primitive.Style.Theme.preset(:light),
#       ...>       scroll_bar_radius: 2,
#       ...>       scroll_bar_border: 2,
#       ...>       scroll_drag: %{
#       ...>         mouse_buttons: [:left, :right, :middle]
#       ...>       }
#       ...>     ],
#       ...>     scroll_drag: %{
#       ...>       mouse_buttons: [:left, :right, :middle]
#       ...>     },
#       ...>     id: :scroll_bars_component_1
#       ...>   ]
#       ...> )
#       ...> graph.primitives[1].id
#       :scroll_bars_component_1
#   """

#   @typedoc """
#   Data structure representing a vector 2, in the form of an {x, y} tuple.
#   """
#   @type v2 :: Scenic.Scrollable.v2()

#   @type content_size :: {number, number}

#   @typedoc """
#   The required settings to initialize a scroll bars component.
#   For more information see the top of this module.
#   """
#   @type settings :: %{
#           width: number,
#           height: number,
#           content_size: v2,
#           scroll_position: v2
#         }

#   @typedoc """
#   The optional styles to customize the scroll bars.
#   For more information see the top of this module.
#   """
#   @type style ::
#           {:scroll_bar, Scenic.Scrollable.ScrollBar.styles()}
#           | {:horizontal_scroll_bar, Scenic.Scrollable.ScrollBar.styles()}
#           | {:vertical_scroll_bar, Scenic.Scrollable.ScrollBar.styles()}
#           | {:scroll_drag, Scenic.Scrollable.Drag.settings()}
#           | {:scroll_bar_thickness, number}

#   @typedoc """
#   A collection of optional styles to customize the scroll bars.
#   For more information see `t:Scenic.Scrollable.ScrollBars.style/0` and the top of this module.
#   """
#   @type styles :: [style]

#   @typedoc """
#   An atom describing the state the scroll bars are in.
#   - idle: none of the scroll bars are currently being clicked or dragged.
#   - dragging: one of the scroll bars is being dragged.
#   - scrolling: one of the scroll bars is being scrolled using a scroll button.
#   """
#   @type scroll_state ::
#           :idle
#           | :dragging
#           | :scrolling

#   @typedoc """
#   The state with which the scrollable components GenServer is running.
#   """
#   @type t :: %__MODULE__{
#           id: atom,
#           graph: Graph.t(),
#           scroll_position: v2,
#           content_size: content_size,
#           scroll_state: scroll_state,
#           pid: pid,
#           horizontal_scroll_bar_pid: {:some, pid} | :none,
#           vertical_scroll_bar_pid: {:some, pid} | :none
#         }

#   defstruct id: :scroll_bars,
#             graph: Graph.build(),
#             scroll_position: {0, 0},
#             content_size: {0, 0},
#             scroll_state: :idle,
#             pid: nil,
#             horizontal_scroll_bar_pid: :none,
#             vertical_scroll_bar_pid: :none

#   @default_id :scroll_bars
#   @default_thickness 10

#   # PUBLIC API

#   @doc """
#   Find the direction the content should be scrolling in, depending on the scroll bar buttons pressed states.
#   """
#   @spec direction(t) :: v2
#   def direction(state) do
#     {x, _} =
#       state.horizontal_scroll_bar_pid
#       |> OptionEx.map(&ScrollBar.direction/1)
#       |> OptionEx.or_else({0, 0})

#     {_, y} =
#       state.vertical_scroll_bar_pid
#       |> OptionEx.map(&ScrollBar.direction/1)
#       |> OptionEx.or_else({0, 0})

#     {x, y}
#   end

#   @doc """
#   Find out if one of the scroll bars is currently being dragged.
#   """
#   @spec dragging?(t) :: boolean
#   def dragging?(%{scroll_state: :dragging}), do: true

#   def dragging?(_), do: false

#   @doc """
#   Find out if one of the scroll bars wheel is currently being scrolled.
#   """
#   @spec wheel_scrolling?(t) :: boolean
#   def wheel_scrolling?(%{wheel_state: :scrolling}), do: true

#   def wheel_scrolling?(_), do: false

#   @doc """
#   Find the latest position the scrollable content should be updated with.
#   The position corresponds to the contents translation, rather than the scroll bars drag control translation.
#   """
#   @spec new_position(t) :: {:some, v2} | :none
#   def new_position(%{scroll_position: position}), do: {:some, position}

#   # CALLBACKS

#   @impl Scenic.Scene
#   def init(scene, settings, opts) do
#     id = opts[:id] || @default_id
#     styles = Enum.into(opts || %{}, [])
#     shared_styles = Keyword.take(styles, [:scroll_bar, :scroll_drag])

#     horizontal_bar_styles =
#       (styles[:horizontal_scroll_bar] || styles[:scroll_bar])
#       |> OptionEx.return()
#       |> OptionEx.map(&Keyword.merge(&1, shared_styles))
#       |> OptionEx.map(&Keyword.put(&1, :id, :horizontal_scroll_bar))
#       |> OptionEx.map(&Keyword.put(&1, :translate, {0, settings.height}))

#     vertical_bar_styles =
#       (styles[:vertical_scroll_bar] || styles[:scroll_bar])
#       |> OptionEx.return()
#       |> OptionEx.map(&Keyword.merge(&1, shared_styles))
#       |> OptionEx.map(&Keyword.put(&1, :id, :vertical_scroll_bar))
#       |> OptionEx.map(&Keyword.put(&1, :translate, {settings.width, 0}))

#     {content_width, content_height} = settings.content_size
#     {x, y} = settings.scroll_position

#     graph = Graph.build()

#     graph =
#       horizontal_bar_styles
#       |> OptionEx.map(fn styles ->
#         graph
#         |> FloUI.Scrollable.ScrollBar.add_to_graph(
#           %{
#             width: settings.width,
#             height: styles[:scroll_bar_thickness] || @default_thickness,
#             content_size: content_width,
#             scroll_position: x,
#             direction: :horizontal
#           },
#           styles
#         )
#       end)
#       |> OptionEx.or_else(graph)

#     graph =
#       vertical_bar_styles
#       |> OptionEx.map(fn styles ->
#         graph
#         |> FloUI.Scrollable.ScrollBar.add_to_graph(
#           %{
#             width: styles[:scroll_bar_thickness] || @default_thickness,
#             height: settings.height,
#             content_size: content_height,
#             scroll_position: y,
#             direction: :vertical
#           },
#           styles
#         )
#       end)
#       |> OptionEx.or_else(graph)

#     state = %__MODULE__{
#       id: id,
#       graph: graph,
#       scroll_position: {x, y},
#       content_size: {content_width, content_height},
#       pid: self()
#     }

#     scene =
#       scene
#       |> assign(state: state)
#       |> push_graph(state.graph)

#     send_parent_event(scene, {:scroll_bars_initialized, state.id, state})

#     {:ok, scene}
#   end

#   @impl Scenic.Component
#   def validate(
#         %{
#           content_size: {content_x, content_y},
#           scroll_position: {x, y}
#         } = settings
#       )
#       when is_number(content_x) and is_number(content_y) and is_number(x) and is_number(y) do
#     {:ok, settings}
#   end

#   def validate(_), do: :invalid_input

#   @impl Scenic.Scene
#   def handle_event(
#         {:scroll_bar_initialized, :horizontal_scroll_bar, scroll_bar_state},
#         _from,
#         %{assigns: %{state: state}} = scene
#       ) do
#     state = %{state | horizontal_scroll_bar_pid: OptionEx.return(scroll_bar_state.pid)}
#     {:noreply, assign(scene, state: state)}
#   end

#   def handle_event(
#         {:scroll_bar_initialized, :vertical_scroll_bar, scroll_bar_state},
#         _from,
#         %{assigns: %{state: state}} = scene
#       ) do
#     state = %{state | vertical_scroll_bar_pid: OptionEx.return(scroll_bar_state.pid)}
#     {:noreply, assign(scene, state: state)}
#   end

#   def handle_event(
#         {:scroll_bar_button_pressed, _, scroll_bar_state},
#         _from,
#         %{assigns: %{state: state}} = scene
#       ) do
#     state = update_scroll_state(state, scroll_bar_state)
#     {:cont, {:scroll_bars_button_pressed, state.id, state}, assign(scene, state: state)}
#   end

#   def handle_event(
#         {:scroll_bar_button_released, _, scroll_bar_state},
#         _from,
#         %{assigns: %{state: state}} = scene
#       ) do
#     state = update_scroll_state(state, scroll_bar_state)

#     {:cont, {:scroll_bars_button_released, state.id, state, scroll_bar_state.wheel_state},
#      assign(scene, state: state)}
#   end

#   def handle_event(
#         {:cursor_scroll_started, _, scroll_bar_state},
#         _from,
#         %{assigns: %{state: state}} = scene
#       ) do
#     state = update_scroll_state(state, scroll_bar_state)

#     {:cont, {:cursor_scroll_started, state.id, state, scroll_bar_state.wheel_state},
#      assign(scene, state: state)}
#   end

#   def handle_event(
#         {:cursor_scroll_stopped, _, scroll_bar_state},
#         _from,
#         %{assigns: %{state: state}} = scene
#       ) do
#     state = update_scroll_state(state, scroll_bar_state)

#     {:cont, {:cursor_scroll_stopped, state.id, state, scroll_bar_state.wheel_state},
#      assign(scene, state: state)}
#   end

#   def handle_event(
#         {:scroll_bar_position_change, _, _scroll_bar_state},
#         _from,
#         %{assigns: %{state: %{scroll_state: :scrolling} = state}} = scene
#       ) do
#     {:noreply, scene}
#   end

#   def handle_event(
#         {:scroll_bar_position_change, _, %{direction: direction} = scroll_bar_state},
#         _from,
#         %{assigns: %{state: state}} = scene
#       ) do
#     {x, y} = state.scroll_position

#     state =
#       ScrollBar.new_position(scroll_bar_state)
#       |> Direction.from_vector_2(direction)
#       |> Direction.map_horizontal(&{&1, y})
#       |> Direction.map_vertical(&{x, &1})
#       |> Direction.unwrap()
#       |> (&Map.put(state, :scroll_position, &1)).()
#       |> update_scroll_state(scroll_bar_state)

#     {:cont, {:scroll_bars_position_change, state.id, state}, assign(scene, state: state)}
#   end

#   def handle_event(
#         {:scroll_bar_scroll_end, _id, scroll_bar_state},
#         _from,
#         %{assigns: %{state: state}} = scene
#       ) do
#     state = update_scroll_state(state, scroll_bar_state)

#     {:cont, {:scroll_bars_scroll_end, state.id, state}, assign(scene, state: state)}
#   end

#   def handle_event(_event, _from, scene) do
#     {:noreply, scene}
#   end

#   # no callback on the `Scenic.Scene` and no GenServer @behaviour, so impl will not work
#   @spec handle_call(request :: term(), GenServer.from(), state :: term()) ::
#           {:reply, reply :: term(), new_state :: term()}
#   def handle_call({:update_scroll_position, {x, y}}, _, %{assigns: %{state: state}} = scene) do
#     state = %{state | scroll_position: {x, y}}
#     # TODO error handling
#     state.horizontal_scroll_bar_pid
#     |> OptionEx.map(fn pid -> GenServer.call(pid, {:update_scroll_position, x}) end)

#     state.vertical_scroll_bar_pid
#     |> OptionEx.map(fn pid -> GenServer.call(pid, {:update_scroll_position, y}) end)

#     {:reply, :ok, assign(scene, state: state)}
#   end

#   def handle_call({:update_scroll_pos, {x, y}}, _, %{assigns: %{state: state}} = scene) do
#     state = %{state | scroll_position: {x, y}}
#     # TODO error handling
#     state.horizontal_scroll_bar_pid
#     |> OptionEx.map(fn pid -> GenServer.call(pid, {:update_scroll_position, x}) end)

#     state.vertical_scroll_bar_pid
#     |> OptionEx.map(fn pid -> GenServer.call(pid, {:update_scroll_position, y}) end)

#     {:reply, :ok, assign(scene, state: state)}
#   end

#   def handle_call({:update_content_size, {width, height}}, _, %{assigns: %{state: state}} = scene) do
#     state = %{state | content_size: {width, height}}

#     state.horizontal_scroll_bar_pid
#     |> OptionEx.map(fn pid -> GenServer.call(pid, {:update_content_size, width}) end)

#     state.vertical_scroll_bar_pid
#     |> OptionEx.map(fn pid -> GenServer.call(pid, {:update_content_size, height}) end)

#     {:reply, :ok, assign(scene, state: state)}
#   end

#   def handle_call(msg, _, scene) do
#     {:reply, {:error, {:unexpected_message, msg}}, scene}
#   end

#   def handle_cast({:update_cursor_scroll, scroll_pos}, %{assigns: %{state: state}} = scene) do
#     # TODO error handling
#     state.horizontal_scroll_bar_pid
#     |> OptionEx.map(fn pid -> GenServer.cast(pid, {:update_cursor_scroll, scroll_pos}) end)

#     state.vertical_scroll_bar_pid
#     |> OptionEx.map(fn pid -> GenServer.cast(pid, {:update_cursor_scroll, scroll_pos}) end)

#     {:noreply, scene}
#   end

#   def handle_cast(:unrequest_cursor_scroll, %{assigns: %{state: state}} = scene) do
#     # TODO error handling
#     state.horizontal_scroll_bar_pid
#     |> OptionEx.map(fn pid -> GenServer.cast(pid, :unrequest_cursor_scroll) end)

#     state.vertical_scroll_bar_pid
#     |> OptionEx.map(fn pid -> GenServer.cast(pid, :unrequest_cursor_scroll) end)

#     {:noreply, scene}
#   end

#   # UTILITY

#   @spec update_scroll_state(t, ScrollBar.t()) :: t
#   defp update_scroll_state(state, scroll_bar_state) do
#     %{state | scroll_state: scroll_bar_state.scroll_state}
#   end
# end