//go:build darwin

package hostos

import (
	"bytes"
	"context"
	"encoding/binary"
	"errors"
	"fmt"
	"io/fs"
	"syscall"
	"time"

	"golang.org/x/sys/unix"
)

const (
	startTicksPerSecond = 1000000

	zombieState = 5

	awaitInterval = 100 * time.Millisecond
)

type kinfo struct {
	pid   int
	ppid  int
	pgid  int
	uid   uint32
	state int8
	ticks uint64
}

func readKinfo(pid int) (kinfo, error) {
	k, err := unix.SysctlKinfoProc("kern.proc.pid", pid)
	switch {
	case errors.Is(err, unix.ESRCH), errors.Is(err, unix.ENOENT), errors.Is(err, syscall.EINVAL):
		return kinfo{}, fmt.Errorf("hostos: no process at pid %d: %w", pid, fs.ErrNotExist)
	case err != nil:
		return kinfo{}, fmt.Errorf("hostos: reading the kinfo of pid %d: %w", pid, err)
	case k.Proc.P_pid != int32(pid):
		return kinfo{}, fmt.Errorf("hostos: no process at pid %d: %w", pid, fs.ErrNotExist)
	}
	return kinfo{pid: pid, ppid: int(k.Eproc.Ppid), pgid: int(k.Eproc.Pgid), uid: k.Eproc.Ucred.Uid,
		state: k.Proc.P_stat, ticks: startTicks(k)}, nil
}

func startTicks(k *unix.KinfoProc) uint64 {
	return uint64(k.Proc.P_starttime.Sec)*startTicksPerSecond + uint64(k.Proc.P_starttime.Usec)
}

func ProcStart(pid int) (uint64, error) {
	k, err := readKinfo(pid)
	if err != nil {
		return 0, err
	}
	if k.state == zombieState {
		return 0, fmt.Errorf("hostos: pid %d has exited: %w", pid, fs.ErrNotExist)
	}
	return k.ticks, nil
}

func Cmdline(pid int) ([]string, error) {
	b, err := unix.SysctlRaw("kern.procargs2", pid)
	switch {
	case errors.Is(err, unix.ESRCH), errors.Is(err, unix.ENOENT), errors.Is(err, syscall.EINVAL):
		return nil, fmt.Errorf("hostos: no process at pid %d: %w", pid, fs.ErrNotExist)
	case err != nil:
		return nil, fmt.Errorf("hostos: reading the argument area of pid %d: %w", pid, err)
	}
	if len(b) < 4 {
		return nil, fmt.Errorf("hostos: the argument area of pid %d is %d bytes, shorter than its argc", pid, len(b))
	}
	argc := int(binary.LittleEndian.Uint32(b[:4]))
	rest := b[4:]
	i := bytes.IndexByte(rest, 0)
	if i < 0 {
		return nil, fmt.Errorf("hostos: the argument area of pid %d carries no executable path", pid)
	}
	rest = bytes.TrimLeft(rest[i:], "\x00")
	fields := bytes.Split(rest, []byte{0})
	if argc > len(fields) {
		argc = len(fields)
	}
	out := make([]string, 0, argc)
	for _, f := range fields[:argc] {
		out = append(out, string(f))
	}
	return out, nil
}

func Alive(pid int) (bool, error) {
	err := syscall.Kill(pid, 0)
	switch {
	case err == nil:
		return true, nil
	case errors.Is(err, syscall.ESRCH):
		return false, nil
	case errors.Is(err, syscall.EPERM):
		return true, nil
	}
	return false, fmt.Errorf("hostos: probing pid %d: %w", pid, err)
}

func Signal(pid int, force bool) error {
	sig := syscall.SIGTERM
	if force {
		sig = syscall.SIGKILL
	}
	if err := syscall.Kill(pid, sig); err != nil && !errors.Is(err, syscall.ESRCH) {
		return fmt.Errorf("hostos: signalling pid %d: %w", pid, err)
	}
	return nil
}

func Reload(pid int) error {
	if err := syscall.Kill(pid, syscall.SIGHUP); err != nil {
		return fmt.Errorf("hostos: sending SIGHUP to pid %d: %w", pid, err)
	}
	return nil
}

func Terminate(ctx context.Context, pid int, grace time.Duration) error {
	ticks, err := ProcStart(pid)
	if errors.Is(err, fs.ErrNotExist) {
		return nil
	}
	if err != nil {
		return err
	}
	if err := Signal(pid, false); err != nil {
		return err
	}
	wctx, cancel := context.WithTimeout(context.WithoutCancel(ctx), grace)
	defer cancel()
	if err := AwaitExit(wctx, pid, ticks); err == nil {
		return nil
	}
	if ctx.Err() == nil {
		return fmt.Errorf("hostos: pid %d outlived its %s grace", pid, grace)
	}
	return Signal(pid, true)
}

func AwaitExit(ctx context.Context, pid int, startTicks uint64) error {
	if pid <= 0 {
		return fmt.Errorf("hostos: no process at pid %d to wait for", pid)
	}
	for {
		err := exited(pid, startTicks)
		if errors.Is(err, fs.ErrNotExist) {
			return nil
		}
		if err != nil {
			return err
		}
		select {
		case <-ctx.Done():
			return ctx.Err()
		case <-time.After(awaitInterval):
		}
	}
}

func exited(pid int, ticks uint64) error {
	k, err := readKinfo(pid)
	if err != nil {
		return err
	}
	if k.state == zombieState || (ticks != 0 && k.ticks != ticks) {
		return fmt.Errorf("hostos: pid %d has gone: %w", pid, fs.ErrNotExist)
	}
	return nil
}