cmx 0.2.0

// SPDX-License-Identifier: Apache-2.0 OR MIT
// Copyright (c) 2021-2026, Harbers Bik LLC
#![allow(unused)]

use crate::{
    profile::{ProfileTagRecord, RawProfile},
    tag::{
        self,
        tagdata::{CurveData, ParametricCurveData, TagData},
        Tag, TagSignature,
    },
};

/// Provides uniform access to the underlying [`RawProfile`] from any profile
/// wrapper type or from the [`Profile`](super::Profile) enum.
///
/// This trait is implemented for [`RawProfile`] itself, for every device-class
/// wrapper ([`DisplayProfile`](super::DisplayProfile), etc.), and for the
/// [`Profile`](super::Profile) enum, allowing the builder API to work generically
/// over all of them.
pub trait HasRawProfile {
    fn raw(&self) -> &RawProfile;
    fn raw_mut(&mut self) -> &mut RawProfile;
}

// Implement for RawProfile itself.
impl HasRawProfile for RawProfile {
    fn raw(&self) -> &RawProfile {
        self
    }
    fn raw_mut(&mut self) -> &mut RawProfile {
        self
    }
}

// Implement for all wrapper profiles.
impl HasRawProfile for super::InputProfile {
    fn raw(&self) -> &RawProfile {
        &self.0
    }
    fn raw_mut(&mut self) -> &mut RawProfile {
        &mut self.0
    }
}
impl HasRawProfile for super::DisplayProfile {
    fn raw(&self) -> &RawProfile {
        &self.0
    }
    fn raw_mut(&mut self) -> &mut RawProfile {
        &mut self.0
    }
}
impl HasRawProfile for super::OutputProfile {
    fn raw(&self) -> &RawProfile {
        &self.0
    }
    fn raw_mut(&mut self) -> &mut RawProfile {
        &mut self.0
    }
}
impl HasRawProfile for super::DeviceLinkProfile {
    fn raw(&self) -> &RawProfile {
        &self.0
    }
    fn raw_mut(&mut self) -> &mut RawProfile {
        &mut self.0
    }
}
impl HasRawProfile for super::AbstractProfile {
    fn raw(&self) -> &RawProfile {
        &self.0
    }
    fn raw_mut(&mut self) -> &mut RawProfile {
        &mut self.0
    }
}
impl HasRawProfile for super::ColorSpaceProfile {
    fn raw(&self) -> &RawProfile {
        &self.0
    }
    fn raw_mut(&mut self) -> &mut RawProfile {
        &mut self.0
    }
}
impl HasRawProfile for super::NamedColorProfile {
    fn raw(&self) -> &RawProfile {
        &self.0
    }
    fn raw_mut(&mut self) -> &mut RawProfile {
        &mut self.0
    }
}
impl HasRawProfile for super::SpectralProfile {
    fn raw(&self) -> &RawProfile {
        &self.0
    }
    fn raw_mut(&mut self) -> &mut RawProfile {
        &mut self.0
    }
}

// Implement for the enum Profile.
impl HasRawProfile for super::Profile {
    fn raw(&self) -> &RawProfile {
        self.as_raw_profile()
    }
    fn raw_mut(&mut self) -> &mut RawProfile {
        super::Profile::as_raw_profile_mut(self)
    }
}

/// Marker trait for tag signatures whose data is stored as a
/// `MultiLocalizedUnicodeData` (ICC type `mluc`).
///
/// Implemented for: `CopyrightTag`, `ProfileDescriptionTag`,
/// `DeviceMfgDescTag`, `DeviceModelDescTag`, `ViewingCondDescTag`.
pub trait IsMultiLocalizedUnicodeTag {}
impl IsMultiLocalizedUnicodeTag for crate::tag::tags::CopyrightTag {}
impl IsMultiLocalizedUnicodeTag for crate::tag::tags::ProfileDescriptionTag {}
impl IsMultiLocalizedUnicodeTag for crate::tag::tags::DeviceMfgDescTag {}
impl IsMultiLocalizedUnicodeTag for crate::tag::tags::DeviceModelDescTag {}
impl IsMultiLocalizedUnicodeTag for crate::tag::tags::ViewingCondDescTag {}
#[cfg(feature = "v5")]
impl IsMultiLocalizedUnicodeTag for crate::tag::tags::ScreeningDescTag {}

/// Marker trait for tags whose data is stored as `DictData` (ICC type `dict`).
///
/// Only the `MetadataTag` (`meta`, ICC v4.4+) uses `dictType`.
pub trait IsDictTag {}
impl IsDictTag for crate::tag::tags::MetadataTag {}

/// Marker trait for tone-reproduction-curve tags whose data is stored as a
/// `CurveData` (ICC type `curv`): `RedTRCTag`, `GreenTRCTag`,
/// `BlueTRCTag`, `GrayTRCTag`.
pub trait IsCurveTag {}
impl IsCurveTag for crate::tag::tags::BlueTRCTag {}
impl IsCurveTag for crate::tag::tags::GreenTRCTag {}
impl IsCurveTag for crate::tag::tags::RedTRCTag {}
impl IsCurveTag for crate::tag::tags::GrayTRCTag {}

/// Marker trait for tone-reproduction-curve tags whose data is stored as a
/// `ParametricCurveData` (ICC type `para`): `RedTRCTag`, `GreenTRCTag`,
/// `BlueTRCTag`, `GrayTRCTag`.
pub trait IsParametricCurveTag {}
impl IsParametricCurveTag for crate::tag::tags::BlueTRCTag {}
impl IsParametricCurveTag for crate::tag::tags::GreenTRCTag {}
impl IsParametricCurveTag for crate::tag::tags::RedTRCTag {}
impl IsParametricCurveTag for crate::tag::tags::GrayTRCTag {}

/// Marker trait for tags whose data is stored as a `SignatureData`
/// (ICC type `sig `): `TechnologyTag`,
/// `ColorimetricIntentImageStateTag`, `PerceptualRenderingIntentGamutTag`.
pub trait IsSignatureTag {}
impl IsSignatureTag for crate::tag::tags::ColorimetricIntentImageStateTag {}
impl IsSignatureTag for crate::tag::tags::TechnologyTag {}
#[cfg(feature = "v5")]
impl IsSignatureTag for crate::tag::tags::SaturationRenderingIntentGamutTag {}
impl IsSignatureTag for crate::tag::tags::PerceptualRenderingIntentGamutTag {}

/// Marker trait for tags whose data is stored as an `XYZArrayData`
/// (ICC type `XYZ `): matrix column tags, luminance, white-point, black-point.
pub trait IsXYZArrayTag {}
impl IsXYZArrayTag for crate::tag::tags::RedMatrixColumnTag {}
impl IsXYZArrayTag for crate::tag::tags::GreenMatrixColumnTag {}
impl IsXYZArrayTag for crate::tag::tags::BlueMatrixColumnTag {}
impl IsXYZArrayTag for crate::tag::tags::LuminanceTag {}
impl IsXYZArrayTag for crate::tag::tags::MediaWhitePointTag {}
impl IsXYZArrayTag for crate::tag::tags::MediaBlackPointTag {}

/// Marker trait for tags whose data is stored as a `TextDescriptionData`
/// (legacy ICC v2 type `desc`).
pub trait IsTextDescriptionTag {}
impl IsTextDescriptionTag for crate::tag::tags::ProfileDescriptionTag {}
impl IsTextDescriptionTag for crate::tag::tags::CopyrightTag {}
impl IsTextDescriptionTag for crate::tag::tags::DeviceMfgDescTag {}
impl IsTextDescriptionTag for crate::tag::tags::DeviceModelDescTag {}
#[cfg(feature = "v5")]
impl IsTextDescriptionTag for crate::tag::tags::ScreeningDescTag {}
impl IsTextDescriptionTag for crate::tag::tags::ViewingCondDescTag {}

/// Marker trait for tags whose data is stored as plain ASCII `TextData`
/// (ICC type `text`): `CopyrightTag`, `CharTargetTag`.
pub trait IsTextTag {}
impl IsTextTag for crate::tag::tags::CopyrightTag {}
impl IsTextTag for crate::tag::tags::CharTargetTag {}

/// Marker trait for tags whose data is stored as an `S15Fixed16ArrayData`
/// (ICC type `sf32`): `ChromaticAdaptationTag`.
pub trait IsS15Fixed16ArrayTag {}
impl IsS15Fixed16ArrayTag for crate::tag::tags::ChromaticAdaptationTag {}

/// Marker trait for tags whose data is stored as `Lut8Data` (ICC type `mft1`).
pub trait IsLut8DataTag {}
/// Marker trait for tags whose data is stored as `Lut16Data` (ICC type `mft2`).
pub trait IsLut16DataTag {}
/// Marker trait for tags whose data uses the `LutAtoB` format (ICC type `mAB `).
pub trait IsLutAtoBDataTag {}
/// Marker trait for tags whose data uses the `LutBtoA` format (ICC type `mBA `).
pub trait IsLutBtoADataTag {}

/// Marker trait for the Apple `mmod` (Make and Model) tag whose data is stored
/// as `MakeAndModelData`: `MakeAndModelTag`.
pub trait IsMakeAndModelTag {}
impl IsMakeAndModelTag for crate::tag::tags::MakeAndModelTag {}

/// Marker trait that allows any tag to be set using raw bytes via
/// [`TagSetter::as_raw`].  Implemented for all tag signatures.
pub trait IsRawTag {}

/// An intermediate builder returned by [`with_tag`](super::Profile::with_tag) that
/// provides type-safe methods for setting the data of a specific ICC tag.
///
/// `TagSetter<P, S>` is generic over:
/// - `P` — the profile type being built (e.g. [`DisplayProfile`](super::DisplayProfile),
///   [`Profile`](super::Profile), or [`RawProfile`]).
/// - `S` — the tag signature type (one of the zero-sized structs in
///   [`cmx::tag::tags`](crate::tag::tags)).
///
/// Each `as_*` method is gated by a marker trait (e.g. `IsCurveTag`) that is
/// only implemented for the tag signatures where that data format is valid.
/// Attempting to call `as_curve()` on a tag signature that does not implement
/// `IsCurveTag` is a **compile-time error**, not a runtime one.
///
/// Calling an `as_*` method consumes the `TagSetter` and returns the profile `P`,
/// allowing builder chains:
///
/// ```rust
/// use cmx::profile::DisplayProfile;
/// use cmx::tag::tags::{RedTRCTag, GreenTRCTag};
///
/// let profile = DisplayProfile::new()
///     .with_tag(RedTRCTag)
///     .as_curve(|c| c.set_gamma(2.2))
///     .with_tag(GreenTRCTag)
///     .as_curve(|c| c.set_gamma(2.2));
/// ```
pub struct TagSetter<P: HasRawProfile, S> {
    profile: P,
    tag: S,
}

impl<P, S> TagSetter<P, S>
where
    P: HasRawProfile,
    S: Into<TagSignature> + Copy,
{
    pub fn new(profile: P, tag: S) -> Self {
        Self { profile, tag }
    }

    /// Sets the tag's data as a `CurveData`.
    /// This method is only available if the signature implements `IsCurveTag`.
    pub fn as_curve<F>(mut self, configure: F) -> P
    where
        S: IsCurveTag,
        F: FnOnce(&mut CurveData),
    {
        let curve = self.profile.raw_mut().ensure_curve_mut(self.tag.into());
        configure(curve);
        self.profile
    }

    /// Set the tag's data as a `ParametricCurveData` (ICC type `para`).
    ///
    /// Available for TRC tags: `RedTRCTag`, `GreenTRCTag`, `BlueTRCTag`,
    /// `GrayTRCTag`.  Use [`ParametricCurveData::set_parameters`] for a
    /// fixed-size array or [`ParametricCurveData::set_parameters_slice`] for a
    /// dynamically-sized slice (the slice variant validates the parameter count
    /// and returns a `Result`).
    pub fn as_parametric_curve<F>(mut self, configure: F) -> P
    where
        S: IsParametricCurveTag,
        F: FnOnce(&mut ParametricCurveData),
    {
        let para_curve = self
            .profile
            .raw_mut()
            .ensure_parametric_curve_mut(self.tag.into());
        configure(para_curve);
        self.profile
    }

    /// Set the tag's data as a `SignatureData` (ICC type `sig `).
    ///
    /// Available for: `TechnologyTag`, `ColorimetricIntentImageStateTag`,
    /// `PerceptualRenderingIntentGamutTag`.
    pub fn as_signature<F>(mut self, configure: F) -> P
    where
        S: IsSignatureTag,
        F: FnOnce(&mut crate::tag::tagdata::SignatureData),
    {
        let signature = self.profile.raw_mut().ensure_signature_mut(self.tag.into());
        configure(signature);
        self.profile
    }

    /// Set the tag's data as an `XYZArrayData` (ICC type `XYZ `).
    ///
    /// Available for: `RedMatrixColumnTag`, `GreenMatrixColumnTag`,
    /// `BlueMatrixColumnTag`, `LuminanceTag`, `MediaWhitePointTag`,
    /// `MediaBlackPointTag`.
    pub fn as_xyz_array<F>(mut self, configure: F) -> P
    where
        S: IsXYZArrayTag,
        F: FnOnce(&mut crate::tag::tagdata::XYZArrayData),
    {
        let xyz = self.profile.raw_mut().ensure_xyz_array_mut(self.tag.into());
        configure(xyz);
        self.profile
    }

    /// Set the tag's data as a `TextDescriptionData` (legacy ICC v2 type `desc`).
    ///
    /// Available for: `ProfileDescriptionTag`, `CopyrightTag`,
    /// `DeviceMfgDescTag`, `DeviceModelDescTag`, `ViewingCondDescTag`.
    ///
    /// For new ICC v4 profiles prefer [`as_multi_localized_unicode`](Self::as_multi_localized_unicode),
    /// which supports multiple languages.  `TextDescriptionData` is provided for
    /// compatibility with tools that require v2-style description tags.
    pub fn as_text_description<F>(mut self, configure: F) -> P
    where
        S: IsTextDescriptionTag,
        F: FnOnce(&mut crate::tag::tagdata::TextDescriptionData),
    {
        let text_description = self
            .profile
            .raw_mut()
            .ensure_text_description_mut(self.tag.into());
        configure(text_description);
        self.profile
    }

    /// Set the tag's data as plain ASCII `TextData` (ICC type `text`).
    ///
    /// Available for: `CopyrightTag`, `CharTargetTag`.
    pub fn as_text<F>(mut self, configure: F) -> P
    where
        S: IsTextTag,
        F: FnOnce(&mut crate::tag::tagdata::TextData),
    {
        let text = self.profile.raw_mut().ensure_text_mut(self.tag.into());
        configure(text);
        self.profile
    }

    /// Set the tag's data as an `S15Fixed16ArrayData` (ICC type `sf32`).
    ///
    /// Available for: `ChromaticAdaptationTag` (a 3×3 matrix stored as nine
    /// s15Fixed16 values in row-major order).
    pub fn as_sf15_fixed_16_array<F>(mut self, configure: F) -> P
    where
        S: IsS15Fixed16ArrayTag,
        F: FnOnce(&mut crate::tag::tagdata::S15Fixed16ArrayData),
    {
        let array = self
            .profile
            .raw_mut()
            .ensure_s15_fixed_16_array_mut(self.tag.into());
        configure(array);
        self.profile
    }

    /// Sets the tag's data as raw bytes.
    /// This is used for non-ICC or manufacturer private tags, with unknown data formats, It is the
    /// caller's responsibility to ensure the data is valid for the intended use.
    /// It can also be used to set the raw data for known tags, but this is not recommended,
    /// as it bypasses the type safety provided by the other methods.
    pub fn as_raw<F>(mut self, configure: F) -> P
    where
        F: FnOnce(&mut crate::tag::tagdata::RawData),
    {
        let sig: TagSignature = self.tag.into();
        let raw = self.profile.raw_mut().ensure_raw_mut(self.tag.into());

        // If the tag has no data yet (is a new tag), initialize it with the tag signature and
        // reserved bytes.  This method is intended for use with unknown tags.  If a new tag is
        // being created using this method, it will use the tag signature also as the type
        // signature.  If the tag already exists, it may already have data, in which case we do not
        // overwrite it.
        if raw.0.is_empty() {
            // Initialize with the tag signature and reserved bytes.
            let mut initial_data = Vec::with_capacity(8);
            initial_data.extend_from_slice(&sig.to_u32().to_be_bytes());
            initial_data.extend_from_slice(&[0u8; 4]); // Reserved bytes
            raw.0 = initial_data;
        }
        configure(raw);
        self.profile
    }

    /// Set the tag's data as a `DictData` (ICC type `dict`, ICC v4.4+).
    ///
    /// Available for: `MetadataTag` (`meta`).
    ///
    /// Use [`DictData::insert`](crate::tag::tagdata::DictData::insert) inside the closure to
    /// add key/value pairs.  Keys and values are Unicode strings stored as UTF-16BE.
    ///
    /// # Example
    ///
    /// ```rust
    /// use cmx::profile::DisplayProfile;
    /// use cmx::tag::tags::MetadataTag;
    ///
    /// let profile = DisplayProfile::new()
    ///     .with_tag(MetadataTag)
    ///     .as_dict(|d| {
    ///         d.insert("CMF_product", "MyApp");
    ///         d.insert("CMF_version", "1.0");
    ///     });
    ///
    /// let bytes = profile.to_bytes().unwrap();
    /// assert!(bytes.len() > 128);
    /// ```
    pub fn as_dict<F>(mut self, configure: F) -> P
    where
        S: IsDictTag,
        F: FnOnce(&mut crate::tag::tagdata::DictData),
    {
        let dict = self.profile.raw_mut().ensure_dict_mut(self.tag.into());
        configure(dict);
        self.profile
    }

    /// Set the tag's data as a `MultiLocalizedUnicodeData` (ICC type `mluc`).
    ///
    /// Available for: `CopyrightTag`, `ProfileDescriptionTag`,
    /// `DeviceMfgDescTag`, `DeviceModelDescTag`, `ViewingCondDescTag`.
    ///
    /// Use [`MultiLocalizedUnicodeData::insert`](crate::tag::tagdata::MultiLocalizedUnicodeData::insert)
    /// inside the closure to add one or more locale/string pairs.
    pub fn as_multi_localized_unicode<F>(mut self, configure: F) -> P
    where
        S: IsMultiLocalizedUnicodeTag,
        F: FnOnce(&mut crate::tag::tagdata::MultiLocalizedUnicodeData),
    {
        let mlu = self
            .profile
            .raw_mut()
            .ensure_multi_localized_unicode_mut(self.tag.into());
        configure(mlu);
        self.profile
    }

    /// Set the tag's data as Apple `MakeAndModelData` (private type `mmod`).
    ///
    /// Available for: `MakeAndModelTag`.
    ///
    /// Use [`MakeAndModelData::set_manufacturer`](crate::tag::tagdata::MakeAndModelData::set_manufacturer),
    /// [`MakeAndModelData::set_model`](crate::tag::tagdata::MakeAndModelData::set_model), and related
    /// methods inside the closure to populate the hardware identifiers.
    ///
    /// # Example
    ///
    /// ```rust
    /// use cmx::profile::DisplayProfile;
    /// use cmx::tag::tags::MakeAndModelTag;
    ///
    /// let profile = DisplayProfile::new()
    ///     .with_tag(MakeAndModelTag)
    ///     .as_make_and_model(|m| {
    ///         m.set_manufacturer(0x00004c2d);
    ///         m.set_model(0x00000587);
    ///     });
    ///
    /// let bytes = profile.to_bytes().unwrap();
    /// assert!(bytes.len() > 128);
    /// ```
    pub fn as_make_and_model<F>(mut self, configure: F) -> P
    where
        S: IsMakeAndModelTag,
        F: FnOnce(&mut crate::tag::tagdata::MakeAndModelData),
    {
        let mmod = self
            .profile
            .raw_mut()
            .ensure_make_and_model_mut(self.tag.into());
        configure(mmod);
        self.profile
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::profile::InputProfile;
    use crate::tag::tags::*;
    #[test]
    fn test_tag_setter() -> Result<(), Box<dyn std::error::Error>> {
        let mut profile = InputProfile::new();

        profile
            .with_tag(RedTRCTag)
            .as_curve(|curve| {
                curve.set_gamma(2.2);
            })
            .with_tag(GreenTRCTag)
            .as_curve(|curve| {
                curve.set_gamma(2.2);
            })
            .with_tag(BlueTRCTag)
            .as_curve(|curve| {
                curve.set_gamma(2.2);
            })
            .with_tag(GrayTRCTag)
            .as_parametric_curve(|para_curve| para_curve.set_parameters([0.5]))
            .with_tag(TechnologyTag)
            .as_signature(|signature| {
                signature.set_signature("fscn");
            });

        Ok(())
    }

    #[test]
    fn test_as_make_and_model() {
        use crate::profile::DisplayProfile;
        use crate::tag::tagdata::MakeAndModelData;
        use crate::tag::{TagDataTraits, TagSignature};

        let profile = DisplayProfile::new()
            .with_tag(MakeAndModelTag)
            .as_make_and_model(|m| {
                m.set_manufacturer(0x00004c2d);
                m.set_model(0x00000587);
                m.set_serial_number(0x4d593234);
                m.set_manufacture_date(0xc76c2600);
            });

        let sig: TagSignature = MakeAndModelTag.into();
        let data = profile.0.tags.get(&sig).unwrap().tag.data();
        let bytes = data.as_slice();

        // Type signature 'mmod' at bytes 0–3
        assert_eq!(&bytes[0..4], &0x6D6D6F64u32.to_be_bytes());
        // Reserved bytes 4–7 must be zero
        assert_eq!(&bytes[4..8], &[0u8; 4]);
        // Manufacturer at bytes 8–11
        assert_eq!(&bytes[8..12], &0x00004c2du32.to_be_bytes());
        // Model at bytes 12–15
        assert_eq!(&bytes[12..16], &0x00000587u32.to_be_bytes());
        // Serial number at bytes 16–19
        assert_eq!(&bytes[16..20], &0x4d593234u32.to_be_bytes());
        // Manufacture date at bytes 20–23
        assert_eq!(&bytes[20..24], &0xc76c2600u32.to_be_bytes());
    }
}