// WaitCode is enumeration of possible process states.
type WaitCode int

const (
	// Process has terminated normally.
	ProcessExited WaitCode = iota
	// Process was terminated by a signal.
	ProcessSignaled
	// Process was stopped by delivery of a signal, but not trapped.
	ProcessStopped
	// Process has stopped and trapped.
	ProcessTrapped
	// Child continued.
	ProcessContinued
	// Process was killed by a signal and dumped core.
	ProcessDumped
)

// WaitInfo provides information about the state of the process after waiting.
type WaitInfo struct {
	Id int // Pid or pidfd
	Status int
	Code   WaitCode
}

// Exited returns true if the process has terminated normally.
func (i WaitInfo) Exited() bool { return i.Code == ProcessExited }

// Signaled returns true if the process was terminated by a signal.
func (i WaitInfo) Signaled() bool { return i.Code == ProcessSignaled }

// Stopped returns true if the process was stopped by delivery of a signal, but not trapped.
func (i WaitInfo) Stopped() bool { return i.Code == ProcessStopped }

// Trapped returns true if the process has stopped and trapped.
func (i WaitInfo) Trapped() bool { return i.Code == ProcessTrapped }

// Continued returns true if the process has continued.
func (i WaitInfo) Continued() bool { return i.Code == ProcessContinued }

// CoreDump returns true if the process was killed by a signal and dumped core.
func (i WaitInfo) CoreDump() bool { return i.Code == ProcessDumped }

func (i WaitInfo) ExitStatus() int {
	if !i.Exited() {
		return -1
	}
	return i.Status
}

func (i WaitInfo) Signal() syscall.Signal {
	if !i.Signaled() {
		return -1
	}
	return syscall.Signal(i.Status)
}

func (i WaitInfo) StopSignal() syscall.Signal {
	if !i.Stopped() {
		return -1
	}
	return syscall.Signal(i.Status)
}

func (i WaitInfo) TrapCause() int {
	if !i.Trapped() {
		return -1
	}
	return i.Status
}

// Wait waits on the process with pid core one or more state transitions to those listed.
// Once transition to that state happens, a WaitInfo is sent to the provided channel.
// Wait can be called multiple times on the same process with an arbitrary combination
// of codes to wait on. When context is canceled, waiting gets canceled as well.
func Wait(ctx context.Context, pid int, c chan<- WaitInfo, code ...WaitCode) {

}

// WaitPidfd is similar to Wait, just that it operates on process file handles available on Linux.
func WaitPidfd(pidfd int, c chan<- WaitInfo, code ...WaitCode) {

}

// Waits on any process to transition to states listed. Once transition to that state happens,
// a WaitInfo is sent to the provided channel.Can be called multiple times with  an arbitrary
// combination of codes to wait on. When context is canceled, waiting gets canceled as well.
func WaitAny(c chan<- WaitInfo, code ...WaitCode) {

}