defmodule EzcontainerRailway.Railway do
  alias EzcontainerRailway.Projects
  alias EzcontainerRailway.GraphqlClient
  def get_projects(token) do
    resp = GraphqlClient.query(
        """
        query {
            projects {
                edges {
                    node {
                        id
                        name
                    }
                }
            }
        }
        """,
        token: token
    ) |> format_response

    case resp do
      {:error, _} -> resp
      {:ok, data} -> {:ok, data["projects"]["edges"]}
    end
  end

  def get_services(token) do
    project_id = Projects.get_project_by_token(token).project_id
    resp = GraphqlClient.query(
        """
        query getServices($projectId: String!) {
            project(id: $projectId) {
                services {
                    edges {
                        node {
                            id
                            name
                            serviceInstances {
                                edges {
                                    node {
                                    upstreamUrl
                                        domains {
                                            customDomains {
                                                domain
                                            }
                                            serviceDomains {
                                                domain
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        """,
        token: token,
        variables: %{
          projectId: project_id
        }
    ) |> format_response

    case resp do
      {:error, _} -> resp
      {:ok, data} ->
        final =
          data["project"]["services"]["edges"]
          |> Enum.map(&(&1["node"]))

        {:ok, final}
    end
  end
    

  def create_service(source, type, token) do
    resp = case type do
      "repo" -> create_service_from_repo(source, token)
      "image" -> create_service_from_image(source, token)
    end

    case resp do
      {:error, _} -> resp
      {:ok, data} -> {:ok, data["serviceCreate"]}
    end
  end

  defp create_service_from_image(source, token) do
    project_id = Projects.get_project_by_token(token).project_id
    GraphqlClient.query(
        """
        mutation createService($projectId: String!, $image: String!, $name: String!){
            serviceCreate(input: {projectId: $projectId, name: $name source: { image: $image }}) {
                id
            }
        }
        """,
      token: token,
      variables: %{
        projectId: project_id,
        image: source,
        name: source
      }
    ) |> format_response
  end

  defp create_service_from_repo(source, token) do
    project_id = Projects.get_project_by_token(token).project_id
    GraphqlClient.query(
        """
        mutation createService($projectId: String!, $repo: String!, $name: String!){
            serviceCreate(input: {projectId: $projectId, name: $name source: { repo: $repo }}) {
                id
            }
        }
        """,
      token: token,
      variables: %{
        projectId: project_id,
        repo: source,
        name: source
      }
    ) |> format_response
  end

  def create_project(token) do
    resp = GraphqlClient.query(
        """
        mutation {
            projectCreate(input: {}) {
                id
                name
            }
        }
        """,
      token: token
    )
    |> format_response

    case resp do
      {:error, _} -> resp
      {:ok, data} -> {:ok, data["projectCreate"]["id"]}
    end
  end

  def delete_container(service_id, token) do
    GraphqlClient.query(
        """
        mutation deleteContainer($id: String!) {
            serviceDelete(id: $id)
        }
        """,
      token: token,
      variables: %{
        id: service_id
      }
    )
    |> format_response
  end

  def get_user_id(token) do
    {:ok, resp} = GraphqlClient.query(
        """
        query {
            me {
                id
            }
        }
        """,
      token: token
    )
    |> format_response

    {:ok, resp["me"]["id"]}
  end

  def has_errors?(resp) do
    has_errors_in_array?(resp["errors"])
  end

  defp format_response(resp) when is_map(resp) do
    if has_errors?(resp.body) do
      {:error, resp.body["errors"]}
    else
      {:ok, resp.body["data"]}
    end
  end

  defp has_errors_in_array?([_|_]), do: true
  defp has_errors_in_array?(_), do: false
end