/*

 * // Copyright (c) Radzivon Bartoshyk 3/2025. All rights reserved.

 * //

 * // Redistribution and use in source and binary forms, with or without modification,

 * // are permitted provided that the following conditions are met:

 * //

 * // 1.  Redistributions of source code must retain the above copyright notice, this

 * // list of conditions and the following disclaimer.

 * //

 * // 2.  Redistributions in binary form must reproduce the above copyright notice,

 * // this list of conditions and the following disclaimer in the documentation

 * // and/or other materials provided with the distribution.

 * //

 * // 3.  Neither the name of the copyright holder nor the names of its

 * // contributors may be used to endorse or promote products derived from

 * // this software without specific prior written permission.

 * //

 * // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 * // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

 * // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

 * // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

 * // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

 * // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

use crate::mlaf::mlaf;

use crate::{Matrix3f, Vector3f, Xyz};

use pxfm::{f_atan2f, f_hypotf, f_sincosf};

/// Structure for Yrg colorspace

///

/// Kirk Yrg 2021.

#[repr(C)]

#[derive(Default, Debug, PartialOrd, PartialEq, Copy, Clone)]

pub struct Yrg {

    pub y: f32,

    pub r: f32,

    pub g: f32,

}

/// Structure for cone form of Yrg colorspace

#[repr(C)]

#[derive(Default, Debug, PartialOrd, PartialEq, Copy, Clone)]

pub struct Ych {

    pub y: f32,

    pub c: f32,

    pub h: f32,

}

const LMS_TO_XYZ: Matrix3f = Matrix3f {

    v: [

        [1.8079466, -1.2997167, 0.34785876],

        [0.61783963, 0.39595452, -0.041046873],

        [-0.12546961, 0.20478038, 1.7427418],

    ],

};

const XYZ_TO_LMS: Matrix3f = Matrix3f {

    v: [

        [0.257085, 0.859943, -0.031061],

        [-0.394427, 1.175800, 0.106423],

        [0.064856, -0.076250, 0.559067],

    ],

};

impl Yrg {

    #[inline]

    pub const fn new(y: f32, r: f32, g: f32) -> Yrg {

        Yrg { y, r, g }

    }

    /// Convert [Xyz] D65 to [Yrg]

    ///

    /// Yrg defined in D65 white point. Ensure Xyz values is adapted.

    /// Yrg use CIE XYZ 2006, adapt CIE XYZ 1931 by using [cie_y_1931_to_cie_y_2006] at first.

    #[inline]

    pub fn from_xyz(xyz: Xyz) -> Self {

        let lms = XYZ_TO_LMS.f_mul_vector(Vector3f {

            v: [xyz.x, xyz.y, xyz.z],

        });

        let y = mlaf(0.68990272 * lms.v[0], 0.34832189, lms.v[1]);

        let a = lms.v[0] + lms.v[1] + lms.v[2];

        let l = if a == 0. { 0. } else { lms.v[0] / a };

        let m = if a == 0. { 0. } else { lms.v[1] / a };

        let r = mlaf(mlaf(0.02062, -0.6873, m), 1.0671, l);

        let g = mlaf(mlaf(-0.05155, -0.0362, l), 1.7182, m);

        Yrg { y, r, g }

    }

    #[inline]

    pub fn to_xyz(&self) -> Xyz {

        let l = mlaf(0.95 * self.r, 0.38, self.g);

        let m = mlaf(mlaf(0.03, 0.59, self.g), 0.02, self.r);

        let den = mlaf(0.68990272 * l, 0.34832189, m);

        let a = if den == 0. { 0. } else { self.y / den };

        let l0 = l * a;

        let m0 = m * a;

        let s0 = (1f32 - l - m) * a;

        let v = Vector3f { v: [l0, m0, s0] };

        let x = LMS_TO_XYZ.f_mul_vector(v);

        Xyz {

            x: x.v[0],

            y: x.v[1],

            z: x.v[2],

        }

    }

}

impl Ych {

    #[inline]

    pub const fn new(y: f32, c: f32, h: f32) -> Self {

        Ych { y, c, h }

    }

    #[inline]

    pub fn from_yrg(yrg: Yrg) -> Self {

        let y = yrg.y;

        // Subtract white point. These are the r, g coordinates of

        // sRGB (D50 adapted) (1, 1, 1) taken through

        // XYZ D50 -> CAT16 D50->D65 adaptation -> LMS 2006

        // -> grading RGB conversion.

        let r = yrg.r - 0.21902143;

        let g = yrg.g - 0.54371398;

        let c = f_hypotf(g, r);

        let h = f_atan2f(g, r);

        Self { y, c, h }

    }

    #[inline]

    pub fn to_yrg(&self) -> Yrg {

        let y = self.y;

        let c = self.c;

        let h = self.h;

        let sincos = f_sincosf(h);

        let r = mlaf(0.21902143, c, sincos.1);

        let g = mlaf(0.54371398, c, sincos.0);

        Yrg { y, r, g }

    }

}

// Pipeline and ICC luminance is CIE Y 1931

// Kirk Ych/Yrg uses CIE Y 2006

// 1 CIE Y 1931 = 1.05785528 CIE Y 2006, so we need to adjust that.

// This also accounts for the CAT16 D50->D65 adaptation that has to be done

// to go from RGB to CIE LMS 2006.

// Warning: only applies to achromatic pixels.

pub const fn cie_y_1931_to_cie_y_2006(x: f32) -> f32 {

    1.05785528 * (x)

}

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    fn test_yrg() {

        let xyz = Xyz::new(0.95, 1.0, 1.08);

        let yrg = Yrg::from_xyz(xyz);

        let yrg_to_xyz = yrg.to_xyz();

        assert!((xyz.x - yrg_to_xyz.x) < 1e-5);

        assert!((xyz.y - yrg_to_xyz.y) < 1e-5);

        assert!((xyz.z - yrg_to_xyz.z) < 1e-5);

    }

    #[test]

    fn test_ych() {

        let xyz = Yrg::new(0.5, 0.4, 0.3);

        let yrg = Ych::from_yrg(xyz);

        let yrg_to_xyz = yrg.to_yrg();

        assert!((xyz.y - yrg_to_xyz.y) < 1e-5);

        assert!((xyz.r - yrg_to_xyz.r) < 1e-5);

        assert!((xyz.g - yrg_to_xyz.g) < 1e-5);

    }

}