// Provides a [color.Color] type for dealing with premultiplied OkLab+Alpha colours.
package oklaba

import (
	"image/color"
	"math"

	"smariot.com/color/internal/helper"
)

// Color is a premultiplied OkLab+Alpha [color.Color].
type Color struct {
	Lightness, ChromaA, ChromaB, A float64
}

func sqr(a float64) float64 {
	return a * a
}

// DistanceSqr returns the maximum possible euclidean distance squared between two colours,
// accounting for the possible backgrounds they might be composited over.
func DistanceSqr(a, b Color) float64 {
	dLightness := a.Lightness - b.Lightness
	dChromaA := a.ChromaA - b.ChromaA
	dChromaB := a.ChromaB - b.ChromaB
	dA := a.A - b.A
	return max(sqr(dLightness), sqr(dLightness+dA)) + max(sqr(dChromaA), sqr(dChromaA+dA)) + max(sqr(dChromaB), sqr(dChromaB+dA))
}

// Distance returns the maximum possible euclidean distance between two colours,
// accounting for the possible backgrounds they might be composited over.
//
// If you just want to compare relative distances, use [DistanceSqr] instead.
func Distance(a, b Color) float64 {
	return math.Sqrt(DistanceSqr(a, b))
}

// RGBA converts to premultiplied RGBA, implementing the [color.Color] interface.
func (c Color) RGBA() (r, g, b, a uint32) {
	return helper.NLRGBAtoRGBA(c.NLRGBA())
}

// NRGBA converts to non-premultiplied RGBA.
func (c Color) NRGBA() (r, g, b, a uint32) {
	return helper.NLRGBAtoNRGBA(c.NLRGBA())
}

// NLRGBA converts to non-premultiplied linear RGBA.
func (c Color) NLRGBA() (r, g, b, a float64) {
	if c.A <= 0 {
		return 0, 0, 0, 0
	}

	r, g, b = helper.LMStoLRGB(helper.OkLabToLMS(c.Lightness/c.A, c.ChromaA/c.A, c.ChromaB/c.A))
	return r, g, b, c.A
}

// NXYZA converts to non-premultiplied XYZ+Alpha.
func (c Color) NXYZA() (x, y, z, a float64) {
	if c.A <= 0 {
		return 0, 0, 0, 0
	}

	x, y, z = helper.LMStoXYZ(helper.OkLabToLMS(c.Lightness/c.A, c.ChromaA/c.A, c.ChromaB/c.A))
	return x, y, z, c.A
}

// NOkLabA converts to non-premultiplied OkLab+Alpha.
func (c Color) NOkLabA() (lightness, chromaA, chromaB, a float64) {
	if c.A <= 0 {
		return 0, 0, 0, 0
	}

	return c.Lightness / c.A, c.ChromaA / c.A, c.ChromaB / c.A, c.A
}

// Convert converts an arbitrary colour type to a pre-multiplied OkLab+Alpha [Color].
func Convert(c color.Color) Color {
	if c, ok := c.(Color); ok {
		return c
	}

	lightness, chromaA, chromaB, a := helper.ColorToNOkLabA(c)
	return Color{lightness * a, chromaA * a, chromaB * a, a}
}

// A [color.Model] for converting arbitrary colours to a premultiplied OkLab+Alpha [Color].
//
// Wraps the [Convert] function, returning a [color.Color] interface rather than the [Color] type.
var Model = helper.Model(Convert)

// Type assertion.
var _ color.Color = Color{}