scenic_clock

#
#  Created by Boyd Multerer on August 8, 2018.
#  Copyright © 2018 Kry10 Industries. All rights reserved.
#

defmodule Scenic.Clock.Analog do
  @moduledoc """
  A component that runs an analog clock.

  See the [Components](Scenic.Clock.Components.html#analog_clock/2) module for useage

  """
  use Scenic.Component, has_children: false

  alias Scenic.Graph
  alias Scenic.Primitive.Style.Theme

  # alias Scenic.Component.Input.Dropdown
  import Scenic.Primitives,
    only: [
      {:circle, 3},
      {:line, 3},
      {:update_opts, 2}
    ]

  # import IEx

  # analog clock setup
  @default_radius 10
  @two_pi 2 * :math.pi()
  @back_size_ratio 0.1
  @hour_size_ratio -0.6
  @minute_size_ratio -0.9
  @second_size_ratio -0.9
  @tick_ratio 0.08

  @min_radius_for_default_ticks 30

  @default_timezone "GMT"

  @default_theme :dark

  # --------------------------------------------------------
  @doc false
  def verify(nil), do: {:ok, nil}
  def verify(_), do: :invalid_data

  # --------------------------------------------------------
  @doc false
  def init(_, opts) do
    styles = opts[:styles]

    # theme is passed in as an inherited style
    theme =
      (styles[:theme] || Theme.preset(@default_theme))
      |> Theme.normalize()

    # confirm the timezone
    timezone =
      case Enum.member?(Timex.timezones(), styles[:timezone]) do
        true -> styles[:timezone]
        false -> Timex.Timezone.local() || @default_timezone
      end

    # get and calc the sizes 
    radius = styles[:radius] || @default_radius
    back_size = radius * @back_size_ratio
    hour_size = radius * @hour_size_ratio
    minute_size = radius * @minute_size_ratio
    second_size = radius * @second_size_ratio

    thick =
      cond do
        radius > 40 -> 2
        true -> 1.2
      end

    hour_color = Map.get(theme, :hours, theme.border)
    minute_color = Map.get(theme, :minutes, theme.border)

    # set up the main part of the clock
    graph =
      Graph.build()
      |> circle(radius, fill: theme.background, stroke: {thick, theme.border})
      |> line({{0, back_size}, {0, hour_size}},
        pin: {0, 0},
        stroke: {thick, hour_color},
        id: :hour_hand
      )
      |> line({{0, back_size}, {0, minute_size}},
        pin: {0, 0},
        stroke: {thick, minute_color},
        id: :minute_hand
      )

    # add the optional second hand if requested
    graph =
      case !!styles[:seconds] do
        true ->
          second_color = Map.get(theme, :second, theme.border)

          line(
            graph,
            {{0, back_size}, {0, second_size}},
            pin: {0, 0},
            stroke: {thick, second_color},
            id: :second_hand
          )

        false ->
          graph
      end

    # add the tick marks if requested
    graph =
      case styles[:ticks] do
        nil -> radius >= @min_radius_for_default_ticks
        _ -> !!styles[:ticks]
      end
      |> case do
        true ->
          angle = @two_pi / 12
          tick_size = @tick_ratio * radius

          Enum.reduce(1..12, graph, fn n, g ->
            line(
              g,
              {{0, radius - tick_size}, {0, radius}},
              stroke: {thick, theme.border},
              pin: {0, 0},
              rotate: n * angle
            )
          end)

        false ->
          graph
      end

    state =
      %{
        graph: graph,
        timezone: timezone,
        timer: nil,
        last: nil,
        seconds: !!styles[:seconds]
      }
      # start up the graph
      |> update_time()

    # send a message to self to start the clock a fraction of a second
    # into the future to hopefully line it up closer to when the seconds
    # actually are. Note that I want it to arrive just slightly after
    # the one second mark, which is way better than just slighty before.
    # avoid trunc errors and such that way even if it means the second
    # timer is one millisecond behind the actual time.
    {microseconds, _} = Time.utc_now().microsecond
    Process.send_after(self(), :start_clock, 1001 - trunc(microseconds / 1000))

    {:ok, state}
  end

  # --------------------------------------------------------
  # should be shortly after the actual one-second mark
  @doc false
  def handle_info(:start_clock, state) do
    # start the timer on a one-second interval
    {:ok, timer} = :timer.send_interval(1000, :second)

    # update the clock
    state = update_time(state)

    {:noreply, %{state | timer: timer}}
  end

  # --------------------------------------------------------
  def handle_info(:second, state) do
    {:noreply, update_time(state)}
  end

  # --------------------------------------------------------
  defp update_time(
         %{
           graph: graph,
           timezone: timezone,
           seconds: seconds,
           last: last
         } = state
       ) do
    time = Timex.now(timezone)

    new_last =
      if seconds do
        time.second
      else
        time.minute
      end

    if new_last != last do
      # get the hour and minutes as a percent of the circle
      second_percent = time.second / 60.0

      # get the hour and minutes as a percent of the circle
      minute_percent = (time.minute + second_percent) / 60.0

      hour =
        cond do
          time.hour >= 12 -> time.hour - 12
          true -> time.hour
        end

      hour_percent = (hour + minute_percent) / 12.0

      # convert to radians and apply as a rotation matrix
      # a full circle is 2 radians...
      graph
      |> Graph.modify(:hour_hand, &update_opts(&1, r: @two_pi * hour_percent))
      |> Graph.modify(:minute_hand, &update_opts(&1, r: @two_pi * minute_percent))
      |> Graph.modify(:second_hand, &update_opts(&1, r: @two_pi * second_percent))
      |> push_graph()
    end

    %{state | last: new_last}
  end
end