defmodule Frenzy.Item do
  use Ecto.Schema
  import Ecto.Changeset
  import Ecto.Query
  alias FrenzyWeb.Router.Helpers, as: Routes
  alias FrenzyWeb.Endpoint

  def to_fever(item) do
    res = %{
      id: item.id,
      feed_id: item.feed_id,
      title: item.title,
      author: item.creator,
      html: item.content,
      url: item.url,
      is_saved: 0,
      is_read: if(item.read, do: 1, else: 0)
    }

    if item.date do
      Map.put(res, :created_on_time, Timex.to_unix(item.date))
    else
      res
    end
  end

  def to_fervor(item) do
    res = %{
      id: item.id |> Integer.to_string(),
      feed_id: item.feed_id |> Integer.to_string(),
      title: item.title,
      author: item.creator,
      content: item.content,
      url: item.url,
      service_url:
        Application.get_env(:frenzy, :base_url) <> Routes.item_path(Endpoint, :show, item.id),
      read: item.read
    }

    if item.date do
      Map.put(res, :published, DateTime.to_iso8601(item.date))
    else
      res
    end
  end

  schema "items" do
    field :content, :string
    field :content_type, :string
    field :date, :utc_datetime
    field :creator, :string
    field :guid, :string
    field :url, :string
    field :read, :boolean, default: false
    field :read_date, :utc_datetime
    field :title, :string
    field :tombstone, :boolean, default: false

    belongs_to :feed, Frenzy.Feed

    timestamps()
  end

  @type t() :: %__MODULE__{
          __meta__: Ecto.Schema.Metadata.t(),
          id: integer() | nil,
          content: String.t(),
          content_type: String.t() | nil,
          date: DateTime.t(),
          creator: String.t(),
          guid: String.t(),
          url: String.t(),
          read: boolean(),
          read_date: DateTime.t(),
          title: String.t() | nil,
          tombstone: boolean(),
          feed: Frenzy.Feed.t() | Ecto.Association.NotLoaded.t(),
          inserted_at: NaiveDateTime.t(),
          updated_at: NaiveDateTime.t()
        }

  @doc false
  def changeset(item, attrs) do
    item
    |> cast(attrs, [
      :guid,
      :title,
      :url,
      :creator,
      :date,
      :content,
      :read,
      :read_date,
      :tombstone,
      :feed_id
    ])
    |> validate_required([:guid, :url, :date, :content, :feed_id])
    |> unique_constraint([:feed_id, :guid], name: :items_feed_guid_index)
  end

  def exists?(feed_id, guid) do
    Frenzy.Repo.exists?(from i in __MODULE__, where: i.feed_id == ^feed_id and i.guid == ^guid)
  end
end