defmodule ExCatalog do
  @moduledoc """
  Documentation for `ExCatalog`.
  """
  @repo ExCatalog.Config.repo()

  alias ExCatalog.Category
  alias ExCatalog.Product
  alias ExCatalog.Manufacturer

  @doc """
  List version.
  """
  @version Mix.Project.config()[:version]
  def version, do: @version

  @doc """
  List all the categories (the index).

  ## Examples

      iex> ExCatalog.index(25)


  """
  def index(limit \\ 25, metadata \\ nil, cursor \\ nil, deleted \\ false) do
    import Ecto.Query
    import Ecto.SoftDelete.Query

    query =
      case(deleted) do
        false ->
          from(ExCatalog.Category,
            preload: [:parent_category],
            preload: [:image]
          )

        true ->
          from(ExCatalog.Category,
            preload: [:parent_category],
            preload: [:image]
          )
          |> with_undeleted
      end

    case cursor do
      :before ->
        @repo.paginate(
          query,
          before: metadata.before,
          include_total_count: true,
          cursor_fields: [:inserted_at, :id],
          limit: limit
        )

      :after ->
        @repo.paginate(
          query,
          after: metadata.after,
          include_total_count: true,
          cursor_fields: [:inserted_at, :id],
          limit: limit
        )

      _ ->
        @repo.paginate(
          query,
          include_total_count: true,
          cursor_fields: [:inserted_at, :id],
          limit: limit
        )
    end
  end

  @doc """
  List all products with preloads and optional currency conversion..

  ## Examples

      iex> ExCatalog.products(25)
      iex> ExCatalog.products(25,:USD)


  """
  def products(limit \\ 25, currency \\ :USD, deleted \\ false, owner_id \\ nil) do
    products(limit, nil, nil, currency, deleted, owner_id)
  end

  def products(limit \\ 25, metadata, cursor, currency, deleted, owner_id) do
    import Ecto.Query
    import Ecto.SoftDelete.Query

    query =
      case(owner_id) do
        nil ->
          case(deleted) do
            false ->
              from(ExCatalog.Product,
                preload: [:variations],
                preload: [:categories],
                preload: [:metas],
                preload: [:primary_image],
                preload: [:images],
                preload: [:manufacturer],
                preload: [:videos]
              )

            true ->
              from(ExCatalog.Product,
                preload: [:variations],
                preload: [:categories],
                preload: [:metas],
                preload: [:primary_image],
                preload: [:images],
                preload: [:manufacturer],
                preload: [:videos]
              )
              |> with_undeleted
          end

        _ ->
          case(deleted) do
            false ->
              from(ExCatalog.Product,
                where: [owner_id: ^owner_id],
                preload: [:variations],
                preload: [:categories],
                preload: [:metas],
                preload: [:primary_image],
                preload: [:manufacturer],
                preload: [:images],
                preload: [:videos]
              )

            true ->
              from(ExCatalog.Product,
                where: [owner_id: ^owner_id],
                preload: [:variations],
                preload: [:categories],
                preload: [:metas],
                preload: [:primary_image],
                preload: [:manufacturer],
                preload: [:images],
                preload: [:videos]
              )
              |> with_undeleted
          end
      end

    reply =
      case cursor do
        :before ->
          @repo.paginate(
            query,
            before: metadata.before,
            include_total_count: true,
            cursor_fields: [:inserted_at, :id],
            limit: limit
          )

        :after ->
          @repo.paginate(
            query,
            after: metadata.after,
            include_total_count: true,
            cursor_fields: [:inserted_at, :id],
            limit: limit
          )

        _ ->
          @repo.paginate(
            query,
            include_total_count: true,
            cursor_fields: [:inserted_at, :id],
            limit: limit
          )
      end

    case currency do
      nil ->
        reply

      _ ->
        modified =
          Enum.map(reply.entries, fn x ->
            {:ok, price} = ExCatalog.Currencies.convert(x.price, currency)
            %{x | price: price}
          end)

        {modified, reply.metadata}
    end
  end

  @doc """
  List product with preloads by sku and optional currency conversion.

  ## Examples

      iex> price = Money.new(:USD, 100)
      iex>  product = %{sku: "12345", price: price, title: "test product", sub_title: "test product", description: "test product"}
      iex> ExCatalog.product(product.sku)


  """
  def product(sku, currency \\ nil, deleted \\ false) do
    import Ecto.Query
    import Ecto.SoftDelete.Query

    query =
      case(deleted) do
        false ->
          from(ExCatalog.Product,
            where: [sku: ^sku],
            preload: [:variations],
            preload: [:categories],
            preload: [:metas],
            preload: [:primary_image],
            preload: [:manufacturer],
            preload: [:images],
            preload: [:videos]
          )

        true ->
          from(ExCatalog.Product,
            where: [sku: ^sku],
            preload: [:variations],
            preload: [:categories],
            preload: [:metas],
            preload: [:primary_image],
            preload: [:manufacturer],
            preload: [:images],
            preload: [:videos]
          )
          |> with_undeleted
      end

    reply = @repo.all(query)

    case List.first(reply) do
      nil ->
        reply

      record ->
        case currency do
          nil ->
            record

          currency ->
            {:ok, price} = ExCatalog.Currencies.convert(record.price, currency)
            %{record | price: price}
        end
    end
  end

  @doc """
  List product with preloads by category and optional currency conversion.

  ## Examples
      iex> ExCatalog.products_by_category("test_category", 1, :USD, false, order_by: :sku)


  """
  def products_by_category(slug, limit \\ 25, currency \\ :USD, deleted \\ false, opts \\ []) do
    products_by_category(slug, limit, nil, nil, currency, deleted, opts)
  end

  def products_by_category(slug, limit, metadata, cursor, currency, deleted, opts) do
    category = @repo.get_by(Category, slug: slug)

    case category do
      nil ->
        {:error, "Invalid Category"}

      _ ->
        import Ecto.Query
        import Ecto.SoftDelete.Query

        order = Keyword.get(opts, :order) || :desc
        by = Keyword.get(opts, :order_by) || :updated_at
        order_by = [{order, by}]
        origins = Keyword.get(opts, :origins) || []

        query =
          case(deleted) do
            false ->
              from(p in ExCatalog.Product,
                where: p.category_id == ^category.id and p.origin not in ^origins,
                order_by: ^order_by,
                preload: [:variations],
                preload: [:categories],
                preload: [:metas],
                preload: [:primary_image],
                preload: [:manufacturer],
                preload: [:images],
                preload: [:videos]
              )

            true ->
              from(p in ExCatalog.Product,
                where: p.category_id == ^category.id and p.origin not in ^origins,
                preload: [:variations],
                preload: [:categories],
                preload: [:metas],
                preload: [:primary_image],
                preload: [:manufacturer],
                preload: [:images],
                preload: [:videos]
              )
              |> with_undeleted
          end

        reply =
          case cursor do
            :before ->
              @repo.paginate(
                query,
                before: metadata.before,
                include_total_count: true,
                cursor_fields: [:inserted_at, :id],
                limit: limit
              )

            :after ->
              @repo.paginate(
                query,
                after: metadata.after,
                include_total_count: true,
                cursor_fields: [:inserted_at, :id],
                limit: limit
              )

            _ ->
              @repo.paginate(
                query,
                include_total_count: true,
                cursor_fields: [:inserted_at, :id],
                limit: limit
              )
          end

        case currency do
          nil ->
            reply

          _ ->
            modified =
              Enum.map(reply.entries, fn x ->
                {:ok, price} = ExCatalog.Currencies.convert(x.price, currency)
                %{x | price: price}
              end)

            {modified, reply.metadata}
        end
    end
  end

  ###
  @doc """
  List product with preloads by country and optional currency conversion.

  ## Examples

      iex> ExCatalog.products_by_country(["US"], 2, :USD, false, order_by: :sku)


  """
  def products_by_country(origin, limit \\ 25, currency \\ :USD, deleted \\ false, opts \\ [])
      when is_list(origin) do
    products_by_country(origin, limit, nil, nil, currency, deleted, opts)
  end

  def products_by_country(origin, limit, metadata, cursor, currency, deleted, opts) do
    import Ecto.Query
    import Ecto.SoftDelete.Query

    order = Keyword.get(opts, :order) || :desc
    by = Keyword.get(opts, :order_by) || :updated_at
    order_by = [{order, by}]

    query =
      case(deleted) do
        false ->
          from(p in ExCatalog.Product,
            where: p.origin not in ^origin,
            order_by: ^order_by,
            preload: [:variations],
            preload: [:categories],
            preload: [:metas],
            preload: [:primary_image],
            preload: [:manufacturer],
            preload: [:images],
            preload: [:videos]
          )

        true ->
          from(p in ExCatalog.Product,
            where: p.origin not in ^origin,
            preload: [:variations],
            preload: [:categories],
            preload: [:metas],
            preload: [:primary_image],
            preload: [:manufacturer],
            preload: [:images],
            preload: [:videos]
          )
          |> with_undeleted
      end

    reply =
      case cursor do
        :before ->
          @repo.paginate(
            query,
            before: metadata.before,
            include_total_count: true,
            cursor_fields: [:inserted_at, :id],
            limit: limit
          )

        :after ->
          @repo.paginate(
            query,
            after: metadata.after,
            include_total_count: true,
            cursor_fields: [:inserted_at, :id],
            limit: limit
          )

        _ ->
          @repo.paginate(
            query,
            include_total_count: true,
            cursor_fields: [:inserted_at, :id],
            limit: limit
          )
      end

    case currency do
      nil ->
        reply

      _ ->
        modified =
          Enum.map(reply.entries, fn x ->
            {:ok, price} = ExCatalog.Currencies.convert(x.price, currency)
            %{x | price: price}
          end)

        {modified, reply.metadata}
    end
  end

  @doc """
  List product with preloads by manufacturer and optional currency conversion.

  ## Examples

      iex> ExCatalog.products_by_manufacturer("test_manufacturer", 2, :USD, false, order_by: :sku)


  """

  def products_by_manufacturer(slug, limit \\ 25, currency \\ :USD, deleted \\ false, opts \\ []) do
    products_by_manufacturer(slug, limit, nil, nil, currency, deleted, opts)
  end

  def products_by_manufacturer(slug, limit, metadata, cursor, currency, deleted, opts) do
    manufacturer = @repo.get_by(Manufacturer, slug: slug)

    case manufacturer do
      nil ->
        {:error, "Invalid Manufacturer"}

      _ ->
        import Ecto.Query
        import Ecto.SoftDelete.Query

        order = Keyword.get(opts, :order) || :desc
        by = Keyword.get(opts, :order_by) || :updated_at
        order_by = [{order, by}]

        query =
          case(deleted) do
            false ->
              from(ExCatalog.Product,
                where: [manufacturer: ^manufacturer],
                order_by: ^order_by,
                preload: [:variations],
                preload: [:categories],
                preload: [:metas],
                preload: [:primary_image],
                preload: [:manufacturer],
                preload: [:images],
                preload: [:videos]
              )

            true ->
              from(ExCatalog.Product,
                where: [manufacturer: ^manufacturer],
                preload: [:variations],
                preload: [:categories],
                preload: [:metas],
                preload: [:primary_image],
                preload: [:manufacturer],
                preload: [:images],
                preload: [:videos]
              )
              |> with_undeleted
          end

        reply =
          case cursor do
            :before ->
              @repo.paginate(
                query,
                before: metadata.before,
                include_total_count: true,
                cursor_fields: [:inserted_at, :id],
                limit: limit
              )

            :after ->
              @repo.paginate(
                query,
                after: metadata.after,
                include_total_count: true,
                cursor_fields: [:inserted_at, :id],
                limit: limit
              )

            _ ->
              @repo.paginate(
                query,
                include_total_count: true,
                cursor_fields: [:inserted_at, :id],
                limit: limit
              )
          end

        case currency do
          nil ->
            reply

          _ ->
            modified =
              Enum.map(reply.entries, fn x ->
                {:ok, price} = ExCatalog.Currencies.convert(x.price, currency)
                %{x | price: price}
              end)

            {modified, reply.metadata}
        end
    end
  end

  ###
  @doc """
  Change the status active or disabled, this controls which products the user can see, (by default only the active products are displayed)

  ## Examples

      iex>  id = Ecto.UUID.generate
      iex> ExCatalog.active(:category, id)
      iex> ExCatalog.active(:product, id)


  """
  def active(type, id) do
    import Ecto.Query
    import Ecto.SoftDelete.Query

    query =
      case type do
        :category ->
          from(c in Category, where: c.id == ^id, select: c)
          |> with_undeleted

        _ ->
          from(p in Product, where: p.id == ^id, select: p)
          |> with_undeleted
      end

    case Keyword.has_key?(@repo.__info__(:functions), :soft_restore!) do
      true ->
        try do
          @repo.one!(query)
          |> @repo.soft_restore!()
        rescue
          _ -> {:error, "Not Available"}
        end

      false ->
        {:error, "Not Available"}
    end
  end

  def active(type, id, false) do
    import Ecto.Query

    case type do
      :category ->
        @repo.get_by!(Category, id: id)

        from(c in Category, where: c.id == ^id, select: c)
        |> @repo.soft_delete!()

      _ ->
        from(p in Product, where: p.id == ^id, select: p)
        |> @repo.soft_delete!()
    end
  end
end