package nsenter

import "io"

type nsOptions struct {
	types  []NsType
	pid    int
	procfs string
	envs   []string
	output io.Writer
	uid    int
	gid    int
}

type Option interface {
	apply(*nsOptions)
}

type nsTypesOption []NsType

func (opt nsTypesOption) apply(options *nsOptions) {
	options.types = opt
}

// Types specify namespace types while creating Namespace instance, supports NET,
// UTS, IPC, USER, and PID.
func Types(types ...NsType) Option {
	return nsTypesOption(types)
}

type pidOption int

func (opt pidOption) apply(options *nsOptions) {
	options.pid = int(opt)
}

// Pid specify which process attached to for namespaces
func Pid(pid int) Option {
	return pidOption(pid)
}

type procfsOption string

func (opt procfsOption) apply(options *nsOptions) {
	if string(opt) != "" {
		options.procfs = string(opt)
	}
}

// Procfs specify host procfs, which is useful for using package in container that
// has bind host /proc into container or starts with host pid namespace
func Procfs(procfs string) Option {
	return procfsOption(procfs)
}

type outputOption struct {
	output io.Writer
}

func (opt outputOption) apply(options *nsOptions) {
	options.output = opt.output
}

// Output specify output writer for execution results, only works for Command
func Output(output io.Writer) Option {
	return outputOption{output}
}

type envsOption struct {
	envs []string
}

func (opt *envsOption) apply(options *nsOptions) {
	options.envs = opt.envs
}

func Envs(envs ...string) Option {
	return &envsOption{envs}
}

type uidOption int

func (opt uidOption) apply(options *nsOptions) {
	options.uid = int(opt)
}

func UID(uid int) Option {
	return uidOption(uid)
}

type gidOption int

func (opt gidOption) apply(options *nsOptions) {
	options.gid = int(opt)
}

func GID(gid int) Option {
	return gidOption(gid)
}