interfaces

type ActiveContext interface {
	context.Context

	Cause() error
	GetState() ContextState

	// TODO disambiguate between errors and exceptions
	// TODO rename this to Complete
	Cancel(error)

	// `After` runs a function after the context is complete (regardless of
	// any errors). `After`s are run in the reverse order of when they are
	// called,
	// like
	// defers but on a whole-program level.
	After(FuncActiveContext)

	// `Must` executes a function even if the context has been cancelled. If
	// the function returns an error, `Must` cancels the context. It is
	// meant for
	// defers that must be executed, like closing files, flushing buffers,
	// releasing locks.
	Must(FuncActiveContext)
}

type ActiveContextGetter interface {
	GetActiveContext() ActiveContext
}

type Adder[ELEMENT any] interface {
	Add(ELEMENT) error
}

type CLIFlagDefinitions interface {
	BoolVar(variable *bool, name string, defaultValue bool, usage string)
	StringVar(variable *string, name string, defaultValue string, usage string)
	Var(value FlagValue, name string, usage string)
	Func(name, usage string, funk func(string) error)
	IntVar(variable *int, name string, defaultValue int, usage string)
}

type CLIFlagIOWrapper interface {
	FlagValue
	IOWrapper
}

type Coder[OBJECT any, READER any, WRITER any] interface {
	DecoderFrom[OBJECT, READER]
	EncoderTo[OBJECT, WRITER]
}

type CoderBufferedReadWriter[OBJECT any] = Coder[OBJECT, *bufio.Reader, *bufio.Writer]

type CoderReadWriter[OBJECT any] = Coder[OBJECT, io.Reader, io.Writer]

type Collection[ELEMENT any] interface {
	Lenner
	Iterable[ELEMENT]
}

type CollectionMutable[ELEMENT any] interface {
	Collection[ELEMENT]
	Resetable
}

type CommandComponentWriter interface {
	SetFlagDefinitions(CLIFlagDefinitions)
}

type Comparable[SELF any] interface {
	Lenner
	RuneDecoder
	Shift(int) SELF
}

type CompoundKeyer[T any] []StringKeyer[T]

type ContainsKeyer interface {
	ContainsKey(string) bool
}

type ContextState uint8

type DecoderFrom[OBJECT any, READER any] interface {
	DecodeFrom(OBJECT, READER) (int64, error)
}

type DecoderFromBufferedReader[OBJECT any] = DecoderFrom[OBJECT, *bufio.Reader]

type DecoderFromReader[OBJECT any] = DecoderFrom[OBJECT, io.Reader]

type Delta[ELEMENT any] interface {
	GetAdded() Set[ELEMENT]
	GetRemoved() Set[ELEMENT]
}

type DirectoryLayoutBaseEnvVar interface {
	Stringer

	GetBaseEnvVarName() string
	GetBaseEnvVarValue() string

	MakePath(...string) DirectoryLayoutPath
}

type DirectoryLayoutPath interface {
	Stringer

	GetBaseEnvVar() DirectoryLayoutBaseEnvVar
	GetTarget() string

	GetTemplate() string
}

type DirectoryLayoutXDG interface {
	GetDirHome() DirectoryLayoutBaseEnvVar
	GetDirCwd() DirectoryLayoutBaseEnvVar
	GetDirData() DirectoryLayoutBaseEnvVar
	GetDirConfig() DirectoryLayoutBaseEnvVar
	GetDirState() DirectoryLayoutBaseEnvVar
	GetDirCache() DirectoryLayoutBaseEnvVar
	GetDirRuntime() DirectoryLayoutBaseEnvVar

	CloneWithUtilityName(string) DirectoryLayoutXDG
}

type EncoderTo[OBJECT any, READER any] interface {
	EncodeTo(OBJECT, READER) (int64, error)
}

type EncoderToBufferedWriter[OBJECT any] = EncoderTo[OBJECT, *bufio.Writer]

type EncoderToWriter[OBJECT any] = EncoderTo[OBJECT, io.Writer]

type EnvVars = map[string]string

type EnvVarsAdder interface {
	AddToEnvVars(EnvVars)
}

type Equaler[ELEMENT any] interface {
	Equals(ELEMENT, ELEMENT) bool
}

type Equatable[ELEMENT any] interface {
	Equals(ELEMENT) bool
}

type ErrorHiddenWrapper interface {
	ErrorOneUnwrapper
	ShouldHideUnwrap() bool
}

type ErrorManyUnwrapper interface {
	error
	Unwrap() []error
}

type ErrorOneUnwrapper interface {
	error
	Unwrap() error
}

type ErrorRetryable interface {
	error
	Recover(ActiveContext, FuncRetry, FuncRetryAborted)
}

type FlagValue interface {
	StringerSetter
}

type FuncActiveContext = func(ActiveContext) error

type FuncIter[ELEMENT any] func(ELEMENT) error

type FuncIterIO[ELEMENT any] func(ELEMENT) (int64, error)

type FuncIterKey func(string) error

type FuncIterWithKey[ELEMENT any] func(string, ELEMENT) error

type FuncMakePrinter[OUT any] func(WriterAndStringWriter) FuncIter[OUT]

type FuncRepool func()

type FuncRetry func()

type FuncRetryAborted func(err error)

type FuncSetString func(string) error

type FuncString[T any] func(T) string

type FuncStringWriterFormat[T any] func(WriterAndStringWriter, T) (int64, error)

type FuncTransform[ELEMENT any, T1 any] func(ELEMENT) (T1, error)

type FuncWriter func(io.Writer) (int64, error)

type FuncWriterElementInterface[ELEMENT any] func(
	WriterAndStringWriter,
	ELEMENT,
) (int64, error)

type FuncWriterFormat[T any] func(io.Writer, T) (int64, error)

type IOWrapper interface {
	ReadWrapper
	WriteWrapper
}

type Iterable[ELEMENT any] interface {
	All() Seq[ELEMENT]
}

type Keyer[ELEMENT any] interface {
	Key(ELEMENT) string
}

type Lenner interface {
	Len() int
}

type Lessor[ELEMENT any] interface {
	Less(ELEMENT, ELEMENT) bool
}

type LockSmith interface {
	IsAcquired() bool
	Lock() error
	Unlock() error
}

type LockSmithGetter interface {
	GetLockSmith() LockSmith
}

type Pool[T any] interface {
	GetWithRepool() (T, FuncRepool)
}

type PoolPtr[T any, TPtr Ptr[T]] interface {
	Pool[TPtr]
}

type Printer interface {
	io.Writer

	GetFile() *os.File
	IsTty() bool

	// TODO add "isOn" function
	Caller(skip int) Printer
	Print(a ...any) (err error)
	PrintDebug(a ...any) (err error)
	Printf(f string, a ...any) (err error)
}

type Ptr[T any] interface {
	*T
}

type Pull[ELEMENT any] = func() (ELEMENT, bool)

type Pull2[ELEMENT any, ELEMENT_TWO any] = func() (ELEMENT, ELEMENT_TWO, bool)

type ReadWrapper interface {
	WrapReader(r io.Reader) (io.ReadCloser, error)
}

type Resetable interface {
	Reset()
}

type ResetablePtr[ELEMENT any] interface {
	Ptr[ELEMENT]
	ResetWith(ELEMENT)
	Reset()
}

type ResetableWithError interface {
	Reset() error
}

type Resetter[ELEMENT any] interface {
	Reset(ELEMENT)
	ResetWith(ELEMENT, ELEMENT)
}

type ResetterPtr[
	ELEMENT any,
	ELEMENT_PTR Ptr[ELEMENT],
] interface {
	Reset(ELEMENT_PTR)
	ResetWith(ELEMENT_PTR, ELEMENT_PTR)
}

type RuneDecoder interface {
	DecodeRune() (char rune, width int)
}

type Seq[ELEMENT any] = iter.Seq[ELEMENT]

type Seq2[ELEMENT any, ELEMENT_TWO any] = iter.Seq2[ELEMENT, ELEMENT_TWO]

type SeqError[ELEMENT any] = iter.Seq2[ELEMENT, error]

type Set[ELEMENT any] interface {
	ContainsKeyer
	Iterable[ELEMENT]
	Keyer[ELEMENT]
	Lenner
	SetGetter[ELEMENT]
}

type SetGetter[ELEMENT any] interface {
	Get(string) (ELEMENT, bool)
}

type SetMutable[ELEMENT any] interface {
	Set[ELEMENT]
	Adder[ELEMENT]
	DelKey(string) error
	Resetable
}

type Setter interface {
	Set(string) error
}

type SetterPtr[T any] interface {
	Ptr[T]
	Setter
}

type StringCoder[T any] interface {
	DecoderFromReader[T]
	StringEncoderTo[T]
}

type StringEncoderTo[T any] interface {
	EncodeStringTo(T, WriterAndStringWriter) (int64, error)
}

type StringKeyer[T any] interface {
	GetKey(T) string
}

type StringKeyerPtr[T any, TPtr Ptr[T]] interface {
	StringKeyer[T]
	GetKeyPtr(TPtr) string
}

type StringSetterPtr[T any] interface {
	Stringer
	Ptr[T]
	Setter
}

type Stringer interface {
	String() string
}

type StringerPtr[T any] interface {
	Stringer
	Ptr[T]
}

type StringerSetter interface {
	Stringer
	Setter
}

type StringerSetterPtr[T any] interface {
	Stringer
	Setter
	Ptr[T]
}

type StringerWithHeadAndTail interface {
	Stringer
	GetHead() string
	GetTail() string
}

type Tridex interface {
	Collection[string]
	ContainsAbbreviation(string) bool
	ContainsExpansion(string) bool
	Abbreviate(string) string
	Expand(string) string
}

type TridexMutable interface {
	Tridex
	Add(string)
	Remove(string)
}

type Value interface {
	Stringer
	IsEmpty() bool
}

type ValuePtr[SELF Value] interface {
	Resetable
	ResetablePtr[SELF]
	StringerSetterPtr[SELF]
}

type WriteWrapper interface {
	WrapWriter(w io.Writer) (io.WriteCloser, error)
}

type WriterAndStringWriter interface {
	io.Writer
	io.StringWriter
}