package server

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

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

type boxMail struct {
	mu                  sync.Mutex
	n                   int
	user, subject, html string
	wait                chan struct{}
}

func (b *boxMail) SendEmail(ctx context.Context, username, subject, html string) error {
	b.mu.Lock()
	b.n++
	b.user, b.subject, b.html = username, subject, html
	b.mu.Unlock()
	if b.wait != nil {
		b.wait <- struct{}{}
	}
	return nil
}

func TestFailureMailUsesRecipientLanguage(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"},
		Git:  config.Git{Binary: "git", DefaultBranch: "master"},
	}
	wait := make(chan struct{}, 1)
	box := &boxMail{wait: wait}
	srv := &Server{Cfg: cfg, Store: st, Auth: auth.Dev{Username: "tim", AuthID: 1}, Dev: true, Git: "git", Mail: box}
	ts := httptest.NewServer(srv.Handler())
	t.Cleanup(ts.Close)
	res, err := ts.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)
	}
	if err := st.SetLanguage(ctx, user.ID, "nl"); err != nil {
		t.Fatal(err)
	}
	repo, err := st.CreateRepo(ctx, "user", user.ID, "mail", "", "master", "private")
	if err != nil {
		t.Fatal(err)
	}
	id, err := st.CreatePipeline(ctx, repo.ID, "abc", "refs/tags/v0.0.26", "push", "tim", "tag die faalt", []store.NewJob{
		{Name: "hardjob", Stage: "test", Script: "exit 1"},
		{Name: "softjob", Stage: "test", Script: "exit 1", AllowFailure: true},
	})
	if err != nil {
		t.Fatal(err)
	}
	jobs, _ := st.JobsByPipeline(ctx, id)
	for _, j := range jobs {
		if err := st.FinishJob(ctx, j.ID, "failed", ""); err != nil {
			t.Fatal(err)
		}
	}
	srv.Dispatch(repo.ID, webhook.Event{Type: webhook.EventPipelineSuccess, PipelineID: strconv.FormatInt(id, 10)})
	if box.n != 0 {
		t.Fatalf("succes mailde %d", box.n)
	}
	srv.Dispatch(repo.ID, webhook.Event{Type: webhook.EventPipelineFailure, PipelineID: strconv.FormatInt(id, 10)})
	select {
	case <-wait:
	case <-time.After(2 * time.Second):
		t.Fatal("geen mail")
	}
	box.mu.Lock()
	defer box.mu.Unlock()
	if box.user != "tim" || !strings.Contains(box.subject, "mislukt") || !strings.Contains(box.subject, "tim/mail") {
		t.Fatalf("onderwerp %s voor %s", box.subject, box.user)
	}
	for _, want := range []string{"v0.0.26", "hardjob", "Mislukte jobs", "/-/pipelines/" + strconv.FormatInt(id, 10), "/jobs/"} {
		if !strings.Contains(box.html, want) {
			t.Errorf("html mist %q\n%s", want, box.html)
		}
	}
	if strings.Contains(box.html, "softjob") {
		t.Fatalf("allow_failure hoort niet in de mail:\n%s", box.html)
	}
}
