// The difference:

// ❌ Standard RGB manipulation
lighter := RGB{blue.R + 0.2, blue.G + 0.2, blue.B + 0.2} // Looks cyan-ish

// ✅ This library (perceptually uniform)
lighter := color.Lighten(blue, 0.2) // Actually looks lighter blue!

blue := color.RGB(0, 0, 1)

// All operations are perceptually uniform:
lighter := color.Lighten(blue, 0.2)    // Looks evenly lighter
darker := color.Darken(blue, 0.2)      // Looks evenly darker
vivid := color.Saturate(blue, 0.3)     // Looks more saturated
muted := color.Desaturate(blue, 0.3)   // Looks less saturated

red := color.RGB(1, 0, 0)
blue := color.RGB(0, 0, 1)

// Smooth, perceptually uniform gradient
gradient := color.Gradient(red, blue, 20)

// Create in Display P3 (wider gamut)
p3Red, _ := color.ConvertFromRGBSpace(1, 0, 0, 1, "display-p3")

// Manipulate in perceptual space
lighter := color.Lighten(p3Red, 0.2)

// Convert back to Display P3 (preserves vibrancy!)
result, _ := color.ConvertToRGBSpace(lighter, "display-p3")

color1, _ := color.ParseColor("#FF6B6B")
color2, _ := color.ParseColor("#FF6D6C")

// How different do they look to humans?
diff := color.DeltaE2000(color1, color2) // Industry standard

if diff < 1.0 {
    fmt.Println("Imperceptible difference")
} else if diff < 2.0 {
    fmt.Println("Small difference")
} else {
    fmt.Println("Noticeable difference")
}

// Vivid Display P3 color (out of sRGB gamut)
vividColor := NewSpaceColor(DisplayP3Space, []float64{1.1, 0.3, 0.2}, 1.0)

// Choose your mapping strategy:
clipped := MapToGamut(vividColor, GamutClip)                // Fast
lightness := MapToGamut(vividColor, GamutPreserveLightness) // Keep brightness ⭐
chroma := MapToGamut(vividColor, GamutPreserveChroma)       // Keep saturation
best := MapToGamut(vividColor, GamutProject)                // Best quality

// Load LOG footage from cinema camera
slog3 := color.NewSpaceColor(color.SLog3Space,
    []float64{0.41, 0.39, 0.35}, 1.0)

// Process in HDR workflow
hdr := slog3.ConvertTo(color.Rec2020Space)      // HDR mastering
web := slog3.ConvertTo(color.SRGBSpace)         // Web delivery

// Supported: Canon C-Log, Sony S-Log3, Panasonic V-Log,
//            Arri LogC, Red Log3G10, Blackmagic Film

package main

import (
    "fmt"
    "github.com/SCKelemen/color"
)

func main() {
    // Parse any CSS color format
    blue, _ := color.ParseColor("#0000FF")

    // Perceptually uniform operations
    lighter := color.Lighten(blue, 0.2)
    darker := color.Darken(blue, 0.2)
    vivid := color.Saturate(blue, 0.3)

    // Generate smooth gradient
    red := color.RGB(1, 0, 0)
    gradient := color.Gradient(red, blue, 10)

    // Convert to hex
    for _, c := range gradient {
        fmt.Println(color.RGBToHex(c))
    }
}

// Load S-Log3 footage from Sony camera
slog3 := color.NewSpaceColor(color.SLog3Space,
    []float64{0.41, 0.39, 0.35}, 1.0)

// Convert to Rec.2020 for HDR delivery
hdr := slog3.ConvertTo(color.Rec2020Space)

// Convert to sRGB for web
web := slog3.ConvertTo(color.SRGBSpace)

// Create colors
red := color.RGB(1, 0, 0)
oklch := color.NewOKLCH(0.7, 0.2, 30, 1.0)

// Parse CSS colors
parsed, _ := color.ParseColor("#FF0000")
parsed, _ := color.ParseColor("rgb(255, 0, 0)")
parsed, _ := color.ParseColor("hsl(0, 100%, 50%)")
parsed, _ := color.ParseColor("oklch(0.7 0.2 30)")
parsed, _ := color.ParseColor("color(display-p3 1 0 0)")

// Perceptually uniform
lighter := color.Lighten(c, 0.2)
darker := color.Darken(c, 0.2)
vivid := color.Saturate(c, 0.3)
muted := color.Desaturate(c, 0.3)

// Hue operations
shifted := color.AdjustHue(c, 60)
complement := color.Complement(c)

// Mixing
mixed := color.MixOKLCH(c1, c2, 0.5)

// Other
inverted := color.Invert(c)
gray := color.Grayscale(c)

// Simple gradient (OKLCH, perceptually uniform)
gradient := color.Gradient(start, end, 20)

// Choose interpolation space
gradient := color.GradientInSpace(start, end, 20, color.GradientOKLCH)

// Multi-stop gradient
stops := []color.GradientStop{
    {Color: red, Position: 0.0},
    {Color: yellow, Position: 0.5},
    {Color: blue, Position: 1.0},
}
gradient := color.GradientMultiStop(stops, 30, color.GradientOKLCH)

// With easing
gradient := color.GradientWithEasing(start, end, 20,
    color.GradientOKLCH, color.EaseInOutCubic)

// Modern, fast
diff := color.DeltaEOK(c1, c2)

// Industry standard (slower, most accurate)
diff := color.DeltaE2000(c1, c2)

// Classic formula
diff := color.DeltaE76(c1, c2)

// Convert to wide-gamut space
displayP3, _ := color.ConvertToRGBSpace(c, "display-p3")

// Create from wide-gamut values
p3Color, _ := color.ConvertFromRGBSpace(1.0, 0.5, 0.0, 1.0, "display-p3")

// Check if in gamut
if color.InGamut(c) {
    fmt.Println("Fits in sRGB")
}

// Map to gamut with strategy
mapped := color.MapToGamut(c, color.GamutPreserveLightness)

// Create color in specific space
p3Color := color.NewSpaceColor(
    color.DisplayP3Space,
    []float64{1.0, 0.5, 0.0}, // R, G, B
    1.0, // alpha
)

// Convert between spaces (preserves gamut)
rec2020Color := p3Color.ConvertTo(color.Rec2020Space)

// Get metadata
metadata := color.Metadata(color.DisplayP3Space)
fmt.Printf("Gamut: %.2f× sRGB\n", metadata.GamutVolumeRelativeToSRGB)

brand := color.NewOKLCH(0.55, 0.15, 230, 1.0) // Blue

palette := map[string]string{
    "50":  color.RGBToHex(color.Lighten(brand, 0.45)),
    "100": color.RGBToHex(color.Lighten(brand, 0.35)),
    "200": color.RGBToHex(color.Lighten(brand, 0.25)),
    "300": color.RGBToHex(color.Lighten(brand, 0.15)),
    "400": color.RGBToHex(color.Lighten(brand, 0.05)),
    "500": color.RGBToHex(brand), // Base
    "600": color.RGBToHex(color.Darken(brand, 0.05)),
    "700": color.RGBToHex(color.Darken(brand, 0.15)),
    "800": color.RGBToHex(color.Darken(brand, 0.25)),
    "900": color.RGBToHex(color.Darken(brand, 0.35)),
}

// RAW photo in ProPhoto RGB (widest gamut)
raw, _ := color.ConvertFromRGBSpace(0.9, 0.2, 0.1, 1.0, "prophoto-rgb")

// Edit in perceptual space
edited := color.Saturate(raw, 0.15)
edited = color.Lighten(edited, 0.05)

// Export for Display P3 (modern screens)
p3, _ := color.ConvertToRGBSpace(edited, "display-p3")

// Or map to sRGB with quality gamut mapping
srgb := color.MapToGamut(edited, color.GamutProject)

func checkContrast(fg, bg Color) {
    diff := color.DeltaE2000(fg, bg)

    if diff < 30 {
        fmt.Println("⚠️ Poor contrast - may fail accessibility")
    } else if diff < 50 {
        fmt.Println("✅ Acceptable contrast")
    } else {
        fmt.Println("✅✅ Excellent contrast")
    }
}