package config

import (
	"bytes"
	"io"
	"log/slog"
	"os"
	"path/filepath"
	"strings"
	"testing"
)

func writeUpgradeFixture(t *testing.T) (configPath, stateDir, secretPath string, raw []byte) {
	t.Helper()
	root := t.TempDir()
	stateDir = filepath.Join(root, "state")
	if err := os.MkdirAll(stateDir, 0o750); err != nil {
		t.Fatal(err)
	}
	secretPath = filepath.Join(root, "client_secret")
	if err := os.WriteFile(secretPath, []byte("het-geheim\n"), 0o600); err != nil {
		t.Fatal(err)
	}
	configPath = filepath.Join(root, "etc", "config.yml")
	if err := os.MkdirAll(filepath.Dir(configPath), 0o755); err != nil {
		t.Fatal(err)
	}
	raw = []byte(`base_url: https://git.example.test
listen: 127.0.0.1:9090
state_path: ` + stateDir + `
trusted_proxies:
  - 10.0.0.2
auth:
  mode: oauth
  client_id: git.example.test
  client_secret: ""
  client_secret_file: ` + secretPath + `
ssh:
  enabled: true
  listen: 127.0.0.1:2222
  public_host: git.example.test
  public_port: 22
ci:
  enabled: true
  concurrency: 2
`)
	if err := os.WriteFile(configPath, raw, 0o644); err != nil {
		t.Fatal(err)
	}
	return configPath, stateDir, secretPath, raw
}

func TestUpgradePathLeavesConfigYmlUnchanged(t *testing.T) {
	configPath, stateDir, _, raw := writeUpgradeFixture(t)
	silent := slog.New(slog.NewTextHandler(io.Discard, nil))

	rt, err := LoadRuntime(configPath, silent)
	if err != nil {
		t.Fatal(err)
	}
	if !rt.Imported {
		t.Fatal("eerste start hoort config.yml te importeren")
	}
	if rt.Config.Auth.ClientSecret != "het-geheim" {
		t.Fatalf("geheim: %q", rt.Config.Auth.ClientSecret)
	}
	if rt.Config.Listen != "127.0.0.1:9090" || rt.Config.CI.Concurrency != 2 {
		t.Fatalf("waarden: %+v", rt.Config)
	}
	after, err := os.ReadFile(configPath)
	if err != nil {
		t.Fatal(err)
	}
	if !bytes.Equal(after, raw) {
		t.Fatalf("config.yml is gewijzigd:\n%s", after)
	}
	if _, err := os.Stat(filepath.Join(stateDir, SettingsFile)); err != nil {
		t.Fatal("settings.yml ontbreekt")
	}
	if _, err := os.Stat(filepath.Join(stateDir, ImportMarker)); err != nil {
		t.Fatal("marker ontbreekt")
	}

	// Tweede start: geen tweede import, ook niet als config.yml verandert.
	changed := bytes.Replace(raw, []byte("127.0.0.1:9090"), []byte("127.0.0.1:9191"), 1)
	if err := os.WriteFile(configPath, changed, 0o644); err != nil {
		t.Fatal(err)
	}
	rt2, err := LoadRuntime(configPath, silent)
	if err != nil {
		t.Fatal(err)
	}
	if rt2.Imported {
		t.Fatal("tweede start mag niet opnieuw importeren")
	}
	if rt2.Config.Listen != "127.0.0.1:9090" {
		t.Fatalf("settings moeten winnen, got %s", rt2.Config.Listen)
	}
	after, _ = os.ReadFile(configPath)
	if !bytes.Equal(after, changed) {
		t.Fatal("tweede start mag config.yml niet terugschrijven")
	}
}

func TestSettingsOverlayWinsAndEnvWinsLast(t *testing.T) {
	configPath, stateDir, _, _ := writeUpgradeFixture(t)
	silent := slog.New(slog.NewTextHandler(io.Discard, nil))
	if _, err := LoadRuntime(configPath, silent); err != nil {
		t.Fatal(err)
	}
	st, err := LoadSettings(stateDir)
	if err != nil || st == nil {
		t.Fatal(err)
	}
	st.Listen = ptr("127.0.0.1:9400")
	st.BaseURL = ptr("https://over.example.test")
	if err := SaveSettings(stateDir, *st); err != nil {
		t.Fatal(err)
	}
	t.Setenv("BLUEGIT_LISTEN", "127.0.0.1:9500")
	rt, err := LoadRuntime(configPath, silent)
	if err != nil {
		t.Fatal(err)
	}
	if rt.Config.BaseURL != "https://over.example.test" {
		t.Fatalf("overlay base_url: %s", rt.Config.BaseURL)
	}
	if rt.Config.Listen != "127.0.0.1:9500" {
		t.Fatalf("env moet winnen: %s", rt.Config.Listen)
	}
}

func TestCorruptSettingsFallBackToConfigYml(t *testing.T) {
	configPath, stateDir, _, _ := writeUpgradeFixture(t)
	silent := slog.New(slog.NewTextHandler(io.Discard, nil))
	if _, err := LoadRuntime(configPath, silent); err != nil {
		t.Fatal(err)
	}
	bad := filepath.Join(stateDir, SettingsFile)
	if err := os.WriteFile(bad, []byte(":::: geen yaml"), 0o600); err != nil {
		t.Fatal(err)
	}
	rt, err := LoadRuntime(configPath, silent)
	if err != nil {
		t.Fatalf("moet starten op config.yml: %v", err)
	}
	if rt.Config.Listen != "127.0.0.1:9090" || rt.Config.Auth.ClientSecret != "het-geheim" {
		t.Fatalf("terugval mislukt: %+v", rt.Config)
	}
}

func TestInvalidSettingsValuesFallBack(t *testing.T) {
	configPath, stateDir, _, _ := writeUpgradeFixture(t)
	silent := slog.New(slog.NewTextHandler(io.Discard, nil))
	if _, err := LoadRuntime(configPath, silent); err != nil {
		t.Fatal(err)
	}
	st, err := LoadSettings(stateDir)
	if err != nil {
		t.Fatal(err)
	}
	st.BaseURL = ptr("niet-een-url")
	if err := SaveSettings(stateDir, *st); err != nil {
		t.Fatal(err)
	}
	rt, err := LoadRuntime(configPath, silent)
	if err != nil {
		t.Fatalf("ongeldige settings mogen de start niet breken: %v", err)
	}
	if rt.Config.BaseURL != "https://git.example.test" {
		t.Fatalf("terugval base_url: %s", rt.Config.BaseURL)
	}
}

func TestSecretFileFallbackWhenSettingsHaveNoSecret(t *testing.T) {
	configPath, stateDir, secretPath, _ := writeUpgradeFixture(t)
	silent := slog.New(slog.NewTextHandler(io.Discard, nil))
	if _, err := LoadRuntime(configPath, silent); err != nil {
		t.Fatal(err)
	}
	st, err := LoadSettings(stateDir)
	if err != nil {
		t.Fatal(err)
	}
	st.Auth.ClientSecret = nil
	if err := SaveSettings(stateDir, *st); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(secretPath, []byte("nieuw-geheim\n"), 0o600); err != nil {
		t.Fatal(err)
	}
	rt, err := LoadRuntime(configPath, silent)
	if err != nil {
		t.Fatal(err)
	}
	if rt.Config.Auth.ClientSecret != "nieuw-geheim" {
		t.Fatalf("bestand als terugval: %q", rt.Config.Auth.ClientSecret)
	}
}

func TestLoadRuntimeSameAsLoadWhenNoSettingsYet(t *testing.T) {
	// Als settings.yml niet geschreven kan worden, moet LoadRuntime
	// nog steeds hetzelfde resultaat geven als Load (ook als root
	// draait, waar chmod op een map niet tegenhoudt).
	configPath, stateDir, _, _ := writeUpgradeFixture(t)
	if err := os.RemoveAll(stateDir); err != nil {
		t.Fatal(err)
	}
	if err := os.WriteFile(stateDir, []byte("geen map"), 0o600); err != nil {
		t.Fatal(err)
	}
	silent := slog.New(slog.NewTextHandler(io.Discard, nil))
	want, err := Load(configPath)
	if err != nil {
		t.Fatal(err)
	}
	rt, err := LoadRuntime(configPath, silent)
	if err != nil {
		t.Fatal(err)
	}
	if rt.Imported {
		t.Fatal("import hoort te falen als state_path geen schrijfbare map is")
	}
	if rt.Config.Listen != want.Listen || rt.Config.Auth.ClientSecret != want.Auth.ClientSecret || rt.Config.BaseURL != want.BaseURL {
		t.Fatalf("LoadRuntime != Load: %+v vs %+v", rt.Config, want)
	}
}

func TestMergeUpdateKeepsSecretWhenLeftBlank(t *testing.T) {
	cur := Config{BaseURL: "https://git.example.test", Listen: "127.0.0.1:8080", StatePath: t.TempDir()}
	cur.Auth = Auth{Mode: "oauth", ClientID: "id", ClientSecret: "old-secret", BaseURL: "https://auth.example"}
	cur.applyDefaults()
	next, saved := MergeUpdate(cur, Persisted{
		Listen: ptr("127.0.0.1:8081"),
		Auth:   &PersistedAuth{ClientSecret: ptr("")},
	})
	if next.Listen != "127.0.0.1:8081" {
		t.Fatal(next.Listen)
	}
	if next.Auth.ClientSecret != "old-secret" {
		t.Fatalf("geheim gewist: %q", next.Auth.ClientSecret)
	}
	if saved.Auth == nil || saved.Auth.ClientSecret == nil || *saved.Auth.ClientSecret != "old-secret" {
		t.Fatal("opgeslagen geheim ontbreekt")
	}
}

func TestImportIsIdempotentWithMarkerOnly(t *testing.T) {
	configPath, stateDir, _, _ := writeUpgradeFixture(t)
	if err := os.WriteFile(filepath.Join(stateDir, ImportMarker), nil, 0o640); err != nil {
		t.Fatal(err)
	}
	silent := slog.New(slog.NewTextHandler(io.Discard, nil))
	rt, err := LoadRuntime(configPath, silent)
	if err != nil {
		t.Fatal(err)
	}
	if rt.Imported {
		t.Fatal("marker zonder settings.yml: niet opnieuw importeren")
	}
	if _, err := os.Stat(filepath.Join(stateDir, SettingsFile)); err == nil {
		t.Fatal("er had geen settings.yml mogen ontstaan")
	}
	if !strings.HasPrefix(rt.Config.Listen, "127.0.0.1:9090") {
		t.Fatalf("config.yml als terugval: %s", rt.Config.Listen)
	}
}
