defmodule Rela do
  use Ecto.Schema

  schema "" do
    field(:actor_id, :integer)
    field(:contractor_id, :integer)
    field(:contractor, :string)
    field(:created_at, :naive_datetime)
    field(:is_deleted, :boolean)
  end

  defmacro __using__(opts) do
    quote bind_quoted: [opts: opts] do
      import Ecto.Query
      @sql Ecto.Adapters.SQL
      @chng Ecto.Changeset
      @repo opts[:repo]
      @conns Enum.reduce(opts[:relations], %{}, fn
               %{arity: :one_to_one, actor: actor, contractor: contractor}, acc ->
                 Map.merge(acc, %{{actor, contractor} => :one, {contractor, actor} => :one})

               %{arity: :one_to_many, actor: actor, contractor: contractor}, acc ->
                 Map.merge(acc, %{{actor, contractor} => :many, {contractor, actor} => :one})

               %{arity: :many_to_many, actor: actor, contractor: contractor}, acc ->
                 Map.merge(acc, %{{actor, contractor} => :many, {contractor, actor} => :many})

               _ = type, _ ->
                 throw({:error, "INCORRECT TYPE FORMAT", type})
             end)

      def exists_relation?(left, right) do
        exists_relation(left, right)
        |> case do
          {:ok, _} -> true
          {:error, _} -> false
        end
      end

      def exists_relation(left, _right) when not is_struct(left),
        do: {:error, "left item is not a struct"}

      def exists_relation(_left, right) when not is_struct(right),
        do: {:error, "right item is not a struct"}

      def exists_relation(
            %{__meta__: %{source: left_table}, id: left_id},
            %{__meta__: %{source: right_table}, __struct__: right_struct, id: right_id}
          )
          when not is_nil(left_id) and not is_nil(right_id) do
        with true <- exists(left_table, left_id, right_id, right_table),
             true <- exists(right_table, right_id, left_id, left_table) do
          {:ok, "relation between #{left_table} and #{right_table} exists"}
        else
          false -> {:error, "relations between #{left_table} and #{right_table} not found"}
        end
      end

      def exists_relation(left, _right) do
        message = if is_nil(left[:id]), do: "left", else: "right"

        {:error, "#{message} item has no id"}
      end

      def get_contractors!(left, right) do
        get_contractors(left, right)
        |> case do
          {:ok, answer} -> answer
          {:error, _} -> []
        end
      end

      def get_contractors(left, _right) when not is_struct(left),
        do: {:error, "left item is not a struct"}

      def get_contractors(left, right) when not is_struct(right),
        do: get_contractors(left, right.__struct__)

      def get_contractors(
            %{__meta__: %{source: left_table}, id: left_id},
            %{__meta__: %{source: right_table}, __struct__: right_struct}
          )
          when not is_nil(left_id) do
        with [_ | _] = right <- get(left_table, left_id, right_table),
             contractors <-
               Enum.map(
                 right,
                 fn a ->
                   Enum.at(
                     @repo.all(from(r in right_struct, where: r.id == ^a.contractor_id)),
                     0
                   )
                 end
               ) do
          {:ok, contractors}
        else
          [] -> {:error, "relations between #{left_table} and #{right_table} not found"}
        end
      end

      def get_contractors(left, _right), do: {:error, "left item has no id"}

      def get_contractor!(left, right) do
        get_contractor(left, right)
        |> case do
          {:ok, answer} -> answer
          {:error, _} -> nil
        end
      end

      def get_contractor(left, _right) when not is_struct(left),
        do: {:error, "left item is not a struct"}

      def get_contractor(left, right) when not is_struct(right),
        do: get_contractor(left, right.__struct__)

      def get_contractor(
            %{__meta__: %{source: left_table}, __struct__: left_struct, id: left_id},
            %{__meta__: %{source: right_table}, __struct__: right_struct}
          )
          when not is_nil(left_id) do
        with [%{contractor_id: right_id} | _] <- get(left_table, left_id, right_table),
             [contractor | _] <- @repo.all(from(r in right_struct, where: r.id == ^right_id)) do
          {:ok, contractor}
        else
          [] -> {:error, "relation between #{left_table} and #{right_table} not found"}
        end
      end

      def get_contractor(left, right), do: {:error, "left item has no id"}

      def delete_rela(left, _right) when not is_struct(left),
        do: {:error, "left item is not a struct"}

      def delete_rela(_left, right) when not is_struct(right),
        do: {:error, "right item is not a struct"}

      def delete_rela(
            %{__meta__: %{source: left_table}, __struct__: left_struct, id: left_id},
            %{__meta__: %{source: right_table}, __struct__: right_struct, id: right_id}
          )
          when not is_nil(left_id) and not is_nil(right_id) do
        with [left | _] <- get(left_table, left_id, right_id, right_table),
             [right | _] <- get(right_table, right_id, left_id, left_table),
             _ <- delete(left),
             _ <- delete(right) do
          {:ok, "relation between #{left_table} and #{right_table} deleted"}
        else
          [] -> {:error, "relation between #{left_table} and #{right_table} not found"}
        end
      end

      def delete_rela(left, _right) do
        if is_nil(left[:id]) do
          {:error, "left item has no id"}
        else
          {:error, "right item has no id"}
        end
      end

      def create(left, _right) when not is_struct(left),
        do: {:error, "left item is not a struct"}

      def create(_left, right) when not is_struct(right),
        do: {:error, "right item is not a struct"}

      def create(
            %{__meta__: %{source: left_table}, __struct__: left_struct, id: left_id},
            %{__meta__: %{source: right_table}, __struct__: right_struct, id: right_id}
          )
          when not is_nil(left_id) and not is_nil(right_id) do
        with relation_arity when not is_tuple(relation_arity) <-
               Map.get(
                 @conns,
                 {left_struct, right_struct},
                 {:error,
                  "relation between tables #{left_table} and #{right_table} doesn't exist"}
               ),
             [] <-
               if(relation_arity == :one,
                 do: get(left_table, left_id, right_table),
                 else: []
               ),
             {1, _} <- insert(left_table, left_id, right_id, right_table),
             {1, _} <- insert(right_table, right_id, left_id, left_table) do
          {:ok, "relation between #{left_table} and #{right_table} created"}
        else
          [_ | _] -> {:error, "new relation violates arity agreements"}
          any -> any
        end
      end

      def create(left, _right) do
        if is_nil(left[:id]) do
          {:error, "left item has no id"}
        else
          {:error, "right item has no id"}
        end
      end

      def get_conns(), do: @conns

      def check_r_tables() do
        Enum.map(@conns, fn {{actor, _}, _} -> actor.__struct__.__meta__.source end)
        |> Enum.uniq()
        |> Enum.each(
          &@sql.query(
            @repo,
            "CREATE TABLE IF NOT EXISTS r_#{&1} (id serial PRIMARY KEY, actor_id INT NOT NULL, contractor_id INT NOT NULL, contractor VARCHAR(50) NOT NULL, created_at TIMESTAMP NOT NULL DEFAULT NOW(), is_deleted BOOLEAN NOT NULL DEFAULT false, FOREIGN KEY (actor_id) REFERENCES #{&1} (id))"
          )
        )
      end

      defp get(table, actor_id, contractor) do
        @repo.all(
          from(r in {"r_#{table}", Rela},
            where: r.actor_id == ^actor_id and r.contractor == ^contractor and not r.is_deleted,
            select: r
          )
        )
      end

      defp get(table, actor_id, contractor_id, contractor) do
        @repo.all(
          from(r in {"r_#{table}", Rela},
            where:
              r.actor_id == ^actor_id and r.contractor == ^contractor and
                r.contractor_id == ^contractor_id and not r.is_deleted,
            select: r
          )
        )
      end

      defp insert(table, actor_id, contractor_id, contractor, first_time? \\ true) do
        try do
          if not exists(table, actor_id, contractor_id, contractor) do
            @repo.insert_all("r_#{table}", [
              %{actor_id: actor_id, contractor_id: contractor_id, contractor: contractor}
            ])
          else
            {:error, "relation between #{table} and #{contractor} already exists"}
          end
        rescue
          any ->
            IO.inspect(any)
            check_r_tables()

            if(first_time?,
              do: insert(table, actor_id, contractor_id, contractor, false),
              else: {:error, "something went wrong when inserting relation: #{any}"}
            )
        end
      end

      defp exists(table, actor_id, contractor_id, contractor) do
        @repo.exists?(
          from(r in {"r_#{table}", Rela},
            where:
              r.actor_id == ^actor_id and r.contractor_id == ^contractor_id and
                r.contractor == ^contractor
          )
        )
      end

      defp delete(rela) do
        rela
        |> @chng.change(is_deleted: true)
        |> @repo.update()
      end
    end
  end
end