sorter

type BufferedEntry[TEntry any] struct {
	First TEntry
}

type BufferedPairEntry[TEntry any] struct {
	First  TEntry
	Second TEntry
}

type BufferedSorter interface {
	// Perform the sorting operation with the given properties and return the sorted version of the image
	Sort(options *SorterOptions) (image.Image, error)

	// Cancel the currently running sorting operation and return a boolean value indicating if the sorting was cancelled
	CancelSort() bool
}

type BufferedSorterState interface {
	// Apply sorter options changes to the buffered sorter state machine
	Apply(options *SorterOptions)

	// Confirm the incoming changes to the buffered sorter state machine
	Commit()

	// Reset non-commited incoming changes that came to the buffered sorter state machine
	Rollback()

	// Get the buffered scaled images set and a boolean value indicating if the values were buffered
	GetScaledImages() (*image.NRGBA, *image.NRGBA, bool)

	// Set the buffered scaled images associated to the incoming sorter options changes
	SetScaledImages(img, maskImage *image.NRGBA)

	// Get the buffered rotated images set and a boolean value indicating if the values were buffered
	GetRotatedImages() (*image.NRGBA, *image.NRGBA, bool)

	// Set the buffered rotated images associated to the incoming sorter options changes
	SetRotatedImages(img, maskImage *image.NRGBA)

	// Get the buffered edge detection image and a boolean value indicating if the value were buffered
	GetEdgeDetectionImage() (*image.NRGBA, bool)

	// Set the buffered edge detection image associated to the incoming sorter options changes
	SetEdgeDetectionImage(img *image.NRGBA)
}

type Interval interface {
	// Add a RGBA color to the given interval
	Append(color color.RGBA) error

	// Get the count of colors stored in the interval
	Count() int

	// Get a boolean value representing the presence of elements in the given interval
	Any() bool

	// Sort all interval colors by weight in the specified direction and return the interval as a new slice of RGBA
	// colors. The internal interval items collection will be cleared after the sort.
	Sort(direction SortDirection, painting IntervalPainting) []color.RGBA

	// Sort all interval colors by weight in the specified direction and return the interval by writing the RGBA
	// colors to the provided buffer. The internal interval items collection will be cleared after the sort.
	SortToBuffer(direction SortDirection, painting IntervalPainting, buffer *[]color.RGBA)
}

type IntervalDeterminant int

type IntervalPainting int

type Mask interface {
	// Return a byte value representing the mask grayscale value at the given position represented by the x and y position.
	At(x, y int) (uint8, error)

	// Return a boolean value representing if the mask is masking at the given position represented by the x and y postition (value < 127 is masked).
	AtB(x, y int) (bool, error)

	// Return a byte value representing the mask grayscale value at the given position represented by the i index.
	AtByIndex(i int) (uint8, error)

	// Return a boolean value representing if the mask is masking at the given position represented by the i index (value < 127 is masked).
	AtByIndexB(i int) (bool, error)
}

type ResultImageBlending int

type SortDeterminant int

type SortDirection int

type SortOrder int

type Sorter interface {
	// Perform the sorting operation and return the sorted version of the image
	Sort() (image.Image, error)

	// Cancel the currently running sorting operation and return a boolean value indicating if the sorting was cancelled
	CancelSort() bool
}

type SorterLogger interface {
	// Log a message with a given format with the Debug log level
	Debugf(format string, args ...interface{})

	// Log a message with a given format with the Info log level
	Infof(format string, args ...interface{})

	// Log a message with a given format with the Warning log level
	Warnf(format string, args ...interface{})

	// Log a message with a given format with the Error log level
	Errorf(format string, args ...interface{})
}

type SorterOptions struct {
	SortDeterminant                   SortDeterminant
	SortDirection                     SortDirection
	SortOrder                         SortOrder
	IntervalDeterminant               IntervalDeterminant
	IntervalPainting                  IntervalPainting
	IntervalDeterminantLowerThreshold float64
	IntervalDeterminantUpperThreshold float64
	IntervalLength                    int
	IntervalLengthRandomFactor        int
	Angle                             int
	UseMask                           bool
	Cycles                            int
	Scale                             float64
	Blending                          ResultImageBlending
}