#[cfg(test)]
use super::counters;
use super::limits::{Budget, DECODE_BUDGET, Error, Result, decode_pixels, finite_sample, inflate, release_bytes, too_large};
use super::model::{ColorMode, Layer, Pixels, Rect};
use super::{Psd, Reader};
use std::borrow::Cow;

impl Psd {
    fn bytes_per_sample(&self) -> usize {
        match self.depth {
            16 => 2,
            32 => 4,
            _ => 1,
        }
    }

    /// The raw big-endian bytes of one channel of `w`×`h` samples at `offset` (compression field
    /// first): `row_bytes(w) × h` of them with the compression and the prediction undone.
    /// Uncompressed data is borrowed from the file, not copied; any other buffer is charged to
    /// `budget` and the caller releases it (see [`release_bytes`]) once it is dropped.
    fn channel_bytes(&self, offset: usize, len: usize, w: usize, h: usize, budget: &mut Budget) -> Result<Cow<'_, [u8]>> {
        let end = offset.checked_add(len).filter(|&e| e <= self.data.len()).ok_or(Error::Truncated)?;
        let mut r = Reader::at(self.data.get(..end).ok_or(Error::Truncated)?, offset);
        let comp = r.u16()?;
        decode_pixels(w, h)?;
        self.plane_bytes(comp, &mut r, w, h, budget)
    }

    /// The raw bytes (`row_bytes(w)` × `h`, ZIP prediction undone) of one channel whose pixel data
    /// follows `r`'s position (after the compression field). Uncompressed data is borrowed, not
    /// copied; the other buffers are charged to `budget`.
    pub(crate) fn plane_bytes<'a>(&self, comp: u16, r: &mut Reader<'a>, w: usize, h: usize, budget: &mut Budget) -> Result<Cow<'a, [u8]>> {
        let rowb = self.row_bytes(w);
        let size = rowb.checked_mul(h).ok_or_else(|| too_large(w, h))?;
        Ok(match self.open_planes(comp, r, 1, 1, (w, h), budget)? {
            PlaneStream::Raw => Cow::Borrowed(r.bytes(size)?),
            PlaneStream::Rle(counts) => Cow::Owned(Self::unpack_plane(&counts, 0, r, rowb, h, budget)?),
            PlaneStream::Zip(mut v) => {
                v.resize(size, 0);
                self.zip_plane(comp, &mut v, 0, w, h)?;
                Cow::Owned(v)
            }
        })
    }

    /// Prepare the pixel data at `r` (just after the compression field) of `total` planes of
    /// `w`×`h` samples, of which the first `want` are decoded: the RLE row sizes of every plane,
    /// or the inflated ZIP data, which holds all planes one after another (charged to `budget`
    /// before it is inflated).
    fn open_planes(&self, comp: u16, r: &mut Reader, total: usize, want: usize, size: (usize, usize), budget: &mut Budget) -> Result<PlaneStream> {
        let (w, h) = size;
        let size = self.row_bytes(w).checked_mul(h).ok_or_else(|| too_large(w, h))?;
        Ok(match comp {
            0 => PlaneStream::Raw,
            1 => {
                let n = total.saturating_mul(h);
                let mut counts = Vec::with_capacity(n.min(r.remaining() / 2));
                for _ in 0..n {
                    counts.push(if self.psb { r.u32()? as usize } else { r.u16()? as usize });
                }
                PlaneStream::Rle(counts)
            }
            2 | 3 => {
                let rest = r.bytes(r.remaining())?;
                // One stream holds every plane: what it may decode to is what they need.
                let all = size.checked_mul(want).ok_or_else(|| too_large(w, h))?;
                budget.charge(all as u64)?;
                PlaneStream::Zip(inflate(rest, all)?)
            }
            c => return Err(Error::Unsupported(format!("compression {c}"))),
        })
    }

    /// The raw bytes (`row_bytes(w)` × `h`, ZIP prediction undone) of plane `c`: raw and RLE
    /// planes are read from `r` in order, raw ones borrowed from the file data, ZIP ones from the
    /// inflated buffer (un-predicted in place; already charged by `open_planes`), RLE ones charged
    /// to `budget`.
    fn decode_plane<'x, 'a: 'x>(
        &self,
        comp: u16,
        planes: &'x mut PlaneStream,
        r: &mut Reader<'a>,
        c: usize,
        size: (usize, usize),
        budget: &mut Budget,
    ) -> Result<Cow<'x, [u8]>> {
        let (w, h) = size;
        let rowb = self.row_bytes(w);
        let size = rowb.checked_mul(h).ok_or_else(|| too_large(w, h))?;
        Ok(match planes {
            PlaneStream::Raw => Cow::Borrowed(r.bytes(size)?),
            PlaneStream::Rle(counts) => Cow::Owned(Self::unpack_plane(counts, c, r, rowb, h, budget)?),
            PlaneStream::Zip(v) => Cow::Borrowed(self.zip_plane(comp, v, c, w, h)?),
        })
    }

    /// Unpack the `h` RLE rows of plane `c` (row byte counts `counts`, plane after plane) into a
    /// buffer charged to `budget`.
    fn unpack_plane(counts: &[usize], c: usize, r: &mut Reader, rowb: usize, h: usize, budget: &mut Budget) -> Result<Vec<u8>> {
        let mut out = budget.vec::<u8>(rowb.checked_mul(h).ok_or(Error::Truncated)?)?;
        for row in 0..h {
            let n = *counts.get(c * h + row).ok_or(Error::Truncated)?;
            unpack_bits(r.bytes(n)?, rowb, &mut out)?;
        }
        Ok(out)
    }

    /// Plane `c` of the inflated ZIP data of consecutive planes, un-predicted in place (`comp` 3).
    pub(crate) fn zip_plane<'v>(&self, comp: u16, v: &'v mut [u8], c: usize, w: usize, h: usize) -> Result<&'v [u8]> {
        let rowb = self.row_bytes(w);
        let plane = v.get_mut(c * rowb * h..(c + 1) * rowb * h).ok_or(Error::Truncated)?;
        if comp == 3 {
            self.unpredict(plane, w, h);
        }
        Ok(plane)
    }

    /// One channel as `w * h` floats (0..1), charged to `budget` (the caller releases it).
    fn channel_floats(&self, offset: usize, len: usize, w: usize, h: usize, budget: &mut Budget) -> Result<Vec<f32>> {
        let raw = self.channel_bytes(offset, len, w, h, budget)?;
        let mut out = budget.filled(decode_pixels(w, h)?, 0.0f32)?;
        self.for_each_sample(&raw, w, h, |i, v| {
            if let Some(o) = out.get_mut(i) {
                *o = v;
            }
        });
        release_bytes(budget, raw);
        Ok(out)
    }

    pub(crate) fn row_bytes(&self, w: usize) -> usize {
        if self.depth == 1 { w.div_ceil(8) } else { w * self.bytes_per_sample() }
    }

    pub(crate) fn unpredict(&self, v: &mut [u8], w: usize, h: usize) {
        match self.depth {
            16 => {
                for row in v.chunks_exact_mut(w * 2).take(h) {
                    let mut prev = 0u16;
                    for c in row.as_chunks_mut::<2>().0 {
                        let x = u16::from_be_bytes([c[0], c[1]]).wrapping_add(prev);
                        c.copy_from_slice(&x.to_be_bytes());
                        prev = x;
                    }
                }
            }
            32 => {
                // One scratch row for the whole plane.
                let mut planar = vec![0u8; w * 4];
                #[cfg(test)]
                counters::bump(&counters::SCRATCH);
                for row in v.chunks_exact_mut(w * 4).take(h) {
                    for i in 1..row.len() {
                        row[i] = row[i].wrapping_add(row[i - 1]);
                    }
                    // Bytes are stored plane by plane (all first bytes, then all second bytes…).
                    planar.copy_from_slice(row);
                    for x in 0..w {
                        for b in 0..4 {
                            row[x * 4 + b] = planar[b * w + x];
                        }
                    }
                }
            }
            _ => {
                for row in v.chunks_exact_mut(w).take(h) {
                    for i in 1..row.len() {
                        row[i] = row[i].wrapping_add(row[i - 1]);
                    }
                }
            }
        }
    }

    /// Hand every sample of `raw` (`w`×`h`, row-major, in order) to `f` as a float. Samples a short
    /// `raw` does not have are not reported.
    pub(crate) fn for_each_sample(&self, raw: &[u8], w: usize, h: usize, mut f: impl FnMut(usize, f32)) {
        let n = w.saturating_mul(h);
        match self.depth {
            1 => {
                let rowb = w.div_ceil(8);
                for y in 0..h {
                    for x in 0..w {
                        let b = raw.get(y * rowb + x / 8).copied().unwrap_or(0);
                        // 1 = black.
                        f(y * w + x, if b & (0x80 >> (x % 8)) != 0 { 0.0 } else { 1.0 });
                    }
                }
            }
            16 => raw.as_chunks::<2>().0.iter().take(n).enumerate().for_each(|(i, c)| f(i, u16::from_be_bytes([c[0], c[1]]) as f32 / 65535.0)),
            // NaN reads as 0, +inf as white (1.0, like the integer depths' maximum), -inf as 0.
            32 => raw.as_chunks::<4>().0.iter().take(n).enumerate().for_each(|(i, c)| f(i, finite_sample(f32::from_be_bytes([c[0], c[1], c[2], c[3]])))),
            _ => raw.iter().take(n).enumerate().for_each(|(i, &b)| f(i, b as f32 / 255.0)),
        }
    }

    /// Convert colour values (the document mode's channels, missing ones 0) to RGB.
    pub(crate) fn rgb_from(&self, v: [f32; 4]) -> [f32; 3] {
        let g = |k: usize| v.get(k).copied().unwrap_or(0.0);
        let rgb = match self.mode {
            ColorMode::Rgb => [g(0), g(1), g(2)],
            ColorMode::Cmyk => {
                // Stored inverted (1 = no ink).
                let k = g(3);
                [g(0) * k, g(1) * k, g(2) * k]
            }
            ColorMode::Indexed if self.palette.len() >= 768 => {
                let idx = (g(0) * 255.0).round() as usize & 255;
                [self.palette[idx] as f32 / 255.0, self.palette[256 + idx] as f32 / 255.0, self.palette[512 + idx] as f32 / 255.0]
            }
            ColorMode::Lab => lab_to_rgb(g(0) * 100.0, g(1) * 255.0 - 128.0, g(2) * 255.0 - 128.0),
            _ => [g(0); 3],
        };
        if self.depth == 32 && self.mode != ColorMode::Lab { rgb.map(srgb_encode) } else { rgb }
    }

    /// Write merged-image channel `c` (raw bytes) into the result: the first three colour channels
    /// and the alpha channel into their slot of a pixel, the fourth CMYK channel into `black`.
    fn store_merged_channel(&self, c: usize, raw: &[u8], data: &mut [[f32; 4]], black: &mut Option<Vec<f32>>) {
        let (w, h, cc) = (self.width as usize, self.height as usize, self.mode.color_channels());
        if c < cc.min(3) {
            self.for_each_sample(raw, w, h, |i, v| {
                if let Some(p) = data.get_mut(i) {
                    p[c] = v;
                }
            });
        } else if c == 3 && c < cc {
            if let Some(k) = black {
                self.for_each_sample(raw, w, h, |i, v| {
                    if let Some(o) = k.get_mut(i) {
                        *o = v;
                    }
                });
            }
        } else if c == cc && self.merged_alpha {
            self.for_each_sample(raw, w, h, |i, v| {
                if let Some(p) = data.get_mut(i) {
                    p[3] = v;
                }
            });
        }
    }

    /// The merged (flattened) image.
    pub fn composite(&self) -> Result<Pixels> {
        self.composite_with_budget(DECODE_BUDGET)
    }

    /// [`Self::composite`] with at most `limit` bytes live at once. The channels are written
    /// straight into the result, so the peak is the result (16 bytes a pixel), the CMYK black
    /// channel, and the one buffer a channel (or, for ZIP, all channels) decodes through.
    pub(crate) fn composite_with_budget(&self, limit: u64) -> Result<Pixels> {
        let mut budget = Budget::new(limit);
        let (w, h) = (self.width as usize, self.height as usize);
        let n = decode_pixels(w, h)?;
        let mut r = Reader::at(&self.data, self.merged_offset);
        let comp = r.u16()?;
        let nch = self.channels as usize;
        let cc = self.mode.color_channels();
        let want = (cc + usize::from(self.merged_alpha)).min(nch);
        let rowb = self.row_bytes(w);
        let size = rowb.checked_mul(h).ok_or_else(|| too_large(w, h))?;
        // The peak: the result, the CMYK black channel and what the channels decode through.
        let black_bytes = if self.mode == ColorMode::Cmyk && want > 3 { 4 * n as u64 } else { 0 };
        let transient = if matches!(comp, 2 | 3) { (size as u64).saturating_mul(want as u64) } else { size as u64 };
        budget.check((16 * n as u64).saturating_add(black_bytes).saturating_add(transient))?;
        // Opaque black until a channel says otherwise.
        let mut data = budget.filled(n, [0.0f32, 0.0, 0.0, 1.0])?;
        let mut black = if self.mode == ColorMode::Cmyk && want > 3 { Some(budget.filled(n, 0.0f32)?) } else { None };
        let mut stream = self.open_planes(comp, &mut r, nch, want, (w, h), &mut budget)?;
        for c in 0..want {
            let raw = self.decode_plane(comp, &mut stream, &mut r, c, (w, h), &mut budget)?;
            self.store_merged_channel(c, &raw, &mut data, &mut black);
            release_bytes(&mut budget, raw);
        }
        for (i, p) in data.iter_mut().enumerate() {
            let k = black.as_ref().and_then(|k| k.get(i)).copied().unwrap_or(0.0);
            let [r, g, b] = self.rgb_from([p[0], p[1], p[2], k]);
            *p = [r, g, b, p[3]];
        }
        Ok(Pixels { width: w as u32, height: h as u32, data })
    }

    /// One layer's pixels with its layer mask (and vector-less fill colour) applied to alpha.
    /// `canvas`: document-sized with the layer in place; otherwise the layer's own bounds.
    pub fn layer_pixels(&self, index: usize, canvas: bool) -> Result<Pixels> {
        self.layer_pixels_with_budget(index, canvas, DECODE_BUDGET)
    }

    /// [`Self::layer_pixels`] with at most `limit` bytes live at once: the result (16 bytes a
    /// pixel) with the channels written straight into it, the CMYK black channel, the one channel
    /// being decoded, and the mask.
    pub(crate) fn layer_pixels_with_budget(&self, index: usize, canvas: bool, limit: u64) -> Result<Pixels> {
        let mut budget = Budget::new(limit);
        let l = self.layers.get(index).ok_or_else(|| Error::Invalid(format!("no layer {index}")))?;
        let doc = Rect { top: 0, left: 0, bottom: self.height as i32, right: self.width as i32 };
        // Fill layers often have no pixel data: they cover the canvas (or the mask).
        let fill_rect =
            if l.fill.is_some() && !l.has_pixels() { l.mask.filter(|m| !m.rect.is_empty() && m.default_color == 0).map_or(doc, |m| m.rect) } else { l.rect };
        let out_rect = if canvas {
            doc
        } else if fill_rect.is_empty() {
            Rect { top: 0, left: 0, bottom: 1, right: 1 }
        } else {
            fill_rect
        };
        let (ow, oh) = (out_rect.width() as usize, out_rect.height() as usize);
        let n = decode_pixels(ow, oh)?;
        let src = fill_rect;
        let (sw, sh) = (src.width() as usize, src.height() as usize);
        // The peak: the result, then either the CMYK black channel with the channel being decoded,
        // or the mask as floats with its bytes. Checked before anything is allocated.
        let plane = |w: usize, h: usize| (self.row_bytes(w) as u64).saturating_mul(h as u64);
        let mut pixels_peak = 0u64;
        if l.has_pixels() && sw > 0 && sh > 0 {
            pixels_peak = plane(sw, sh).saturating_add(if self.mode == ColorMode::Cmyk { 4 * n as u64 } else { 0 });
        }
        let mut mask_peak = 0u64;
        if let Some(m) = l.mask.filter(|m| !m.disabled) {
            let (mw, mh) = (m.rect.width() as usize, m.rect.height() as usize);
            if mw > 0 && mh > 0 && l.channels.iter().any(|c| c.id == -2) {
                mask_peak = plane(mw, mh).saturating_add((mw as u64).saturating_mul(mh as u64).saturating_mul(4));
            }
        }
        budget.check((16 * n as u64).saturating_add(pixels_peak.max(mask_peak)))?;
        let mut out = budget.filled(n, [0.0f32; 4])?;
        if sw > 0 && sh > 0 {
            // The source rows / columns that land inside the output (64-bit: file bounds can span
            // the whole i32 range).
            let span = |s0: i32, n: usize, o0: i32, on: usize| {
                let off = i64::from(o0) - i64::from(s0);
                let lo = off.clamp(0, n as i64);
                let hi = (off + on as i64).clamp(lo, n as i64);
                (lo as usize..hi as usize, off)
            };
            let (ys, oy) = span(src.top, sh, out_rect.top, oh);
            let (xs, ox) = span(src.left, sw, out_rect.left, ow);
            let dest = |y: usize, x: usize| (y as i64 - oy) as usize * ow + (x as i64 - ox) as usize;
            let fill = l.fill.map(|c| c.map(|v| v as f32));
            match fill {
                Some(f) if !l.has_pixels() => {
                    for y in ys {
                        for x in xs.clone() {
                            if let Some(p) = out.get_mut(dest(y, x)) {
                                *p = [f[0], f[1], f[2], 1.0];
                            }
                        }
                    }
                }
                _ => {
                    // Opaque unless there is an alpha channel.
                    for y in ys.clone() {
                        for x in xs.clone() {
                            if let Some(p) = out.get_mut(dest(y, x)) {
                                p[3] = 1.0;
                            }
                        }
                    }
                    let cc = self.mode.color_channels();
                    let mut black: Option<Vec<f32>> = None;
                    if l.has_pixels() {
                        for c in &l.channels {
                            let slot = match c.id {
                                -1 => 3,
                                id if id >= 0 && (id as usize) < cc => id as usize,
                                _ => continue,
                            };
                            let raw = self.channel_bytes(c.offset, c.len, sw, sh, &mut budget)?;
                            // The fourth CMYK channel is the black plate, not a slot of the result.
                            let to_black = c.id == 3;
                            if to_black && black.is_none() {
                                black = Some(budget.filled(out.len(), 0.0f32)?);
                            }
                            // Samples arrive in row-major order of the source.
                            let (mut sy, mut sx) = (0usize, 0usize);
                            self.for_each_sample(&raw, sw, sh, |_, v| {
                                if ys.contains(&sy) && xs.contains(&sx) {
                                    let d = dest(sy, sx);
                                    if to_black {
                                        if let Some(o) = black.as_mut().and_then(|k| k.get_mut(d)) {
                                            *o = v;
                                        }
                                    } else if let Some(p) = out.get_mut(d) {
                                        p[slot] = v;
                                    }
                                }
                                sx += 1;
                                if sx == sw {
                                    sx = 0;
                                    sy += 1;
                                }
                            });
                            release_bytes(&mut budget, raw);
                        }
                    }
                    for y in ys {
                        for x in xs.clone() {
                            let d = dest(y, x);
                            let k = black.as_ref().and_then(|k| k.get(d)).copied().unwrap_or(0.0);
                            if let Some(p) = out.get_mut(d) {
                                let [r, g, b] = self.rgb_from([p[0], p[1], p[2], k]);
                                *p = [r, g, b, p[3]];
                            }
                        }
                    }
                    if let Some(k) = black {
                        budget.release(k.len() as u64 * 4);
                    }
                }
            }
        }
        self.apply_layer_mask(l, out_rect, &mut out, &mut budget)?;
        Ok(Pixels { width: ow as u32, height: oh as u32, data: out })
    }

    /// Apply the raster mask to alpha, including its default outside the mask bounds.
    fn apply_layer_mask(&self, l: &Layer, out_rect: Rect, out: &mut [[f32; 4]], budget: &mut Budget) -> Result<()> {
        let (ow, oh) = (out_rect.width() as usize, out_rect.height() as usize);
        // Layer mask: multiplies alpha (also outside the mask rect, by its default colour).
        if let Some(m) = l.mask.filter(|m| !m.disabled) {
            let mc = l.channels.iter().find(|c| c.id == -2);
            let (mw, mh) = (m.rect.width() as usize, m.rect.height() as usize);
            let mask = match mc {
                Some(c) if mw > 0 && mh > 0 => Some(self.channel_floats(c.offset, c.len, mw, mh, budget)?),
                _ => None,
            };
            let def = m.default_color as f32 / 255.0;
            // The factor outside the mask rect, or everywhere when there is no mask data.
            let outside = if m.inverted { 1.0 - def } else { def };
            let scale = |px: &mut [[f32; 4]], v: f32| {
                if v != 1.0 {
                    for p in px {
                        p[3] *= v;
                    }
                }
            };
            match &mask {
                None => scale(out, outside),
                Some(mk) => {
                    // The columns of the output that fall inside the mask rect (the same for every row).
                    let lo = (i64::from(m.rect.left) - i64::from(out_rect.left)).clamp(0, ow as i64);
                    let hi = (i64::from(m.rect.right) - i64::from(out_rect.left)).clamp(lo, ow as i64);
                    let (lo, hi) = (lo as usize, hi as usize);
                    for (y, row) in out.chunks_exact_mut(ow.max(1)).take(oh).enumerate() {
                        let py = i64::from(out_rect.top) + y as i64;
                        #[cfg(test)]
                        counters::bump(&counters::INSIDE);
                        if py < i64::from(m.rect.top) || py >= i64::from(m.rect.bottom) {
                            scale(row, outside);
                            continue;
                        }
                        let (left, rest) = row.split_at_mut(lo);
                        let (mid, right) = rest.split_at_mut(hi - lo);
                        scale(left, outside);
                        scale(right, outside);
                        // The mask row under `mid`: its first column is output column `lo`.
                        let base = (py - i64::from(m.rect.top)) as usize * mw + (i64::from(out_rect.left) + lo as i64 - i64::from(m.rect.left)) as usize;
                        for (i, p) in mid.iter_mut().enumerate() {
                            let v = mk.get(base + i).copied().unwrap_or(def);
                            p[3] *= if m.inverted { 1.0 - v } else { v };
                        }
                    }
                }
            }
        }
        Ok(())
    }
}

/// The pixel data of a run of planes, as prepared by `Psd::open_planes`.
enum PlaneStream {
    Raw,
    /// RLE row byte counts of every plane, plane after plane.
    Rle(Vec<usize>),
    /// The inflated ZIP data of all planes.
    Zip(Vec<u8>),
}

/// PackBits decoding of one row (appends exactly `row` bytes, zero-padded).
pub(crate) fn unpack_bits(src: &[u8], row: usize, out: &mut Vec<u8>) -> Result<()> {
    let start = out.len();
    let mut i = 0;
    while i < src.len() && out.len() - start < row {
        let n = src[i] as i8;
        i += 1;
        if n >= 0 {
            let k = n as usize + 1;
            let s = src.get(i..i + k).ok_or(Error::Truncated)?;
            out.extend_from_slice(s);
            i += k;
        } else if n != -128 {
            let k = (1 - n as isize) as usize;
            let v = *src.get(i).ok_or(Error::Truncated)?;
            out.extend(std::iter::repeat_n(v, k));
            i += 1;
        }
    }
    out.resize(start + row, 0);
    Ok(())
}

/// PackBits encoding of one row.
pub(crate) fn pack_bits(src: &[u8]) -> Vec<u8> {
    let mut out = vec![];
    let mut i = 0;
    while i < src.len() {
        // run of identical bytes
        let mut run = 1;
        while i + run < src.len() && src[i + run] == src[i] && run < 128 {
            run += 1;
        }
        if run >= 2 {
            out.push((1 - run as isize) as i8 as u8);
            out.push(src[i]);
            i += run;
            continue;
        }
        // literal run
        let start = i;
        let mut n = 0;
        while i < src.len() && n < 128 {
            if i + 1 < src.len() && src[i + 1] == src[i] {
                break;
            }
            i += 1;
            n += 1;
        }
        if n == 0 {
            i += 1;
            n = 1;
        }
        out.push((n - 1) as u8);
        out.extend_from_slice(&src[start..start + n]);
    }
    out
}

pub(crate) fn srgb_encode(v: f32) -> f32 {
    if v <= 0.003_130_8 { v * 12.92 } else { 1.055 * v.powf(1.0 / 2.4) - 0.055 }
}

/// CIE L*a*b* (D50) to sRGB (D65 via the Bradford-adapted matrix), clamped.
pub(crate) fn lab_to_rgb(l: f32, a: f32, b: f32) -> [f32; 3] {
    let fy = (l + 16.0) / 116.0;
    let fx = fy + a / 500.0;
    let fz = fy - b / 200.0;
    let f = |t: f32| if t > 6.0 / 29.0 { t * t * t } else { 3.0 * (6.0f32 / 29.0).powi(2) * (t - 4.0 / 29.0) };
    let (x, y, z) = (0.964_22 * f(fx), f(fy), 0.825_21 * f(fz));
    // XYZ (D50) → linear sRGB.
    let r = 3.133_856 * x - 1.616_867 * y - 0.490_615 * z;
    let g = -0.978_768 * x + 1.916_142 * y + 0.033_454 * z;
    let bb = 0.071_945 * x - 0.228_991 * y + 1.405_243 * z;
    [r, g, bb].map(|v| srgb_encode(v.clamp(0.0, 1.0)))
}