//go:build testsuite

// The sandbox test program runs cmd/hakurei with configurations simulating
// several common workloads and inspects the resulting container states.
package main

import (
	"context"
	"encoding/binary"
	"encoding/json"
	"io"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"slices"
	"strconv"
	"sync"
	"sync/atomic"
	"syscall"

	"hakurei.app/fhs"
	"hakurei.app/hst"

	"hakurei.app/test/internal/testsuite"
	"hakurei.app/test/sandbox/testdata"
)

// mustStart starts a hakurei container and returns the pid of a process within
// the container. This process must be terminated by the caller.
func mustStart(
	ctx context.Context,
	serial uint64,
	username string,
	files ...*os.File,
) (pid int, done <-chan error) {
	_serial := strconv.FormatUint(serial, 10)
	_, done = testsuite.MustStartAs(
		ctx, username, files,
		"hakurei", "exec",
		"sleep", "infinity", _serial,
	)

	var (
		s testsuite.StatScanner

		stat syscall.Stat_t
	)
	for s.Scan() {
		select {
		case err := <-done:
			if err == nil {
				log.Fatal("test process terminated unexpectedly")
			}
			log.Fatal(err)
		default:
			break
		}

		if s.Stat().Comm != "sleep" {
			continue
		}

		if args, err := s.Stat().Args(); err != nil {
			log.Fatal(err)
		} else if !slices.Equal(args, []string{
			"sleep",
			"infinity",
			_serial,
		}) {
			continue
		}

		if err := s.Stat().Stat(&stat); err != nil {
			log.Fatal(err)
		}

		id := hst.ToUser[uint32](0, 0)
		if stat.Uid != id || stat.Gid != id {
			continue
		}

		break
	}
	if err := s.Err(); err != nil {
		log.Fatal(err)
	}
	pid = s.Stat().PID
	return
}

func main() {
	go testsuite.ReceiveSignals()
	username := testsuite.GetUser().Username

	// the signal handler does not wait for termination
	ctx := context.Background()

	var wg sync.WaitGroup
	defer wg.Wait()

	var serial atomic.Uint64
	newSerial := func() uint64 { serial.Add(1); return serial.Load() }

	testsuite.MustRunAs(
		username, "-i",
		"hakurei", "exec", "capsh", "--print",
	)
	wg.Go(func() {
		defer log.Println("validated capabilities/securebits in user namespace")

		testsuite.MustRunAs(
			username, "-i",
			"hakurei", "exec", "capsh", "--has-no-new-privs",
		)

		for _, p := range []byte{'a', 'b', 'i', 'p'} {
			testsuite.MustFailAs(
				username, "-i",
				"hakurei", "exec", "capsh", "--has-"+string(p)+"=CAP_SYS_ADMIN",
			)
		}
		testsuite.MustFailAs(
			username, "-i",
			"hakurei", "exec", "umount", "-R", "/dev",
		)
	})

	wg.Go(func() {
		defer log.Println("validated pd seccomp outcome")

		c, cancel := context.WithCancel(ctx)
		defer cancel()

		pid, done := mustStart(c, newSerial(), username)
		testsuite.MustCheckFilter(pid, testdata.SumPD)
		if err := testsuite.FilterTerminated(<-done); err != nil {
			log.Fatal(err)
		}
	})

	wg.Go(func() {
		defer log.Println("validated fd leak")

		c, cancel := context.WithCancel(ctx)
		defer cancel()

		pid, done := mustStart(c, newSerial(), username, os.Stdin, os.Stdout, os.Stderr)
		prefix := filepath.Join(fhs.Proc, strconv.Itoa(pid), "fd")

		var fail bool
		if entries, err := os.ReadDir(prefix); err != nil {
			log.Fatal(err.Error())
		} else {
			for _, ent := range entries {
				var fd int
				if fd, err = strconv.Atoi(ent.Name()); err != nil {
					log.Fatal(err.Error())
				}

				// skip standard streams
				if fd <= 2 {
					continue
				}
				fail = true

				var d string
				if d, err = os.Readlink(filepath.Join(
					prefix,
					ent.Name(),
				)); err != nil {
					log.Fatal(err.Error())
				}
				log.Printf("extra fd %d -> %s", fd, d)
			}
		}
		if fail {
			log.Fatal("file descriptors leaked")
		}

		if err := syscall.Kill(pid, syscall.SIGTERM); err != nil {
			log.Fatalf("cannot terminate anchor: %v", err)
		} else if err = testsuite.FilterTerminated(<-done); err != nil {
			log.Fatal(err)
		}
	})

	if err := os.MkdirAll(testsuite.XDGRuntimeDir, 0700); err != nil {
		log.Fatal(err)
	} else if err = os.Chown(testsuite.XDGRuntimeDir, 1000, 1000); err != nil {
		log.Fatal(err)
	}

	dbusEnv := testsuite.MustStartSessionBus(username)
	testsuite.MustStartSway(&wg, username, dbusEnv)
	defer testsuite.TerminateSway(username)

	if err := os.MkdirAll("/opt/test-helper/bin", 0755); err != nil {
		log.Fatal(err)
	}
	testsuite.MustRun(
		"go", "build",
		"-o", "/opt/test-helper/bin",
		"-tags=tester",
		"-trimpath",
		"./test/sandbox/tester",
	)
	log.Println("created test helper")

	for name, tc := range testdata.All() {
		wg.Go(func() {
			cmd := exec.Command(
				"sudo",
				"-u", username,
				"-C", "6",
				testsuite.XDGRuntimeEnv,
				testsuite.WaylandEnv,
				"DISPLAY=:0",
				dbusEnv,
				"--",

				"script", "/dev/null",
				"-E", "always",
				"-qec",
				"hakurei run "+
					"--identifier-fd=5"+
					" 4 1>&3",
			)
			cmd.SysProcAttr = &syscall.SysProcAttr{
				Pdeathsig: syscall.SIGTERM,
			}
			cmd.Stdout, cmd.Stderr = os.Stderr, os.Stderr

			var err error
			var notify, _notify, _conf, conf, ident, _ident *os.File
			if notify, _notify, err = os.Pipe(); err != nil {
				log.Fatal(err)
			}
			cmd.ExtraFiles = append(cmd.ExtraFiles, _notify)
			if _conf, conf, err = os.Pipe(); err != nil {
				log.Fatal(err)
			}
			cmd.ExtraFiles = append(cmd.ExtraFiles, _conf)
			if ident, _ident, err = os.Pipe(); err != nil {
				log.Fatal(err)
			}
			cmd.ExtraFiles = append(cmd.ExtraFiles, _ident)

			done := testsuite.MustStart(cmd)
			wg.Go(func() {
				if _err := <-done; _err != nil {
					log.Fatalf("[FAIL] test case %s: %v", name, _err)
				}
				log.Printf("[ OK ] test case %s", name)
			})

			if err = json.NewEncoder(conf).Encode(&tc.Hakurei); err != nil {
				log.Fatal(err)
			} else if err = conf.Close(); err != nil {
				log.Fatal(err)
			}

			var id hst.ID
			if _, err = io.ReadFull(ident, id[:]); err != nil {
				log.Fatal(err)
			} else if err = ident.Close(); err != nil {
				log.Fatal(err)
			}

			var buf [8]byte
			if _, err = io.ReadFull(notify, buf[:]); err != nil {
				log.Fatal(err)
			} else if err = notify.Close(); err != nil {
				log.Fatal(err)
			}

			testsuite.MustCheckFilter(
				int(binary.LittleEndian.Uint64(buf[:])),
				tc.Sum,
			)
		})
	}
}