package e2e

import (
	"context"
	"io"
	"net/http"
	"os/exec"
	"strings"
	"testing"

	"github.com/barerepo/server/internal/store"
)

// get reads a page and returns its status, content type and body.
func get(t *testing.T, url string) (int, string, string) {
	t.Helper()
	resp, err := http.Get(url)
	if err != nil {
		t.Fatal(err)
	}
	defer resp.Body.Close()
	body, _ := io.ReadAll(resp.Body)
	return resp.StatusCode, resp.Header.Get("Content-Type"), string(body)
}

// Chapter 39.4 tells a reader to paste these urls into a feed reader, so all three must answer.
func TestEveryPublicFeedInChapter39Answers(t *testing.T) {
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git is not installed")
	}
	ctx := context.Background()
	in := newInstance(t)
	john := in.account("john")
	seed(t, in, john, "john", "johnbot")

	if err := in.db.Record(ctx, store.Event{Kind: store.ThreadOpened, Actor: "lisa",
		Repo: "john/johnbot", Number: 47, Title: "the log page is slow"}); err != nil {
		t.Fatal(err)
	}

	for _, path := range []string{"/john.atom", "/john/johnbot.atom", "/john/johnbot/threads.atom"} {
		code, ctype, body := get(t, in.http.URL+path)
		if code != http.StatusOK {
			t.Errorf("%s answered %d, and chapter 39.4 hands this url out", path, code)
			continue
		}
		if !strings.HasPrefix(ctype, "application/atom+xml") {
			t.Errorf("%s came back as %q, which no feed reader will take", path, ctype)
		}
		if !strings.Contains(body, "<feed") {
			t.Errorf("%s is not a feed:\n%s", path, body)
		}
	}
}

// The threads feed is the discussion alone, so a push must not appear in it. 19.5.
func TestTheThreadsFeedCarriesThreadsAndNotPushes(t *testing.T) {
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git is not installed")
	}
	ctx := context.Background()
	in := newInstance(t)
	john := in.account("john")
	seed(t, in, john, "john", "johnbot")

	if err := in.db.Record(ctx, store.Event{Kind: store.ThreadOpened, Actor: "lisa",
		Repo: "john/johnbot", Number: 47, Title: "the log page is slow"}); err != nil {
		t.Fatal(err)
	}

	_, _, repoFeed := get(t, in.http.URL+"/john/johnbot.atom")
	if !strings.Contains(repoFeed, "pushed") {
		t.Errorf("the repository feed lost the push:\n%s", repoFeed)
	}
	if !strings.Contains(repoFeed, "opened thread 47") {
		t.Errorf("the repository feed lost the thread:\n%s", repoFeed)
	}

	_, _, threadFeed := get(t, in.http.URL+"/john/johnbot/threads.atom")
	if !strings.Contains(threadFeed, "opened thread 47") {
		t.Errorf("the threads feed lost the thread:\n%s", threadFeed)
	}
	if strings.Contains(threadFeed, "pushed") {
		t.Errorf("the threads feed carried a push:\n%s", threadFeed)
	}
}

// A private repository has no public feed, and a 404 is what a stranger gets. 19.5.
func TestAPrivateRepositoryHasNoPublicFeed(t *testing.T) {
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git is not installed")
	}
	in := newInstance(t)
	john := in.account("john")
	work := t.TempDir()
	run(t, work, "git", "init", "-q", "-b", "master")
	write(t, work, "config.go", "package main\n")
	write(t, work, ".barerepo/config", "[repo]\nvisibility = \"private\"\n")
	run(t, work, "git", "add", "-A")
	run(t, work, "git", "commit", "-qm", "first")
	run(t, work, "git", "push", "-q", in.url(john, "/john/secret"), "master")

	for _, path := range []string{"/john/secret.atom", "/john/secret/threads.atom"} {
		if code, _, _ := get(t, in.http.URL+path); code != http.StatusNotFound {
			t.Errorf("%s answered %d to a stranger, wanted 404", path, code)
		}
	}
}

// The inbox page links to its own feed, and a link that can only fail is not a link. Chapter 19.5.
func TestTheInboxFeedOpensForTheReaderLookingAtIt(t *testing.T) {
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git is not installed")
	}
	in := newInstance(t)
	john := in.account("john")
	seed(t, in, john, "john", "johnbot")

	// A feed reader has no session and must still be refused without a token.
	if code, _, _ := get(t, in.http.URL+"/inbox.atom"); code != http.StatusUnauthorized {
		t.Errorf("an anonymous request for the inbox feed answered %d", code)
	}
	if code, _, _ := get(t, in.http.URL+"/inbox.atom?token=ft_live_nonsense"); code != http.StatusUnauthorized {
		t.Errorf("a wrong token answered %d", code)
	}

	session, err := in.db.NewSession(t.Context(), "john")
	if err != nil {
		t.Fatal(err)
	}
	req, err := http.NewRequest(http.MethodGet, in.http.URL+"/inbox.atom", nil)
	if err != nil {
		t.Fatal(err)
	}
	req.AddCookie(&http.Cookie{Name: "barerepo_session", Value: session})
	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		t.Fatal(err)
	}
	defer resp.Body.Close()
	body := readAll(t, resp)
	if resp.StatusCode != http.StatusOK {
		t.Fatalf("the reader's own inbox feed answered %d:\n%s", resp.StatusCode, body)
	}
	if !strings.Contains(body, "barerepo inbox for john") {
		t.Errorf("the feed is not john's:\n%s", body)
	}
}