package scripts

import (
	"context"
	"net/http"
	"net/http/httptest"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"sync"
	"testing"
	"time"
)

func TestSelfUpdateWaitsForOwnSHA(t *testing.T) {
	if _, err := exec.LookPath("bash"); err != nil {
		t.Skip("bash ontbreekt")
	}
	if _, err := exec.LookPath("curl"); err != nil {
		t.Skip("curl ontbreekt")
	}
	if _, err := exec.LookPath("jq"); err != nil {
		t.Skip("jq ontbreekt")
	}
	script := filepath.Join("..", "scripts", "wait-self-update.sh")
	sha := "0123456789abcdef0123456789abcdef01234567"
	other := "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"

	t.Run("ok na running", func(t *testing.T) {
		var posts int
		var gets int
		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if r.URL.Path != "/api/v1/admin/self-update" {
				http.NotFound(w, r)
				return
			}
			if r.Method == http.MethodPost {
				posts++
				w.WriteHeader(http.StatusAccepted)
				_, _ = w.Write([]byte(`{"status":"accepted","ref":"` + sha + `"}`))
				return
			}
			gets++
			w.Header().Set("Content-Type", "application/json")
			if gets < 3 {
				_, _ = w.Write([]byte(`{"running":1,"status":"running","sha":"` + sha + `","result":"running","log":"","update":{"sha":"` + sha + `","result":"running"}}`))
				return
			}
			// log bevat een andere status. Alleen het veld ervoor telt.
			_, _ = w.Write([]byte(`{"running":0,"status":"ok","sha":"` + sha + `","result":"ok","log":"zie \"status\":\"failed\"","update":{"sha":"` + sha + `","result":"ok"}}`))
		}))
		t.Cleanup(srv.Close)
		out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0")
		if err != nil {
			t.Fatalf("wacht: %v %s", err, out)
		}
		if posts != 0 || gets < 3 || !strings.Contains(out, "self-update ok voor "+sha) {
			t.Fatalf("posts %d gets %d\n%s", posts, gets, out)
		}
	})

	t.Run("andere sha telt niet", func(t *testing.T) {
		var gets int
		srv := statusServer(t, func(gets int) string {
			if gets == 1 {
				return `{"running":0,"status":"ok","sha":"` + other + `","result":"ok","log":""}`
			}
			return `{"running":0,"status":"ok","sha":"` + sha + `","result":"ok","log":""}`
		}, &gets)
		out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0")
		if err != nil {
			t.Fatalf("wacht: %v %s", err, out)
		}
		if gets < 2 {
			t.Fatalf("stops bij de vorige sha, gets %d\n%s", gets, out)
		}
	})

	t.Run("log staat vooraan", func(t *testing.T) {
		var gets int
		// De live response begint met log. Daarin staat een nep-status en een nep-sha.
		running := `{"log":"Self-update naar iets\n\"status\":\"ok\"\n\"sha\":\"` + sha + `\"","running":1,"status":"running","sha":"` + sha + `","result":"running"}`
		done := `{"log":"klaar\n\"status\":\"ok\"\n\"sha\":\"ffffffffffffffffffffffffffffffffffffffff\"","running":0,"status":"ok","sha":"` + sha + `","result":"ok"}`
		if !strings.HasPrefix(running, `{"log":`) || !strings.HasPrefix(done, `{"log":`) {
			t.Fatal("log hoort de eerste key te zijn")
		}
		srv := statusServer(t, func(n int) string {
			if n == 1 {
				return running
			}
			return done
		}, &gets)
		out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0")
		if err != nil {
			t.Fatalf("wacht: %v %s", err, out)
		}
		if gets < 2 || !strings.Contains(out, "self-update ok voor "+sha) {
			t.Fatalf("nep-status in log telde mee, gets %d\n%s", gets, out)
		}
	})

	t.Run("failed faalt meteen", func(t *testing.T) {
		srv := statusServer(t, func(int) string {
			return `{"running":0,"status":"failed","sha":"` + sha + `","result":"failed","log":"exit 1"}`
		}, nil)
		out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0")
		if err == nil || !strings.Contains(out, "Self-update mislukt: "+sha) {
			t.Fatalf("failed hoort te stoppen: %v %s", err, out)
		}
	})

	t.Run("timeout", func(t *testing.T) {
		srv := statusServer(t, func(int) string {
			return `{"running":1,"status":"running","sha":"` + sha + `","result":"running","log":""}`
		}, nil)
		out, err := runSelfUpdate(t, script, srv.URL, sha, "0", "0")
		if err == nil || !strings.Contains(out, "Self-update timeout na 0s") {
			t.Fatalf("timeout: %v %s", err, out)
		}
	})

	t.Run("korte storing tijdens herstart", func(t *testing.T) {
		var gets int
		var mu sync.Mutex
		srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if r.Method == http.MethodPost {
				w.WriteHeader(http.StatusAccepted)
				_, _ = w.Write([]byte(`{"status":"accepted"}`))
				return
			}
			mu.Lock()
			gets++
			n := gets
			mu.Unlock()
			if n == 1 {
				hj, ok := w.(http.Hijacker)
				if !ok {
					http.Error(w, "down", http.StatusBadGateway)
					return
				}
				conn, _, err := hj.Hijack()
				if err != nil {
					return
				}
				_ = conn.Close()
				return
			}
			_, _ = w.Write([]byte(`{"running":0,"status":"ok","sha":"` + sha + `","result":"ok","log":""}`))
		}))
		t.Cleanup(srv.Close)
		out, err := runSelfUpdate(t, script, srv.URL, sha, "30", "0")
		if err != nil {
			t.Fatalf("na herstart: %v %s", err, out)
		}
	})
}

func TestSelfUpdatePostsWithoutWaiting(t *testing.T) {
	if _, err := exec.LookPath("bash"); err != nil {
		t.Skip("bash ontbreekt")
	}
	if _, err := exec.LookPath("curl"); err != nil {
		t.Skip("curl ontbreekt")
	}
	script := filepath.Join("..", "scripts", "self-update.sh")
	sha := "0123456789abcdef0123456789abcdef01234567"
	var posts, gets int
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/api/v1/admin/self-update" {
			http.NotFound(w, r)
			return
		}
		if r.Method == http.MethodPost {
			posts++
			w.WriteHeader(http.StatusAccepted)
			_, _ = w.Write([]byte(`{"status":"accepted","ref":"` + sha + `"}`))
			return
		}
		gets++
		select {}
	}))
	t.Cleanup(srv.Close)
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	t.Cleanup(cancel)
	cmd := exec.CommandContext(ctx, "bash", script)
	cmd.Env = append(os.Environ(),
		"CI_API_URL="+srv.URL+"/api/v1",
		"BLUEGIT_UPDATE_TOKEN=test-token",
		"CI_COMMIT_SHA="+sha,
	)
	out, err := cmd.CombinedOutput()
	if err != nil {
		t.Fatalf("post: %v %s", err, out)
	}
	if posts != 1 || gets != 0 || !strings.Contains(string(out), "Self-update gestart: "+sha) {
		t.Fatalf("posts %d gets %d\n%s", posts, gets, out)
	}
	raw, err := os.ReadFile(script)
	if err != nil {
		t.Fatal(err)
	}
	if strings.Contains(string(raw), "jq") || strings.Contains(string(raw), "while true") {
		t.Fatal("self-update.sh polt nog")
	}
}

func statusServer(t *testing.T, body func(gets int) string, gets *int) *httptest.Server {
	t.Helper()
	var n int
	var mu sync.Mutex
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/api/v1/admin/self-update" {
			http.NotFound(w, r)
			return
		}
		if r.Method == http.MethodPost {
			w.WriteHeader(http.StatusAccepted)
			_, _ = w.Write([]byte(`{"status":"accepted"}`))
			return
		}
		mu.Lock()
		n++
		cur := n
		if gets != nil {
			*gets = n
		}
		mu.Unlock()
		w.Header().Set("Content-Type", "application/json")
		_, _ = w.Write([]byte(body(cur)))
	}))
	t.Cleanup(srv.Close)
	return srv
}

func runSelfUpdate(t *testing.T, script, base, sha, timeout, interval string) (string, error) {
	t.Helper()
	cmd := exec.Command("bash", script)
	cmd.Env = append(os.Environ(),
		"CI_API_URL="+base+"/api/v1",
		"BLUEGIT_UPDATE_TOKEN=test-token",
		"CI_COMMIT_SHA="+sha,
		"SELF_UPDATE_TIMEOUT="+timeout,
		"SELF_UPDATE_INTERVAL="+interval,
	)
	out, err := cmd.CombinedOutput()
	return string(out), err
}
