package sshd

import (
	"bytes"
	"context"
	"fmt"
	"io"
	"log/slog"
	"net"
	"os"
	"os/exec"
	"path/filepath"
	"strconv"
	"strings"
	"testing"
	"time"

	"gitlab.com/Timfa/bluegit/internal/gitrepo"
	"gitlab.com/Timfa/bluegit/internal/store"
	"golang.org/x/crypto/ssh"
)

func TestOpenSSHClonePush(t *testing.T) {
	if _, err := exec.LookPath("git"); err != nil {
		t.Skip("git ontbreekt")
	}
	sshBin := testSSH(t)
	clientKex := sshQuery(t, sshBin, "kex")
	supportsMLKEM := strings.Contains(clientKex, kexMLKEM) && kexSupported(kexMLKEM)
	version := sshVersion(t, sshBin)

	storage := t.TempDir()
	st := openSSHStore(t)
	ctx := context.Background()
	user, err := st.UpsertUser(ctx, 1, "tim", "", false)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := st.CreateRepo(ctx, "user", user.ID, "demo", "", "master", "private"); err != nil {
		t.Fatal(err)
	}
	repoDir := gitrepo.Dir(storage, "tim", "demo")
	git(t, "", "init", "--bare", "--initial-branch", "master", repoDir)

	key := filepath.Join(t.TempDir(), "id_ed25519")
	if out, err := exec.Command("ssh-keygen", "-t", "ed25519", "-f", key, "-N", "", "-q").CombinedOutput(); err != nil {
		t.Fatalf("ssh-keygen: %v %s", err, out)
	}
	pubLine, err := os.ReadFile(key + ".pub")
	if err != nil {
		t.Fatal(err)
	}
	pub, _, _, _, err := ssh.ParseAuthorizedKey(bytes.TrimSpace(pubLine))
	if err != nil {
		t.Fatal(err)
	}
	stored := strings.TrimSpace(string(ssh.MarshalAuthorizedKey(pub)))
	if err := st.AddSSHKey(ctx, user.ID, "laptop", stored, ssh.FingerprintSHA256(pub)); err != nil {
		t.Fatal(err)
	}

	log := slog.New(slog.NewTextHandler(io.Discard, nil))
	base := &Server{Store: st, GitBin: "git", Storage: storage, Log: log}

	if opensshMajor(version) >= 10 {
		old := *base
		old.kex = []string{kexCurve, kexLibSSH}
		addr := startSSH(t, &old)
		out := sshProbe(t, sshBin, key, addr)
		if !strings.Contains(out, "post-quantum") {
			t.Fatalf("OpenSSH 10 hoort te waarschuwen zonder pq-kex:\n%s", out)
		}
		if !strings.Contains(out, "kex: algorithm: curve25519-sha256") {
			t.Fatalf("fallback hoort curve25519 te zijn:\n%s", out)
		}
	}

	addr := startSSH(t, base)
	out := sshProbe(t, sshBin, key, addr)
	if supportsMLKEM {
		if strings.Contains(out, "post-quantum") {
			t.Fatalf("waarschuwing bleef staan:\n%s", out)
		}
		if !strings.Contains(out, "kex: algorithm: "+kexMLKEM) {
			t.Fatalf("geen mlkem:\n%s", out)
		}
	} else if !strings.Contains(out, "kex: algorithm: curve25519-sha256") {
		t.Fatalf("oude client hoort op curve25519 te vallen:\n%s", out)
	}

	work := filepath.Join(t.TempDir(), "work")
	remote := fmt.Sprintf("ssh://git@%s/tim/demo.git", addr)
	gitSSH(t, sshBin, key, addr, "", "init", "-b", "master", work)
	if err := os.WriteFile(filepath.Join(work, "README"), []byte("hallo\n"), 0o644); err != nil {
		t.Fatal(err)
	}
	gitSSH(t, sshBin, key, addr, work, "add", "README")
	gitSSH(t, sshBin, key, addr, work, "-c", "user.email=tim@users.git.timfalken.com", "-c", "user.name=tim", "commit", "-m", "een")
	gitSSH(t, sshBin, key, addr, work, "remote", "add", "origin", remote)
	gitSSH(t, sshBin, key, addr, work, "push", "-u", "origin", "HEAD:master")

	clone := filepath.Join(t.TempDir(), "clone")
	gitSSH(t, sshBin, key, addr, "", "clone", remote, clone)
	body, err := os.ReadFile(filepath.Join(clone, "README"))
	if err != nil || string(body) != "hallo\n" {
		t.Fatalf("clone %q %v", body, err)
	}
}

func testSSH(t *testing.T) string {
	t.Helper()
	if bin := os.Getenv("BLUEGIT_TEST_SSH"); bin != "" {
		if _, err := os.Stat(bin); err != nil {
			t.Fatalf("BLUEGIT_TEST_SSH: %v", err)
		}
		return bin
	}
	bin, err := exec.LookPath("ssh")
	if err != nil {
		t.Skip("ssh ontbreekt")
	}
	return bin
}

func sshVersion(t *testing.T, bin string) string {
	t.Helper()
	cmd := exec.Command(bin, "-V")
	out, _ := cmd.CombinedOutput()
	line := strings.TrimSpace(string(out))
	if i := strings.IndexByte(line, ' '); i > 0 {
		return line[:i]
	}
	return line
}

func opensshMajor(version string) int {
	rest, ok := strings.CutPrefix(version, "OpenSSH_")
	if !ok {
		return 0
	}
	major, _, _ := strings.Cut(rest, ".")
	n, err := strconv.Atoi(major)
	if err != nil {
		return 0
	}
	return n
}

func sshQuery(t *testing.T, bin, kind string) string {
	t.Helper()
	out, err := exec.Command(bin, "-Q", kind).CombinedOutput()
	if err != nil {
		t.Fatalf("ssh -Q %s: %v %s", kind, err, out)
	}
	return string(out)
}

func openSSHStore(t *testing.T) *store.Store {
	t.Helper()
	key := make([]byte, 32)
	for i := range key {
		key[i] = byte(i + 1)
	}
	st, err := store.Open(filepath.Join(t.TempDir(), "bluegit.db"), key)
	if err != nil {
		t.Fatal(err)
	}
	t.Cleanup(func() { _ = st.Close() })
	return st
}

func startSSH(t *testing.T, srv *Server) string {
	t.Helper()
	ln, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatal(err)
	}
	addr := ln.Addr().String()
	_ = ln.Close()
	srv.Listen = addr
	srv.HostKey = filepath.Join(t.TempDir(), "hostkey")
	ctx, cancel := context.WithCancel(context.Background())
	t.Cleanup(cancel)
	go func() { _ = srv.Run(ctx) }()
	deadline := time.Now().Add(2 * time.Second)
	for time.Now().Before(deadline) {
		conn, err := net.DialTimeout("tcp", addr, 50*time.Millisecond)
		if err == nil {
			_ = conn.Close()
			return addr
		}
		time.Sleep(20 * time.Millisecond)
	}
	t.Fatalf("ssh luistert niet op %s", addr)
	return ""
}

func sshProbe(t *testing.T, bin, key, addr string) string {
	t.Helper()
	host, port, err := net.SplitHostPort(addr)
	if err != nil {
		t.Fatal(err)
	}
	ctx, cancel := context.WithTimeout(context.Background(), 8*time.Second)
	defer cancel()
	cmd := exec.CommandContext(ctx, bin, "-vvv",
		"-i", key,
		"-o", "IdentitiesOnly=yes",
		"-o", "StrictHostKeyChecking=no",
		"-o", "UserKnownHostsFile=/dev/null",
		"-o", "BatchMode=yes",
		"-p", port,
		"git@"+host,
		"ls",
	)
	out, _ := cmd.CombinedOutput()
	return string(out)
}

func gitSSH(t *testing.T, bin, key, addr, dir string, args ...string) {
	t.Helper()
	_, port, err := net.SplitHostPort(addr)
	if err != nil {
		t.Fatal(err)
	}
	sshCmd := fmt.Sprintf("%s -i %s -o IdentitiesOnly=yes -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o BatchMode=yes -p %s",
		shellQuote(bin), shellQuote(key), port)
	cmd := exec.Command("git", args...)
	if dir != "" {
		cmd.Dir = dir
	}
	cmd.Env = append(os.Environ(), "GIT_SSH_COMMAND="+sshCmd)
	if out, err := cmd.CombinedOutput(); err != nil {
		t.Fatalf("git %s: %v %s", strings.Join(args, " "), err, out)
	}
}

func git(t *testing.T, dir string, args ...string) {
	t.Helper()
	cmd := exec.Command("git", args...)
	if dir != "" {
		cmd.Dir = dir
	}
	if out, err := cmd.CombinedOutput(); err != nil {
		t.Fatalf("git %s: %v %s", strings.Join(args, " "), err, out)
	}
}

func shellQuote(s string) string {
	return "'" + strings.ReplaceAll(s, "'", `'\''`) + "'"
}
