defmodule Mobilizon.Service.Export.ICalendar do
  @moduledoc """
  Export an event to iCalendar format.
  """

  alias Mobilizon.Actors.Actor
  alias Mobilizon.Addresses.Address
  alias Mobilizon.{Config, Events}
  alias Mobilizon.Events.{Event, EventOptions}
  alias Mobilizon.Service.Export.{Cachable, Common}
  alias Mobilizon.Service.Formatter.{HTML, Text}

  @behaviour Cachable

  @item_limit 500

  @doc """
  Create cache for an actor, an event or an user token
  """
  @impl Cachable
  @spec create_cache(String.t()) :: {:commit, String.t()} | {:ignore, atom()}
  def create_cache("actor_" <> name) do
    case export_public_actor(name) do
      {:ok, res} ->
        {:commit, res}

      {:error, err} ->
        {:ignore, err}
    end
  end

  @impl Cachable
  def create_cache("event_" <> uuid) do
    with %Event{} = event <- Events.get_public_event_by_uuid_with_preload(uuid),
         {:ok, res} <- export_public_event(event) do
      {:commit, res}
    else
      {:error, err} ->
        {:ignore, err}

      nil ->
        {:ignore, :event_not_found}
    end
  end

  @impl Cachable
  def create_cache("token_" <> token) do
    case fetch_events_from_token(token) do
      {:ok, res} ->
        {:commit, res}

      {:error, err} ->
        {:ignore, err}
    end
  end

  @impl Cachable
  def create_cache("instance") do
    {:ok, res} = fetch_instance_feed()
    {:commit, res}
  end

  @spec fetch_instance_feed :: {:ok, String.t()}
  defp fetch_instance_feed do
    {:ok, events, _posts} = Common.fetch_instance_public_content(@item_limit)
    {:ok, %ICalendar{events: events |> Enum.map(&do_export_event/1)} |> ICalendar.to_ics()}
  end

  @doc """
  Export an event to iCalendar format.
  """
  @spec export_event(Event.t()) :: {:ok, String.t()}
  def export_event(%Event{} = event), do: {:ok, events_to_ics([event])}

  @doc """
  Export a public event to iCalendar format.

  The event must have a visibility of `:public` or `:unlisted`
  """
  @spec export_public_event(Event.t()) :: {:ok, String.t()} | {:error, :event_not_public}
  def export_public_event(%Event{visibility: visibility} = event)
      when visibility in [:public, :unlisted] do
    {:ok, events_to_ics([event])}
  end

  def export_public_event(%Event{}), do: {:error, :event_not_public}

  # Export a public actor's events to iCalendar format.
  # The actor must have a visibility of `:public` or `:unlisted`, as well as the events
  @spec export_public_actor(String.t()) ::
          {:ok, String.t()} | {:error, :actor_not_public | :actor_not_found}
  defp export_public_actor(name, limit \\ @item_limit) do
    case Common.fetch_actor_event_feed(name, limit) do
      {:ok, _actor, events, _posts} ->
        {:ok, events_to_ics(events)}

      {:error, err} ->
        {:error, err}
    end
  end

  @spec fetch_events_from_token(String.t(), integer()) ::
          {:ok, String.t()} | {:error, :actor_not_public | :actor_not_found}
  defp fetch_events_from_token(token, limit \\ @item_limit) do
    case Common.fetch_events_from_token(token, limit) do
      %{events: events} ->
        {:ok, events_to_ics(events)}

      {:error, err} ->
        {:error, err}
    end
  end

  @spec events_to_ics(list(Events.t())) :: String.t()
  defp events_to_ics(events) do
    %ICalendar{events: events |> Enum.map(&do_export_event/1)}
    |> ICalendar.to_ics(vendor: vendor())
  end

  @spec do_export_event(Event.t()) :: ICalendar.Event.t()
  defp do_export_event(%Event{} = event) do
    icalendar_event = %ICalendar.Event{
      summary: event.title,
      dtstart: begins_on(event),
      dtstamp: event.publish_at || DateTime.utc_now(),
      dtend: ends_on(event),
      description: HTML.html_to_text(event.description),
      uid: event.uuid,
      url: event.url,
      status: event.status,
      organizer: organizer(event)
    }

    icalendar_event =
      if event.physical_address do
        %ICalendar.Event{
          icalendar_event
          | geo: Address.coords(event.physical_address),
            location: Address.representation(event.physical_address)
        }
      else
        icalendar_event
      end

    icalendar_event =
      if length(event.tags) > 0 do
        %ICalendar.Event{icalendar_event | categories: event.tags |> Enum.map(& &1.title)}
      else
        icalendar_event
      end

    icalendar_event
  end

  @spec vendor :: String.t()
  defp vendor do
    "Mobilizon #{Config.instance_version()}"
  end

  defp begins_on(%Event{begins_on: begins_on, options: %EventOptions{timezone: timezone}}) do
    shift_tz(begins_on, timezone)
  end

  defp ends_on(%Event{ends_on: ends_on, options: %EventOptions{timezone: timezone}}) do
    shift_tz(ends_on, timezone)
  end

  defp shift_tz(%DateTime{} = date, timezone) when is_binary(timezone) do
    DateTime.shift_zone!(date, timezone)
  end

  defp shift_tz(%DateTime{} = date, _), do: date
  defp shift_tz(nil, _), do: nil

  defp organizer(%Event{attributed_to: %Actor{} = group}) do
    Actor.display_name(group)
  end

  defp organizer(%Event{organizer_actor: %Actor{} = profile}) do
    Actor.display_name(profile)
  end

  @impl Cachable
  @spec clear_caches(%{
          :__struct__ => Mobilizon.Actors.Actor | Mobilizon.Events.Event | Mobilizon.Posts.Post,
          optional(any) => any
        }) :: {:error, boolean} | {:ok, boolean}
  def clear_caches(%Event{attributed_to: %Actor{} = actor} = event) do
    clear_actor_feed(actor)
    clear_caches(%{event | attributed_to: nil})
  end

  @impl Cachable
  def clear_caches(%Event{uuid: uuid}) do
    # TODO: It would be nice to clear feed token cache based on participations as well,
    # but that's harder, as it would require loading all participations
    Cachex.del(:ics, "event_#{uuid}")
    clear_instance()
  end

  # Not applicable for posts
  @impl Cachable
  def clear_caches(%Mobilizon.Posts.Post{}) do
    {:ok, true}
  end

  @impl Cachable
  def clear_caches(%Actor{} = actor) do
    clear_actor_feed(actor)

    clear_instance()
  end

  defp clear_instance do
    Cachex.del(:ics, "instance")
  end

  defp clear_actor_feed(%Actor{preferred_username: preferred_username} = actor) do
    if Actor.is_public_visibility?(actor) do
      Cachex.del(:ics, "actor_#{preferred_username}")
    end
  end
end