google_sheets

defmodule GoogleSheets.Updater do

  @moduledoc """
  GenServer for updating and polling a spreadsheet.
  """

  use GenServer
  require Logger

  defmodule State do
    defstruct id: nil, config: nil
  end

  @default_poll_delay 5 * 60

  @doc false
  def start_link(id, config) when is_atom(id) and is_list(config) do
    GenServer.start_link(__MODULE__, %State{id: id, config: config}, [name: id])
  end

  @doc false
  @spec update(spreadsheet_id :: atom, timeout :: non_neg_integer) :: {:ok, :updated, String.t}  | {:ok, :unchanged} | {:error, term}
  def update(spreadsheet_id, timeout) when is_atom(spreadsheet_id) and is_integer(timeout) and timeout >= 0 do
    GenServer.call spreadsheet_id, :manual_update, timeout
  end

  @doc false
  def init(%State{} = state) do
    Logger.info "Starting updater process for spreadsheet #{state.id} with config #{inspect state.config}"
    load_initial_version state, GoogleSheets.has_version?(state.id)
    schedule_next_update state.id, Keyword.get(state.config, :poll_delay_seconds, @default_poll_delay)
    {:ok, state}
  end

  defp load_initial_version(%State{}, true) do
    :ok
  end
  defp load_initial_version(%State{} = state, false) do
    Logger.info "Loading initial data for spreadsheet #{state.id} from filesystem directory: #{inspect state.config[:dir]}"

    {:ok, loader_version, worksheets} = do_load GoogleSheets.Loader.FileSystem, state
    {:ok, version, data} = do_parse parser_impl(state), state.id, worksheets
    update_ets_entry state.id, version, loader_version, data
    Logger.info "Initial data for spreadsheet #{state.id} loaded, version is now #{version}"
  end

  @doc false
  def handle_call(:manual_update, _from, %State{} = state) do
    Logger.info "Doing requested manual update for spreadsheet #{state.id}"
    try do
      version = do_update state
      {:reply, {:ok, :updated, version}, state}
    catch
      {:ok, :unchanged} ->
        {:reply, {:ok, :unchanged}, state}
      {:error, reason} ->
        {:reply, {:error, reason}, state}
    rescue
      exception ->
        stacktrace = System.stacktrace
        {:reply, {:error, "Exception while updating configuration.\n\nExcption:\n#{inspect exception}\n\nStacktrace\n#{inspect stacktrace}"}, state}
    end
  end

  @doc false
  def handle_info(:update, %State{} = state) do
    try do
      do_update state
    catch
      {:ok, :unchanged} ->
        :ok
      {:error, reason} ->
        Logger.error "Error updating spreadsheet #{state.id} #{inspect reason}"
    end
    schedule_next_update state.id, Keyword.get(state.config, :poll_delay_seconds, @default_poll_delay)
    {:noreply, state}
  end

  defp do_update(%State{} = state) do
    {:ok, loader_version, worksheets} = do_load loader_impl(state), state
    {:ok, version, data} = do_parse parser_impl(state), state.id, worksheets

    if version == GoogleSheets.latest_version state.id do
      throw {:ok, :unchanged}
    end

    update_ets_entry state.id, version, loader_version, data
  end

  defp do_load(impl, %State{} = state) do
    previous_version = latest_loader_version state.id
    case impl.load previous_version, state.id, state.config do
      {:ok, version, worksheets} ->
        {:ok, version, worksheets}
      result ->
        throw result
    end
  end

  # If no parser is configured and raw CSV data is stored into ETS, calculate MD5 hash,
  # otherwise call the module implementing parser behavior
  defp do_parse(nil, _id, worksheets) when is_list(worksheets) do
    worksheets = Enum.sort worksheets, fn %GoogleSheets.WorkSheet{} = a, %GoogleSheets.WorkSheet{} = b -> a.name < b.name end
    {:ok, calculate_hash(worksheets), worksheets}
  end
  defp do_parse(impl, id, worksheets) when is_list(worksheets) do
    case impl.parse id, worksheets do
      {:ok, version, data} ->
        {:ok, version, data}
      {:ok, data} ->
        {:ok, calculate_hash(data), data}
      result ->
        throw result
    end
  end

  # Write a new entry into ETS table and make the {:id, :latest} tuple point to new version
  defp update_ets_entry(id, version, loader_version, data) do
    Logger.info "Updating ETS entry for spreadsheet #{id} version #{inspect version} loader_version #{inspect loader_version}"
    :ets.insert :google_sheets, {version, %{id: id, version: version, loader_version: loader_version, data: data}}
    :ets.insert :google_sheets, {id, %{version: version}}
  end

  # If update_delay has been configured to 0, no updates will be done
  defp schedule_next_update(id, 0), do: Logger.info("Stopping updates for #{id}")
  defp schedule_next_update(_id, delay_seconds), do: Process.send_after(self, :update, delay_seconds * 1000)

  # Calculate MD5 hash from any data, by converting to binary first if needed
  defp calculate_hash(binary) when is_binary(binary) do
    :crypto.hash(:md5, binary) |> Base.encode16(case: :lower)
  end
  defp calculate_hash(data) do
    calculate_hash :erlang.term_to_binary(data)
  end

  # Returns the module implementing parser or nil if not configured
  defp parser_impl(%State{config: config}) do
    Keyword.get config, :parser
  end

  # Returns the module implementing polling loader
  defp loader_impl(%State{config: config}) do
    Keyword.get config, :loader, GoogleSheets.Loader.Docs
  end

  defp latest_loader_version(id) when is_atom(id) do
    case GoogleSheets.latest_version id do
      :not_found ->
        nil
      {:ok, version} ->
        [{^version, %{loader_version: loader_version}}] = :ets.lookup :google_sheets, version
        loader_version
    end
  end

end