package repo_test

import (
	"bytes"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"

	"go.sudomsg.com/gopkgserver/repo"
)

func TestMetaExec(t *testing.T) {
	t.Parallel()

	meta, err := repo.NewMeta()
	if err != nil {
		t.Fatalf("failed to create Meta: %v", err)
	}

	pkg := "example.com/foo"
	r := repo.Repo{
		VCS:        "git",
		Repository: "https://github.com/user/foo",
		Home:       "https://github.com/user/foo",
		Directory:  "https://github.com/user/foo/tree/master{/dir}",
		File:       "https://github.com/user/foo/blob/master{/dir}/{file}#L{line}",
	}

	html, err := meta.Exec(pkg, r)
	if err != nil {
		t.Fatalf("Exec failed: %v", err)
	}

	htmlStr := string(html)
	if !strings.Contains(htmlStr, `<meta name="go-import"`) {
		t.Fatalf("missing go-import meta tag: %q", htmlStr)
	}
	if !strings.Contains(htmlStr, `<meta name="go-source"`) {
		t.Fatalf("missing go-source meta tag: %q", htmlStr)
	}
	if !strings.Contains(htmlStr, pkg) {
		t.Fatalf("missing package name in output: %q", htmlStr)
	}
}

func TestServeHTTP(t *testing.T) {
	t.Parallel()

	repos := map[string]repo.Repo{
		"example.com/foo": {
			VCS:        "git",
			Repository: "https://github.com/user/foo",
			Home:       "https://github.com/user/foo",
			Directory:  "https://github.com/user/foo/tree/master{/dir}",
			File:       "https://github.com/user/foo/blob/master{/dir}/{file}#L{line}",
		},
	}

	t.Run("returns meta tag for go-get=1", func(t *testing.T) {
		t.Parallel()

		handler, err := repo.New(repos)
		if err != nil {
			t.Fatalf("failed to create handler: %v", err)
		}

		req := httptest.NewRequest(http.MethodGet, "http://example.com/foo?go-get=1", nil)
		w := httptest.NewRecorder()

		handler.ServeHTTP(w, req)

		resp := w.Result()
		defer resp.Body.Close()

		if resp.StatusCode != http.StatusOK {
			t.Fatalf("expected %v, got %v", http.StatusOK, resp.StatusCode)
		}

		var buf bytes.Buffer
		buf.ReadFrom(resp.Body)
		body := buf.String()

		if !strings.Contains(body, `<meta name="go-import"`) {
			t.Fatalf("expected go-import tag in body, got: %v", body)
		}
	})

	t.Run("redirects to pkg.go.dev otherwise", func(t *testing.T) {
		t.Parallel()

		handler, err := repo.New(repos)
		if err != nil {
			t.Fatalf("failed to create handler: %v", err)
		}

		req := httptest.NewRequest(http.MethodGet, "http://example.com/foo", nil)
		w := httptest.NewRecorder()

		handler.ServeHTTP(w, req)

		resp := w.Result()
		defer resp.Body.Close()

		if resp.StatusCode != http.StatusFound {
			t.Fatalf("expected %v, got %v", http.StatusFound, resp.StatusCode)
		}
		loc, err := resp.Location()
		if err != nil {
			t.Fatalf("Invalid redirect location: %v", err)
		}

		if !strings.HasPrefix(loc.String(), "https://pkg.go.dev/example.com/foo") {
			t.Fatalf("unexpected redirect location: %v", loc)
		}
	})

	t.Run("returns 404 for unknown path", func(t *testing.T) {
		t.Parallel()

		handler, err := repo.New(repos)
		if err != nil {
			t.Fatalf("failed to create handler: %v", err)
		}

		w := httptest.NewRecorder()
		req := httptest.NewRequest(http.MethodGet, "http://example.com/bar", nil)
		handler.ServeHTTP(w, req)

		resp := w.Result()
		defer resp.Body.Close()

		if resp.StatusCode != http.StatusNotFound {
			t.Fatalf("expected %v, got %v", http.StatusNotFound, resp.StatusCode)
		}
	})
}