package main

import (
	"bytes"
	"context"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"strings"
	"testing"

	"gitea.maximumdirect.net/eric/ReleaseKit/cmd/releasekit/internal/cli"
)

func TestWoodpeckerDeliveryCommandSequences(t *testing.T) {
	_, sourceFile, _, ok := runtime.Caller(0)
	if !ok {
		t.Fatal("locate integration test source")
	}
	root := filepath.Clean(filepath.Join(filepath.Dir(sourceFile), "../.."))
	executable := filepath.Join(t.TempDir(), "releasekit")
	build := exec.Command("go", "build", "-o", executable, "./cmd/releasekit")
	build.Dir = root
	if output, err := build.CombinedOutput(); err != nil {
		t.Fatalf("build local ReleaseKit executable: %v\n%s", err, output)
	}

	t.Run("source-only", func(t *testing.T) {
		repository := newCLIRepository(t)
		state := &deliveryServerState{}
		server := newDeliveryServer(t, state)
		defer server.Close()
		writeDeliveryProfile(t, repository, cli.Settings{
			Product:  "Example Product",
			Delivery: &cli.DeliverySettings{BaseURL: server.URL, Owner: "owner", Repository: "example"},
		})
		state.commit = cliGitOutput(t, repository, "rev-parse", "HEAD")
		cliGitRun(t, repository, "tag", "v1.2.3")
		cliGitRun(t, repository, "checkout", "--detach", "v1.2.3")

		output := runWoodpeckerCommand(t, executable, repository, true, "deliver", "--repo", repository, "v1.2.3")
		if !strings.Contains(output, "state complete") || state.releaseCreates != 1 || state.assetUploads != 0 {
			t.Fatalf("source-only workflow output=%q creates=%d uploads=%d", output, state.releaseCreates, state.assetUploads)
		}
	})

	t.Run("binary", func(t *testing.T) {
		repository := newDeliveryBuildRepository(t)
		state := &deliveryServerState{}
		server := newDeliveryServer(t, state)
		defer server.Close()
		writeDeliveryProfile(t, repository, cli.Settings{
			Product:  "Example Product",
			Build:    &cli.BuildSettings{MainPackage: ".", BinaryName: "helper", Targets: []string{"linux/amd64"}},
			Delivery: &cli.DeliverySettings{BaseURL: server.URL, Owner: "owner", Repository: "example"},
		})
		state.commit = cliGitOutput(t, repository, "rev-parse", "HEAD")
		cliGitRun(t, repository, "tag", "v1.2.3")
		cliGitRun(t, repository, "checkout", "--detach", "v1.2.3")
		exclude, err := os.OpenFile(filepath.Join(repository, ".git", "info", "exclude"), os.O_APPEND|os.O_WRONLY, 0)
		if err != nil {
			t.Fatal(err)
		}
		if _, err := exclude.WriteString("\n/.releasekit/\n"); err != nil {
			t.Fatal(err)
		}
		if err := exclude.Close(); err != nil {
			t.Fatal(err)
		}
		assets := filepath.Join(repository, ".releasekit", "assets")
		if err := os.MkdirAll(filepath.Dir(assets), 0o700); err != nil {
			t.Fatal(err)
		}

		// This follows the binary template's build then delivery commands, with
		// the executable built above replacing its pinned go install step.
		runWoodpeckerCommand(t, executable, repository, false, "build", "--repo", repository, "--output", assets, "v1.2.3")
		output := runWoodpeckerCommand(t, executable, repository, true, "deliver", "--repo", repository, "--assets", assets, "v1.2.3")
		if !strings.Contains(output, "state complete") || state.releaseCreates != 1 || state.assetUploads != 2 {
			t.Fatalf("binary workflow output=%q creates=%d uploads=%d", output, state.releaseCreates, state.assetUploads)
		}
		if _, ok := state.assets["helper-v1.2.3-linux-amd64"]; !ok {
			t.Fatalf("binary asset was not delivered: %#v", state.assets)
		}
		if _, ok := state.assets["SHA256SUMS"]; !ok {
			t.Fatalf("checksum manifest was not delivered: %#v", state.assets)
		}
	})
}

func runWoodpeckerCommand(t *testing.T, executable, repository string, credential bool, args ...string) string {
	t.Helper()
	command := exec.CommandContext(context.Background(), executable, args...)
	command.Dir = repository
	command.Env = os.Environ()
	if credential {
		command.Env = append(command.Env, "RELEASEKIT_GITEA_TOKEN=fixture-token")
	}
	var stdout, stderr bytes.Buffer
	command.Stdout, command.Stderr = &stdout, &stderr
	if err := command.Run(); err != nil {
		t.Fatalf("ReleaseKit %v failed: %v\nstdout: %s\nstderr: %s", args, err, stdout.String(), stderr.String())
	}
	return stdout.String()
}