# Copyright 2023 Arkemis S.r.l.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

defmodule Arke.Core.File do
  @moduledoc """
  Defines a file that can be used to store data
  """

  use Arke.System
  alias Arke.Utils.Gcp

  arke id: :arke_file, label: "Arke file" do
    parameter(:name, :string, required: true)
    parameter(:path, :string, required: true)
    parameter(:provider, :string, values: ["local", "gcloud", "aws"], default: "gcloud")
    parameter(:size, :float, required: false)
    parameter(:extension, :string, required: false)
    parameter(:binary, :bynary, required: true, only_runtime: true)
  end

  def before_create(_, %{data: %{name: name, path: path, binary: binary}} = unit) do
    case Gcp.upload_file("#{path}/#{name}", binary) do
      {:ok, _object} -> {:ok, unit}
      {:error, error} -> {:error, error}
    end
  end

  def before_delete(_, %{data: %{name: name, path: path}} = unit) do
    case Gcp.delete_file("#{path}/#{name}") do
      {:ok, _e} -> {:ok, unit}
      {:error, error} -> {:error, error}
    end
  end

  def before_update(_, %{binary: binary} = unit) when is_nil(binary), do: {:ok, unit}
  def before_update(_, %{data: %{name: name, path: path, binary: binary}} = unit) do
    case Gcp.upload_file("#{path}/#{name}", binary) do
      {:ok, _object} -> {:ok, unit}
      {:error, error} -> {:error, error}
    end
  end

  def test() do
    {:ok, token} = Goth.Token.fetch([])
    conn = GoogleApi.Storage.V1.Connection.new(token.token)

    # Call the Storage V1 API (for example) to list buckets
    {:ok, response} = GoogleApi.Storage.V1.Api.Buckets.storage_buckets_list(conn, "arkemis-lab")

    # Print the response
    Enum.each(response.items, &IO.puts(&1.id))
  end

  @spec upload_file :: none
  def upload_file() do
    # Authenticate.
    {:ok, token} = Goth.Token.fetch([])
    conn = GoogleApi.Storage.V1.Connection.new(token.token)

    # Make the API request.
    {:ok, object} =
      GoogleApi.Storage.V1.Api.Objects.storage_objects_insert_iodata(
        conn,
        "arke_demo",
        "multipart",
        %{name: "file.txt"},
        "Hello " <> "Dorian aa" <> "!"
      )

    # Print the object.
    IO.puts("Uploaded #{object.name} to #{object.selfLink}")
  end

  def get() do
    {:ok, token} = Goth.Token.fetch([])
    conn = GoogleApi.Storage.V1.Connection.new(token.token)

    # Make the API request.
    {:ok, object} =
      GoogleApi.Storage.V1.Api.Objects.storage_objects_get(
        conn,
        "arke_demo",
        "file.txt"
      )
  end

  def get_url() do
    service_account = "arke-storage@arkemis-lab.iam.gserviceaccount.com"
    bucket = "arke_demo"
    object = "file.txt"

    get_signed_url(service_account, bucket, object)
  end

  def get_signed_url(gcp_service_account, bucket, object) do
    %Tesla.Client{pre: [{Tesla.Middleware.Headers, :call, [auth_headers]}]} = get_connection()
    headers = [{"Content-Type", "application/json"}] ++ auth_headers

    url =
      "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/#{gcp_service_account}:signBlob"

    expires = DateTime.utc_now() |> DateTime.to_unix() |> Kernel.+(1 * 3600)
    resource = "/#{bucket}/#{object}"
    signature = ["GET", "", "", expires, resource] |> Enum.join("\n") |> Base.encode64()
    body = %{"payload" => signature} |> Poison.encode!()
    IO.inspect(HTTPoison.post(url, body, headers))
    {:ok, %{status_code: 200, body: result}} = HTTPoison.post(url, body, headers)

    %{"signedBlob" => signed_blob} = Poison.decode!(result)

    qs =
      %{
        "GoogleAccessId" => gcp_service_account,
        "Expires" => expires,
        "Signature" => signed_blob
      }
      |> URI.encode_query()

    Enum.join(["https://storage.googleapis.com#{resource}", "?", qs])
  end

  defp get_connection() do
    {:ok, token} = Goth.Token.fetch([])
    conn = GoogleApi.Storage.V1.Connection.new(token.token)
  end
end