package forgejo

import (
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"testing"
)

func TestRepoExistsOnlyCreatesOnNotFound(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
		writer.WriteHeader(http.StatusUnauthorized)
	}))
	defer server.Close()
	manager := NewRepoManager(server.URL, "token", "owner", "user", "manifests", "cluster", "main", "maidn/bootstrap-test")
	manager.HTTPClient = server.Client()
	if _, err := manager.repoExists("cluster"); err == nil {
		t.Fatal("repoExists() accepted an unauthorized response")
	}
}

func TestEnsureWebhookUpdatesMatchingURL(t *testing.T) {
	requests := 0
	server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
		requests++
		switch request.Method {
		case http.MethodGet:
			if request.URL.Path != "/api/v1/repos/owner/app/hooks" {
				t.Fatalf("unexpected lookup path %q", request.URL.Path)
			}
			_ = json.NewEncoder(writer).Encode([]hook{{ID: 7, URL: "https://tekton.example.test/"}})
		case http.MethodPatch:
			if request.URL.Path != "/api/v1/repos/owner/app/hooks/7" {
				t.Fatalf("unexpected update path %q", request.URL.Path)
			}
			var body hookRequest
			if err := json.NewDecoder(request.Body).Decode(&body); err != nil {
				t.Fatal(err)
			}
			if body.Type != "" || body.AuthorizationHeader != "Bearer token" || len(body.Events) != 2 {
				t.Fatalf("unexpected hook request: %#v", body)
			}
			writer.WriteHeader(http.StatusOK)
		default:
			t.Fatalf("unexpected method %q", request.Method)
		}
	}))
	defer server.Close()
	manager := NewRepoManager(server.URL, "token", "owner", "user", "manifests", "cluster", "main", "maidn/bootstrap-test")
	manager.HTTPClient = server.Client()
	if err := manager.EnsureWebhook("app", "https://tekton.example.test/", "Bearer token"); err != nil {
		t.Fatal(err)
	}
	if requests != 2 {
		t.Fatalf("requests = %d, want 2", requests)
	}
}

func TestEnsureWebhookCreatesMissingWebhook(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
		switch request.Method {
		case http.MethodGet:
			_ = json.NewEncoder(writer).Encode([]hook{})
		case http.MethodPost:
			var body hookRequest
			if err := json.NewDecoder(request.Body).Decode(&body); err != nil {
				t.Fatal(err)
			}
			if body.Type != "forgejo" || body.Config["content_type"] != "json" {
				t.Fatalf("unexpected hook request: %#v", body)
			}
			writer.WriteHeader(http.StatusCreated)
		default:
			t.Fatalf("unexpected method %q", request.Method)
		}
	}))
	defer server.Close()
	manager := NewRepoManager(server.URL, "token", "owner", "user", "manifests", "cluster", "main", "maidn/bootstrap-test")
	manager.HTTPClient = server.Client()
	if err := manager.EnsureWebhook("app", "https://tekton.example.test/", "Bearer token"); err != nil {
		t.Fatal(err)
	}
}

func TestRepositoryFromURL(t *testing.T) {
	owner, repo, err := RepositoryFromURL("https://git.example.test/team/app.git")
	if err != nil || owner != "team" || repo != "app" {
		t.Fatalf("RepositoryFromURL() = (%q, %q, %v)", owner, repo, err)
	}
}

func TestEnsureRepositoryCreatesWithoutInitialization(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
		switch request.Method {
		case http.MethodGet:
			writer.WriteHeader(http.StatusNotFound)
		case http.MethodPost:
			var body createRepoRequest
			if err := json.NewDecoder(request.Body).Decode(&body); err != nil {
				t.Fatal(err)
			}
			if body.AutoInit {
				t.Fatal("application repository must be created without an initial commit")
			}
			writer.WriteHeader(http.StatusCreated)
		default:
			t.Fatalf("unexpected method %q", request.Method)
		}
	}))
	defer server.Close()
	manager := NewRepoManager(server.URL, "token", "owner", "user", "manifests", "cluster", "main", "maidn/bootstrap-test")
	manager.HTTPClient = server.Client()
	created, err := manager.EnsureRepository("app", "description")
	if err != nil || !created {
		t.Fatalf("EnsureRepository() = (%t, %v)", created, err)
	}
}

func TestRepoExistsReturnsFalseOnNotFound(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
		writer.WriteHeader(http.StatusNotFound)
	}))
	defer server.Close()
	manager := NewRepoManager(server.URL, "token", "owner", "user", "manifests", "cluster", "main", "maidn/bootstrap-test")
	manager.HTTPClient = server.Client()
	exists, err := manager.repoExists("cluster")
	if err != nil || exists {
		t.Fatalf("repoExists() = (%t, %v), want (false, nil)", exists, err)
	}
}