package server

import (
	"context"
	"net/http"
	"net/http/cookiejar"
	"net/http/httptest"
	"path/filepath"
	"strconv"
	"strings"
	"testing"

	"gitlab.com/Timfa/bluegit/internal/auth"
	"gitlab.com/Timfa/bluegit/internal/config"
	"gitlab.com/Timfa/bluegit/internal/store"
)

func TestRankQueueSkipsWaitersAndRunning(t *testing.T) {
	first := pipeSnap{Jobs: []store.Job{
		{ID: 1, Name: "lint", Stage: "test", Status: "queued", Position: 0},
		{ID: 2, Name: "unit", Stage: "test", Status: "queued", Position: 1},
		{ID: 3, Name: "ship", Stage: "deploy", Status: "queued", Position: 2},
	}}
	ranks := rankQueue([]pipeSnap{first})
	if ranks[1] != 1 || ranks[2] != 2 || ranks[3] != 0 {
		t.Fatalf("zelfde stage vóór deploy: %#v", ranks)
	}
	busy := []pipeSnap{{Jobs: []store.Job{
		{ID: 10, RepoID: 1, Name: "hold", Stage: "test", Status: "running", ResourceGroup: "db"},
		{ID: 11, RepoID: 1, Name: "wait", Stage: "test", Status: "queued", ResourceGroup: "db"},
		{ID: 12, RepoID: 1, Name: "other", Stage: "test", Status: "queued"},
	}}}
	ranks = rankQueue(busy)
	if ranks[10] != 0 || ranks[11] != 0 || ranks[12] != 1 {
		t.Fatalf("running vult een slot, resourcegroep telt niet mee: %#v", ranks)
	}
	later := rankQueue([]pipeSnap{
		{Jobs: []store.Job{{ID: 4, Name: "old", Stage: "test", Status: "queued"}}},
		{Jobs: []store.Job{{ID: 5, Name: "new", Stage: "test", Status: "queued"}}},
	})
	if later[4] != 1 || later[5] != 2 {
		t.Fatalf("oudere pipeline eerst: %#v", later)
	}
}

func TestPipelineLiveQueue(t *testing.T) {
	storage := t.TempDir()
	st, err := store.Open(filepath.Join(storage, "bluegit.db"), bytes32())
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = st.Close() })
	cfg := config.Config{
		BaseURL: "http://127.0.0.1:9", Listen: "127.0.0.1:0", StoragePath: storage,
		Auth: config.Auth{Mode: "dev", DevUser: "tim", DevAuthID: 1, UserAgent: "test", BaseURL: "https://auth.timfalken.com"},
		Git:  config.Git{Binary: "git", DefaultBranch: "master"},
		CI:   config.CI{Concurrency: 1},
	}
	srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git"}
	ts := httptest.NewServer(srv.Handler())
	t.Cleanup(ts.Close)
	jar, _ := cookiejar.New(nil)
	client := &http.Client{Jar: jar}
	res, err := client.Get(ts.URL + "/login")
	if err != nil {
		t.Fatal(err)
	}
	_ = res.Body.Close()
	ctx := context.Background()
	user, err := st.UserByUsername(ctx, "tim")
	if err != nil {
		t.Fatal(err)
	}
	repo, err := st.CreateRepo(ctx, "user", user.ID, "demo", "", "master", "private")
	if err != nil {
		t.Fatal(err)
	}
	sha := "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
	id, err := st.CreatePipeline(ctx, repo.ID, sha, "refs/heads/master", "push", "tim", "wachtrij", []store.NewJob{
		{Name: "lint", Stage: "test", Script: "exit 0"},
		{Name: "unit", Stage: "test", Script: "exit 0"},
		{Name: "ship", Stage: "deploy", Script: "exit 0"},
	})
	if err != nil {
		t.Fatal(err)
	}
	jobs, err := st.JobsByPipeline(ctx, id)
	if err != nil {
		t.Fatal(err)
	}
	var lint, unit int64
	for _, j := range jobs {
		switch j.Name {
		case "lint":
			lint = j.ID
		case "unit":
			unit = j.ID
		}
	}
	res, err = client.Get(ts.URL + "/tim/demo/-/pipelines")
	if err != nil {
		t.Fatal(err)
	}
	page := read(t, res)
	for _, want := range []string{
		"In queue (#1)", "In queue (#2)", `data-live-on="1"`, `data-pipe="` + strconv.FormatInt(id, 10) + `"`,
	} {
		if !strings.Contains(page, want) {
			t.Errorf("lijst mist %q", want)
		}
	}
	if strings.Contains(page, "In queue (#3)") {
		t.Fatal("deploy wacht op test en hoort geen plek te hebben")
	}
	req, _ := http.NewRequest(http.MethodGet, ts.URL+"/tim/demo/-/pipelines", nil)
	req.Header.Set("Accept", "application/json")
	res, err = client.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	body := read(t, res)
	if !strings.Contains(body, `"active":true`) || !strings.Contains(body, `"queue":"In queue (#2)"`) {
		t.Fatalf("live json:\n%s", body)
	}
	res, err = client.Get(ts.URL + "/tim/demo/-/pipelines/" + strconv.FormatInt(id, 10))
	if err != nil {
		t.Fatal(err)
	}
	detail := read(t, res)
	if !strings.Contains(detail, "In queue (#1)") || !strings.Contains(detail, `data-live-on="1"`) {
		t.Fatalf("detail:\n%s", detail)
	}
	res, err = client.Get(ts.URL + "/tim/demo/-/pipelines/" + strconv.FormatInt(id, 10) + "/jobs/" + strconv.FormatInt(lint, 10))
	if err != nil {
		t.Fatal(err)
	}
	jobPage := read(t, res)
	if !strings.Contains(jobPage, "In queue (#1)") {
		t.Fatalf("job:\n%s", jobPage)
	}
	res, err = client.Get(ts.URL + "/tim/demo/-/pipelines/" + strconv.FormatInt(id, 10) + "/jobs/" + strconv.FormatInt(unit, 10))
	if err != nil {
		t.Fatal(err)
	}
	if unitPage := read(t, res); !strings.Contains(unitPage, "In queue (#2)") {
		t.Fatalf("tweede job:\n%s", unitPage)
	}
	for _, j := range jobs {
		if err := st.FinishJob(ctx, j.ID, "success", ""); err != nil {
			t.Fatal(err)
		}
	}
	if _, err := st.RefreshPipelineStatus(ctx, id); err != nil {
		t.Fatal(err)
	}
	req, _ = http.NewRequest(http.MethodGet, ts.URL+"/tim/demo/-/pipelines", nil)
	req.Header.Set("Accept", "application/json")
	res, err = client.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	done := read(t, res)
	if !strings.Contains(done, `"active":false`) || strings.Contains(done, "In queue") {
		t.Fatalf("stilgevallen:\n%s", done)
	}
}
