// Package pixel contains pixel format definitions used in various displays and
// fast operations on them.
//
// This package is just a base for pixel operations, it is _not_ a graphics
// library. It doesn't define circles, lines, etc - just the bare minimum
// graphics operations needed plus the ones that need to be specialized per
// pixel format.
package pixel

import (
	"image/color"
	"math/bits"
)

// Pixel with a particular color, matching the underlying hardware of a
// particular display. Each pixel is at least 1 byte in size.
// The color format is sRGB (or close to it) in all cases except for 1-bit.
type Color interface {
	RGB888 | RGB565BE | RGB555 | RGB444BE | Grayscale2bit | Monochrome

	BaseColor
}

// BaseColor contains all the methods needed in a color format. This can be used
// in display drivers that want to define their own Color type with just the
// pixel formats the display supports.
type BaseColor interface {
	// The number of bits when stored.
	// This means for example that RGB555 (which is still stored as a 16-bit
	// integer) returns 16, while RGB444 returns 12.
	BitsPerPixel() int

	// Return the given color in color.RGBA format, which is always sRGB. The
	// alpha channel is always 255.
	RGBA() color.RGBA
}

// NewColor returns the given color based on the RGB values passed in the
// parameters. The input value is assumed to be in sRGB color space.
func NewColor[T Color](r, g, b uint8) T {
	// Ugly cast from color.RGBA to T. The type switch and interface casts are
	// trivially optimized away after instantiation.
	var value T
	switch any(value).(type) {
	case RGB888:
		return any(NewRGB888(r, g, b)).(T)
	case RGB565BE:
		return any(NewRGB565BE(r, g, b)).(T)
	case RGB555:
		return any(NewRGB555(r, g, b)).(T)
	case RGB444BE:
		return any(NewRGB444BE(r, g, b)).(T)
	case Grayscale2bit:
		return any(NewGrayscale2bit(r, g, b)).(T)
	case Monochrome:
		return any(NewMonochrome(r, g, b)).(T)
	default:
		panic("unknown color format")
	}
}

// NewLinearColor returns the given color based on the linear RGB values passed
// in the parameters. Use this if the RGB values are actually linear colors
// (like those that are used in most RGB LEDs) and not when it is in the usual
// sRGB color space (which is not linear).
//
// The input is assumed to be in the linear sRGB color space.
func NewLinearColor[T Color](r, g, b uint8) T {
	r = gammaEncodeTable[r]
	g = gammaEncodeTable[g]
	b = gammaEncodeTable[b]
	return NewColor[T](r, g, b)
}

// RGB888 format, more commonly used in other places (desktop PC displays, CSS,
// etc). Less commonly used on embedded displays due to the higher memory usage.
type RGB888 struct {
	R, G, B uint8
}

func NewRGB888(r, g, b uint8) RGB888 {
	return RGB888{r, g, b}
}

func (c RGB888) BitsPerPixel() int {
	return 24
}

func (c RGB888) RGBA() color.RGBA {
	return color.RGBA{
		R: c.R,
		G: c.G,
		B: c.B,
		A: 255,
	}
}

// RGB565 as used in many SPI displays. Stored as a big endian value.
//
// The color format in integer form is gggbbbbb_rrrrrggg on little endian
// systems, which is the standard RGB565 format but with the top and bottom
// bytes swapped.
//
// There are a few alternatives to this weird big-endian format, but they're not
// great:
//   - Storing the value in two 8-bit stores (to make the code endian-agnostic)
//     incurs too much of a performance penalty.
//   - Swapping the upper and lower bits just before storing. This is still less
//     efficient than it could be, since colors are usually constructed once and
//     then reused in many store operations. Doing the swap once instead of many
//     times for each store is a performance win.
type RGB565BE uint16

func NewRGB565BE(r, g, b uint8) RGB565BE {
	val := uint16(r&0xF8)<<8 +
		uint16(g&0xFC)<<3 +
		uint16(b&0xF8)>>3
	// Swap endianness (make big endian).
	// This is done using a single instruction on ARM (rev16).
	// TODO: this should only be done on little endian systems, but TinyGo
	// doesn't currently (2023) support big endian systems so it's difficult to
	// test. Also, big endian systems don't seem fasionable these days.
	val = bits.ReverseBytes16(val)
	return RGB565BE(val)
}

func (c RGB565BE) BitsPerPixel() int {
	return 16
}

func (c RGB565BE) RGBA() color.RGBA {
	// Note: on ARM, the compiler uses a rev instruction instead of a rev16
	// instruction. I wonder whether this can be optimized further to use rev16
	// instead?
	c = c<<8 | c>>8
	color := color.RGBA{
		R: uint8(c>>11) << 3,
		G: uint8(c>>5) << 2,
		B: uint8(c) << 3,
		A: 255,
	}
	// Correct color rounding, so that 0xff roundtrips back to 0xff.
	color.R |= color.R >> 5
	color.G |= color.G >> 6
	color.B |= color.B >> 5
	return color
}

// Color format used on the GameBoy Advance among others.
//
// Colors are stored as native endian values, with bits 0bbbbbgg_gggrrrrr (red
// is least significant, blue is most significant).
type RGB555 uint16

func NewRGB555(r, g, b uint8) RGB555 {
	return RGB555(r)>>3 | (RGB555(g)>>3)<<5 | (RGB555(b)>>3)<<10
}

func (c RGB555) BitsPerPixel() int {
	// 15 bits per pixel, but there are 16 bits when stored
	return 16
}

func (c RGB555) RGBA() color.RGBA {
	color := color.RGBA{
		R: (uint8(c) & 0x1F) << 3,
		G: (uint8(c>>5) & 0x1F) << 3,
		B: (uint8(c>>10) & 0x1F) << 3,
		A: 255,
	}
	// Correct color rounding, so that 0xff roundtrips back to 0xff.
	color.R |= color.R >> 5
	color.G |= color.G >> 5
	color.B |= color.B >> 5
	return color
}

// Color format that is supported by the ST7789 for example.
// It may be a bit faster to use than RGB565BE on very slow SPI buses.
//
// The color format is native endian as a uint16 (0000rrrr_ggggbbbb), not big
// endian which you might expect. I tried swapping the bytes, but it didn't have
// much of a performance impact and made the code harder to read. It is stored
// as a 12-bit big endian value in Image[RGB444BE] though.
type RGB444BE uint16

func NewRGB444BE(r, g, b uint8) RGB444BE {
	return RGB444BE(r>>4)<<8 | RGB444BE(g>>4)<<4 | RGB444BE(b>>4)
}

func (c RGB444BE) BitsPerPixel() int {
	return 12
}

func (c RGB444BE) RGBA() color.RGBA {
	color := color.RGBA{
		R: uint8(c>>8) << 4,
		G: uint8(c>>4) << 4,
		B: uint8(c>>0) << 4,
		A: 255,
	}
	// Correct color rounding, so that 0xff roundtrips back to 0xff.
	color.R |= color.R >> 4
	color.G |= color.G >> 4
	color.B |= color.B >> 4
	return color
}

// Grayscale2bit represents a 2-bit Grayscale value (4 levels: black, dark gray, light gray, white).
type Grayscale2bit uint8

func NewGrayscale2bit(r, g, b uint8) Grayscale2bit {
	// Convert RGB to luminance using standard weights (approximation of human perception)
	// Use shift-based operations to reduce processing time.
	// luminance := (299*uint32(r) + 587*uint32(g) + 114*uint32(b)) / 1000
	luminance := (77*uint32(r) + 150*uint32(g) + 29*uint32(b)) >> 8
	// Map to 2-bit value: 0–63 => 0, 64–127 => 1, 128–191 => 2, 192–255 => 3
	return Grayscale2bit((luminance >> 6) & 0b11)
}

func (c Grayscale2bit) BitsPerPixel() int {
	return 2
}

func (c Grayscale2bit) RGBA() color.RGBA {
	// Expand 2-bit Grayscale back to 8-bit (0–255) using multiplication
	// 0 → 0x00, 1 → 0x55, 2 → 0xAA, 3 → 0xFF (i.e., multiply by 85)
	gray := uint8(c&0b11) * 85
	return color.RGBA{
		R: gray,
		G: gray,
		B: gray,
		A: 255,
	}
}

type Monochrome bool

func NewMonochrome(r, g, b uint8) Monochrome {
	// Very simple black/white split.
	// This isn't very accurate (especially for sRGB colors) but is close enough.
	if int(r)+int(g)+int(b) > 128*3 { // light, convert to white
		return Monochrome(true)
	}
	// dark, convert to black
	return Monochrome(false)
}

func (c Monochrome) BitsPerPixel() int {
	return 1
}

func (c Monochrome) RGBA() color.RGBA {
	value := uint8(0)
	if c {
		value = 255
	}
	return color.RGBA{
		R: value,
		G: value,
		B: value,
		A: 255,
	}
}

// Gamma brightness lookup table:
// https://victornpb.github.io/gamma-table-generator
// gamma = 0.45 steps = 256 range = 0-255
var gammaEncodeTable = [256]uint8{
	0, 21, 28, 34, 39, 43, 46, 50, 53, 56, 59, 61, 64, 66, 68, 70,
	72, 74, 76, 78, 80, 82, 84, 85, 87, 89, 90, 92, 93, 95, 96, 98,
	99, 101, 102, 103, 105, 106, 107, 109, 110, 111, 112, 114, 115, 116, 117, 118,
	119, 120, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135,
	136, 137, 138, 139, 140, 141, 142, 143, 144, 144, 145, 146, 147, 148, 149, 150,
	151, 151, 152, 153, 154, 155, 156, 156, 157, 158, 159, 160, 160, 161, 162, 163,
	164, 164, 165, 166, 167, 167, 168, 169, 170, 170, 171, 172, 173, 173, 174, 175,
	175, 176, 177, 178, 178, 179, 180, 180, 181, 182, 182, 183, 184, 184, 185, 186,
	186, 187, 188, 188, 189, 190, 190, 191, 192, 192, 193, 194, 194, 195, 195, 196,
	197, 197, 198, 199, 199, 200, 200, 201, 202, 202, 203, 203, 204, 205, 205, 206,
	206, 207, 207, 208, 209, 209, 210, 210, 211, 212, 212, 213, 213, 214, 214, 215,
	215, 216, 217, 217, 218, 218, 219, 219, 220, 220, 221, 221, 222, 223, 223, 224,
	224, 225, 225, 226, 226, 227, 227, 228, 228, 229, 229, 230, 230, 231, 231, 232,
	232, 233, 233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238, 239, 239, 240,
	240, 241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 247, 247, 248,
	248, 249, 249, 249, 250, 250, 251, 251, 252, 252, 253, 253, 254, 254, 255, 255,
}