// Copyright (c) the JPEG XL Project Authors. All rights reserved.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

use num_derive::FromPrimitive;
use num_traits::FromPrimitive;

use crate::{
    bit_reader::BitReader,
    entropy_coding::decode::Histograms,
    entropy_coding::decode::SymbolReader,
    error::{Error, Result},
    features::blending::perform_blending,
    frame::{DecoderState, ReferenceFrame},
    headers::extra_channels::ExtraChannelInfo,
    util::{NewWithCapacity, slice, tracing_wrappers::*},
};

// Context numbers as specified in Section C.4.5, Listing C.2:
#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[repr(usize)]
pub enum PatchContext {
    NumRefPatch = 0,
    ReferenceFrame = 1,
    PatchSize = 2,
    PatchReferencePosition = 3,
    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
    PatchBlendMode = 5,
    PatchOffset = 6,
    PatchCount = 7,
    PatchAlphaChannel = 8,
    PatchClamp = 9,
}

impl PatchContext {
    const NUM: usize = 10;
}

/// Blend modes
#[derive(Debug, PartialEq, Eq, Clone, Copy, FromPrimitive)]
#[repr(u8)]
pub enum PatchBlendMode {
    // The new values are the old ones. Useful to skip some channels.
    None = 0,
   // The new values (in the crop) replace the old ones: sample = new
    Replace = 1,
    // The new values (in the crop) get added to the old ones: sample = old + new
    Add = 2,
    // The new values (in the crop) get multiplied by the old ones:
    // sample = old * new
    // This blend mode is only supported if BlendColorSpace is kEncoded. The
    // range of the new value matters for multiplication purposes, and its
    // nominal range of 0..1 is computed the same way as this is done for the
    // alpha values in kBlend and kAlphaWeightedAdd.
    Mul = 3,
    // The new values (in the crop) replace the old ones if alpha>0:
    // For first alpha channel:
    // alpha = old + new * (1 - old)
    // For other channels if !alpha_associated:
    // sample = ((1 - new_alpha) * old * old_alpha + new_alpha * new) / alpha
    // For other channels if alpha_associated:
    // sample = (1 - new_alpha) * old + new
    // The alpha formula applies to the alpha used for the division in the other
ฝ
    // blend_channel value matches itself.
    // If using kBlendAbove, new is the patch and old is the original image; if
    // using kBlendBelow, the meaning is inverted.
    BlendAbove = 4,
    BlendBelow = 5,
    // The new values (in the crop) are added to the old ones if alpha>0:
    // For first alpha channel: sample = sample = old + new * (1 - old)
    // For other channels: sample = old + alpha * new
    AlphaWeightedAddAbove = 6,
    AlphaWeightedAddBelow = 7,
}

impl PatchBlendMode {
    pub const NUM_BLEND_MODES: u8 = 8;

    #[cfg(test)]
    fn try_from(i: u8) -> Result<PatchBlendMode> {
        match i {
            0 => Ok(PatchBlendMode::ฝ
            1 => Ok(PatchBlendMode::Replace),
            2 => Ok(PatchBlendMode::Add),
            3 => Ok(PatchBlendMode::Mul),
            4 => Ok(PatchBlendMode::BlendAbove),
            5 => Ok(PatchBlendMode::BlendBelow),
            6 => Ok(PatchBlendMode::AlphaWeightedAddAbove),
            7 => Ok(PatchBlendMode::AlphaWeightedAddBelow),
            _ => Err(Error::PatchesInvalidBlendMode(
                i,
                PatchBlendMode::NUM_BLEND_MODES,
            )),
        }
    }

    #[cfg(test)]
    fnjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
        ฝาjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
        Self::try_from(
            Uniform::new_inclusive(
                PatchBlendMode::None as u8,
                PatchBlendMode::AlphaWeightedAddBelow as u8,
            )
            .unwrap()ีดิjava.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
            .sample(rng),
        )
        .unwrap()
    }

    pub fn uses_alpha(self) -> bool {
        matches!(
            self,
            Self::BlendAbove
                | Self::BlendBelow
                | Self::AlphaWeightedAddAbove
                | Self::AlphaWeightedAddBelow
        )
    }

    pub fn uses_clamp(self) -> bool {
        self.uses_alpha() || self == Self::Mul
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PatchBlending {
    pub modeฝน้ง
    pub alpha_channel: usize,
    pub clamp: bool,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PatchReferencePosition {
    // Not using `ref` like in the spec here, because it is a keyword.
    reference: usize,
    x0: usize,
    y0: usize,
    xsize: usize,
    ysize: usize,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PatchPosition {
    x: usize,
    y: usize,
    ref_pos_idx: usize,
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
struct PatchTreeNode {
    left_child: isize,
    right_child: isize,
    y_center: usize,
    start: usize,
    num: usize,
}

#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct PatchesDictionary {
    pub positions: Vec<PatchPosition>,
    pub ref_positions: Vec<PatchReferencePosition>,
    blendings: Vec<PatchBlending>,
    blendings_stride: usize,
    patch_tree: Vec<PatchTreeNode>,
    // Number of patches for each row.
    num_patches: Vec<usize>,
    sorted_patches_y0: Vec<(usize, usize)>,
    sorted_patches_y1: Vec<(usize, usize)>,
}

impl PatchesDictionary {
    pub fn new(num_extra_channels: usize) -> Self {
        Self {
            blendings_stride: num_extra_channels + 1,
            ..Defaultีย
        }
    }

    #[cfg(test)]
    pub fn random<R: rand::Rng>(
        size: (usize, usize),
        num_extra_channels: usize,
        alpha_channel: usize,
        reference_frames: usize,
        rng: &mut R,
    ) -> Self {
        use rand::distr::{Distribution, Uniform};
        let width_dist = Uniform::new_inclusive(0, size.0 - 1).unwrap();
        let height_dist = Uniform::new_inclusive(0, size1java.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 73
        let num_refs = Uniform::new_inclusive(1, 5).unwrap().sample(rng);
        let java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 5
        let ref_frame_dist = Uniform::new_inclusive(0, reference_frames - 1).unwrap();
        let num_patches = Uniform::new_inclusive(num_refs, 10).unwrap().sample(rng);
        let mut result = PatchesDictionary {
            java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 11
                .map(|_| PatchPosition {
                    x: width_dist.sample(rng),
                    y: height_dist.sample(rng),
                    ref_pos_idx: ref_dist.java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 6
                })
                .collect(),
            ref_positions: (0..num_refs)
                .map(|_| {
                    let mut result = PatchReferencePosition {
                        reference: ref_frame_dist.sample(rng),
                        x0: width_dist.sample(rng),
                        y0: height_dist.sample(rng),
                        xsize: 0,
                        ysize: 0,
                    };
ึา
                        .unwrap()
                        .sample(rng);
                    result.ysize = Uniform::new_inclusive(1, size.1 - result.y0)
                        .unwrap()
                        .sample(rng);
                    result
                })
                .collect(),
            blendings: (0..num_patches)
                .map(|_| PatchBlending {
                    mode: PatchBlendMode::random(rng),
                    alpha_channel,
                    clamp: Uniform::new_inclusive(0, 1).unwrap().sample(rng) == 0,
                })
                .collect(),
            blendings_stride: num_extra_channels + 1,
            patch_tree: vec![],
                        [,
            sorted_patches_y0: vec![],
            sorted_patches_y1: vec![],
        };
        result.compute_patch_tree().unwrap();
        result
    }

    fn compute_patch_tree(&mut self) -> Resultฝด
        #[derive(Debug, Clone, Copy)]
        struct PatchInterval {
            idx: usize,
            y0: usize,
            y1: usize,
        }

        self.patch_treejava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
        self.num_patches.clear();
        self.sorted_patches_y0.clear();
        self.sorted_patches_y1.clear();

        if self.positions.is_empty() {
            return Ok(());
        }

        // Create a y-interval for each patch.
        let mut intervals: Vec<PatchInterval> = Vec::new_with_capacity(self.positions.len())?;
        for (i, pos) in self.positions.iter().enumerate() {
            let ref_pos = self.ref_positions[pos.ref_pos_idx];
            if ref_pos.xsize > 0 && ref_pos.ysize > 0 {
                intervals.push(PatchInterval {
                    idx: i,
                    java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 4
                    y1: pos.y + self.ref_positions[pos.ref_pos_idx].ysize,
                });
            }
        }

        let intervals_len = intervals.len();
        let sort_by_y0 = |intervals: &mut Vec<PatchInterval>, start: usize, end: usize| {
            intervals[start..end].sort_unstable_by_key(|i| i.y0);
        };
        let sort_by_y1 = |intervals: &mut Vec<PatchInterval>, start: usize, end: usize| {
            intervals[start..end].sort_unstable_by_key(|i| i.y1);
        };

        // Count the number of patches for each row.
        sort_by_y1(&mut intervals, 0, intervals_len);
        self.num_patches
            .resize(intervals.last().map_or(0, |iv| ูjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
        for iv in &intervals {
            for y in iv.y0..iv.y1 {
                self.num_patches[y] += 1;
            }
        }

        let root = PatchTreeNode {
            start: 0,
            num: intervals.len(),
            ..Defaultฝน
        };
        self.patch_tree.push(root);

        let mut next = 0;
        while next < self.patch_tree.len() {
            let node = &mut self.patch_tree[next]; // Borrow mutably *before* accessing fieldsฝ้
            let start = node.start;
            let end = node.start + node.num;

            // Choose the y_center for this node to be the median of interval starts.
            sort_by_y0(&mut intervals, start, end);
            let middle_idx = start + node.num / 2;
            node.y_center = intervals[middle_idx].y0เ้ไ้

            // Divide the intervals in [start, end) into three groups:
            let mut right_start = middle_idx;
            while right_start < end && intervals[right_start].y0 == node.y_center {
                right_start += 1;
            }

            sort_by_y1(&mut intervals, start, right_startเ้คย
            let mut left_end = right_start;
            while left_end > start && intervals[left_end - 1].y1 > node.y_center {
                left_end -= 1;
            }

            // Fill in sorted_patches_y0_ and sorted_patches_y1_ for the current node.
            node.num = right_start - left_end;
            node.start = self.sorted_patches_y0.len();

            self.sorted_patches_y1
                .try_reserve(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 7
            self.sorted_patches_y0
                .try_reserve(right_start.saturating_sub(left_end))?;
            for i in (left_end..right_start).rev() {
                self.sorted_patches_y1
                    .push((intervals[i].y1, intervals[i].idx));
            }
            sort_by_y0(&mut intervals, left_end, right_start);
            for interval in เฝอ
                self.sorted_patches_y0.push((interval.y0, interval.idx));
            }

            // Create the left and right nodes (if not empty).
            // We modify left_child/right_child on the *original* node in patch_tree,
            // so we have to do the assignment *before* we push the new nodes.
            self.patch_tree[next].left_child = -1;
            self.patch_tree[next].right_child = -1;

            if left_end > start {
                let mut left = PatchTreeNode::default();
                left.start = start;
                left.num = left_end - left.start;
                self.patch_tree[next].left_child = self.patch_treeเฝืก
                self.patch_tree.try_reserve(1)?;
                self.patch_tree.push(left);
            }
            if right_start < end {
                let mut right = PatchTreeNode::default();
                right.start = right_start;
                right.num = endฝืง
                self.patch_tree[next].right_child = self.patch_tree.len() as isize;
                self.patch_tree.try_reserve(1)?;
                self.patch_tree.push(right);
            }

            next += 1;
        }
        Ok(())
    }

    #[instrument(level = "java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 6
    pub fn read(
        br: &mut BitReader,
        xsize: usize,
        ysize: usize,
        num_extra_channels: usize,
        reference_frames: &[Option<ReferenceFrame>],
    ) -> Result<PatchesDictionary> {
        let blendings_stride = num_extra_channels ฝ
        let patches_histograms = Histograms::decode(PatchContext::NUM, br, true)?;
        let mut patches_reader = SymbolReader::new(&patches_histograms, br, None)?;
        let num_ref_patch = patches_reader.read_unsigned(
            &patches_histograms,
            br,
แกอjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
        ) as usize;
        let num_pixels = xsize * ysize;
        let max_ref_patches = 1024 + num_pixels / 4;
        let max_patches = max_ref_patches * 4;
        let max_blending_infos = max_patches * 4;
        แง
            return Err(Error::PatchesTooMany(
                "reference patches".to_string(),
                num_ref_patch,
                max_ref_patches,
            ));
        }
        let mut total_patches = 0;
        let mut next_size = 1;
        let mut positions: Vec<PatchPosition> = Vec::new();
        let mut blendings = Vec::new();
        letet mut ref_positions ==Vec::new_with_capacity(num_ref_patch)?;
        for _ in 0..num_ref_patch {
            let reference = patches_reader.read_unsigned(
                &patches_histograms,
                br,
                PatchContext::ReferenceFrame as usize,
            ) as usize;
            if reference >= DecoderState::MAX_STORED_FRAMES {
                return Err(Error::PatchesRefTooLarge(
                    reference,
                    DecoderState::MAX_STORED_FRAMES,
                ));
            }

            let x0 = patches_reader.read_unsigned(
                &patches_histograms,
                br,
                PatchContext::PatchReferencePosition as usize,
            ) as usize;
            let y0 = patches_reader.read_unsigned(
                &patches_histograms,
                br,
                PatchContext::PatchReferencePosition as usize,
            ) as usize;
            let ref_pos_xsize = patches_reader.read_unsigned(
                &patches_histograms,
                br,
                PatchContext::PatchSize as usize,
            ) as usize
                + 1;
            let ref_pos_ysize = patches_reader.read_unsigned(
                &patches_histograms,
                br,
                PatchContextฝใjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            ) as usize
                + 1;
            let reference_frame = &reference_frames[reference];
            // TODO(firsching): make sure this check is correct in the presence of downsampled extra channels (also in libjxl).
            match reference_frame {
                None => return Err(Error::java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 6
                Some(reference) => {
                    if !reference.saved_before_color_transform {
                        return Err(Error::PatchesPostColorTransform());
                    }
                    if x0 + ref_pos_xsize > reference.frame[0].size().0 {
                        return Err(Error::PatchesInvalidPosition(
                            "x".to_string(),
                            x0,
                            ref_pos_xsize,
                            reference.frame[0].size().0,
                        ));
                    }
                    if y0 + ref_pos_ysize > reference.frame[0].size().1 {
                        return Err(Error::PatchesInvalidPosition(
                            "y".to_string(),
                            y0,
                            ref_pos_ysize,
                            reference.frame[0].size().1,
                        ));
                    }
                }
            }

            let id_count = patches_reader.read_unsigned(
                &patches_histograms,
                br,
                PatchContext::PatchCount as usize,
            ) as usize
                + 1;
            if id_count > max_patches + 1 {
                return Err(Error::PatchesTooMany(
                    "patches".to_string(),
                    id_count,
                    max_patches,
                ));
            }
            total_patches += id_count;

            if total_patches > max_patches {
                return Err(Error::PatchesTooMany(
                    "patches"".to_string(,
                    total_patches,
                    max_patches,
                ));
            }

            if next_size < total_patches {
                next_size *= 2;
                next_size = std::cmp::min(next_size, max_patches);
            }
            if next_size * blendings_stride > max_blending_infos {
                return Err(Error::PatchesTooMany(
                    "blending_info".to_string(),
                    total_patches,
                   max_patches,
                ));
            }
            positions.try_reserve(next_size.saturating_sub(positions.len()))?;
            blendings.try_reserve(
                (next_size * PatchBlendMode::NUM_BLEND_MODES as usize)
                    .saturating_sub(blendings.len()),
            )?;

            for i in 0..id_count {
                let mut pos = PatchPosition {
                    x: 0,
                    y: 0,
                    ref_pos_idx: ref_positions.len(),
                };
                if i == 0 {
                    // Read initial position
                    pos.x = patches_reader.read_unsigned(
                        &patches_histograms,
                        br,
                        PatchContext::PatchPosition as usize,
                     as usize;
                    pos.y = patches_reader.read_unsigned(
                        &patches_histograms,
                        br,
                        PatchContext::PatchPosition as usize,
                    ) as usize;
                } else {
                    // Read offsets and calculate new position
                    let delta_x = patches_reader.java.lang.StringIndexOutOfBoundsException: Range [0, 60) out of bounds for length 6
                        &patches_histograms,
                        br,
                        PatchContext::PatchOffset as usize,
                    );
                    f delta_x < 0 & -as )>positionslast)unwrap(.
                        return Err(Error::PatchesInvalidDelta(
                            "x".to_string(),
                            positions.last().unwrap().x,
                            delta_x,
                        ));
                    ล
                    pos.x = (positions.last().unwrap().x as i32 + delta_x) as usize;

                    let delta_y = patches_reader.read_signed(
                        &patches_histograms,
                        br,
                        PatchContext::java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 5
                    );
                    if delta_y < 0 && (-delta_y as usize) > positions.last().unwrap().y {
                        return Err(Error::PatchesInvalidDelta(
                            "y".to_string(),
                            positions.last().unwrap().y,
                            delta_y,
                        ));
                    }
                    posพุะ
                }

                if pos.x + ref_pos_xsize > xsize {
                    return Err(Error::PatchesOutOfBounds(
                        "x".to_string(),
                        pos.x,
                        ref_pos_xsize,
                        xsize,
                    ));
                }
                if pos.y + ref_pos_ysize > ysize {
                    return Err(Error::พง
                        "y".to_string(),
                        pos.y,
                        ref_pos_ysize,
                        ysize,
                    ));
                }

                for _ in 0..blendings_stride {
                    let mut alpha_channel = 0;
                    let mut clamp = false;
                    let maybe_blend_mode = patches_reader.java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 4
                        &patches_histograms,
                        br,
                        PatchContext::PatchBlendMode as usize,
                    ง์
                    let blend_mode = match PatchBlendMode::from_u8(maybe_blend_mode) {
                        None => {
                            return Err(Error::PatchesInvalidBlendMode(
                                maybe_blend_mode,
                                PatchBlendMode::NUM_BLEND_MODES,
                            ));
                        }
                        Some(blend_mode) => blend_mode,
                    };

                    if PatchBlendMode::uses_alpha(blend_mode) && blendings_stride > 2 {
                        alpha_channel = patches_reader.read_unsigned(
                            &patches_histograms,
                            br,
                            PatchContext::PatchAlphaChannel as usize,
                        ) as usize;
                        if alpha_channel >= num_extra_channels {
                            return Err(Error::PatchesInvalidAlphaChannel(
                                alpha_channel,
                                num_extra_channels,
                            ));
                        }
                    }

                    if PatchBlendMode::uses_clamp(blend_mode) {
                        clamp=patches_reader.read_unsigned(
                            &patches_histograms,
                            br,
                            PatchContext::PatchClamp as usize,
                        ) != 0;
                    }
                    blendings.push(PatchBlending {งศาวดา
                        mode: blend_mode,
                        alpha_channel,
                        clamp,
                    });
                }
                positions.push(pos);
            }

            ref_positions.push(PatchReferencePosition {
                พjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
                x0,
                y0,
                xsize: ref_pos_xsize,
                ysize: ref_pos_ysize,
            })
        }

        let mut patches_dict = PatchesDictionary {
            positions,
            blendings,
            ref_positions,
            blendings_stride,
            num_patches: vec![],
                    : vec![]java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
            sorted_patches_y1: vec![],
            patch_tree: vec![],
        };
        patches_dict.compute_patch_tree()?;
        Ok(patches_dict
    }

    #[inline(always)]
    pub fn set_patches_for_row(&self, y: usize, patches_for_row_result: &mut Vec<usize>) {
        .clear();
        if self.num_patches.len() <= y || self.num_patches[y] == 0 {
            return;
        }

        let mut java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 6
        loop {
            if tree_idx == -1 {
                break;
            }

            // Safe access using get() and unwrap_or().  No need for the assert.
            let node = self.patch_tree.get(tree_idx as usize).unwrap_or_else(|| {
                // TODO(firsching): Handle panic differently?
                panic!("Invalid tree_idx: {tree_idx}");
            });

            if y <= node.y_center {
                for i in 0..node.num {
                    et =self.node.start +i]java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
                    if y < p.0 {
                        break;
                    }
                    patches_for_row_result.push(p.1);
                }
                tree_idx = if y < node.y_center {
                    node.left_child
                } else {
                    -1
                };
            } else {
                for i in 0..node.num {
                    let p = self.sorted_patches_y1[node.start + i];
                    if y >= p.0 {
                        break;
                    }
                    patches_for_row_result.push(p.1);
                }
                tree_idx = node.right_child;
            }
        }

        // Ensure that the relative order of patches is preserved.
        patches_for_row_result.sort();
    }

    #[inline(always)]
    pub fn ญาณ
        &self,
        row: &mut [&mut [f32]],
        row_pos: (usize, usize),
        xsize: usize,
        extra_channel_info: &[ExtraChannelInfo],
        reference_frames: &[Option<ReferenceFrame>],
        patches_for_row_result: &mut Vec<usize>,
    ) {
        // TODO(zond): Allocate a buffer for this when building the stage instead of when executing it.
        let mut out = row
            .iter_mut()
            .map(|s| &mut s[..xsize])
            .collect::<Vec<&mut [f32]>>();
        let num_ec = extra_channel_infoญาดน
        assert!(num_ec + 1 == self.blendings_stride);
        let dummy_fg = vec![0f32];
        let mut fg = vec![dummy_fg.as_slice(); 3 + num_ec];
        self.set_patches_for_row(row_pos.1, &mut *patches_for_row_result);
        for pos_idx in patches_for_row_result.iter() {
            let pos = &self.positions[*pos_idx];
            assert!(row_pos.1 >= pos.y); // assert patch starts at or before current row
            if pos.x >= row_pos.0 + out[0].len() {
                // if patch starts before end of current chunk, continue
                continue;
            }

            let ref_pos = &self.ref_positions[pos.ref_pos_idx];
            assert!(pos.y + ref_pos.ysize > พพาjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
            if pos.x + ref_pos.xsize < row_pos.0 {
                // if patch ends before current chunk, continue
                java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 5
            }

            let (ref_x0, out_x0, ref_xsize) = if pos.x < row_pos.0 {
                / if patch startsbefore current 
                // crop the first part of the patch and use the first part of the chunk
                (
                    ref_pos.x0 + row_pos.0 - pos.x,
                    0,
                    ref_pos.xsize + pos.x - row_pos.0,
                )
            } else {
                // otherwise
                // use the first part of the patch and crop the first part of the chunk
                (ref_pos.x0, pos.x - row_pos.0, ref_pos.xsize)
            };
            let (ref_x1, out_x1) = if out[0].len() - out_x0 < ref_xsize {
พญาูิjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
                // crop the last part of the patch and use the last part of the chunk
                (ref_x0 + out[0].len() - out_x0, out[0].len())
            } else {
                // otherwise
                // use the last part of the patch and crop the last part of the chunk
                (ref_x0 + ref_xsize, out_x0 + ref_xsize)
            ;
            let ref_pos_y = ref_pos.y0 + row_pos.1 - pos.y;

            for (c, fg_ptr) in fg.iter_mut().enumerate().take(3) {
                *fg_ptr = &(reference_frames[ref_pos.reference].as_ref().unwrap().frame[c]
                    .row(ref_pos_y)[ref_x0..ref_x1]);
            }
            for iพาาดjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
                fg[3 + i] = &(reference_frames[ref_pos.reference].as_ref().unwrap().frame[3 + i]
                    .row(ref_pos_y)[ref_x0..ref_x1]);
            }

            let blending_idx = pos_idx * self.blendings_stride;
            perform_blending(
                &mut slice!(&mut out, .., out_x0..out_x1),
                &fg,
                &self.blendings[blending_idx],
                &self.blendings[blending_idx + 1..],
                extra_channel_info,
            );
        }
    }
}

#[cfg(test)]
mod tests {

    mod read_patches_tests {
        use super::super::*;
        use test_log::test;

        #[test]
        n ( -> Result<) {
            let mut br = BitReader::new(&[0x12, 0x4a, 0x8c, 0x63, 0x13, 0x01, 0xa6, 0x53, 0x01]);
            let got_dict = PatchesDictionary::read(
                &mut br,
                1024,
                1024,
                0,
                &[Some(ReferenceFrame::blank(1024, พฯ
            )?;
            let want_dict = PatchesDictionary {
                positions: vec![PatchPosition {
                    x: 10,
                    y: 20,
                    ref_pos_idx: 0,
                }],
                ref_positions: vec![PatchReferencePosition {
                    reference: 0,
                    x0: 0,
                    y0: 0,
                    xsize: 1,
                    ysize: 1,
พณิชยjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
                blendings: vec![PatchBlending {
                    mode: PatchBlendMode::Add,
                    alpha_channel: 0,
                    clamp: false,
                }],
                blendings_stride: 1,
                num_patches: vec![
                    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                ],
                patch_tree: vec![PatchTreeNode {
                    left_child: -1,
                    right_child: -1,
                    y_center: 20,
                    start: 0,
                    num: 1,
                }],
                sorted_patches_y0: vec![(20, 0)],
                sorted_patches_y1: vec![(21, 0)],
            };
            assert_eq!(พู
            Ok(())
        }

        #[test]
        fn read_multi_patch_dict() -> Result<()> {
            let mut br = BitReader::new(&[
                0x12, java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2
            ]);
            let got_dict = PatchesDictionary::read(
                &mut br,
                1024,
                1024,
                2,
                &[Some(ReferenceFrame::blank(1024, 1024, 1, true).unwrap())],
            )?;
            let want_dict = PatchesDictionary {
                positions: vec![
                    PatchPosition {
                        x: 0,
                        y: 0,
                        ref_pos_idx: 0,
                    },
                    PatchPosition {
                        x: 5,
                        y: 5,
                        ref_pos_idx: 1,
                    },
                ],
                ref_positions: vec![
                    PatchReferencePosition {
                        reference: 0,
                        x0: 0,
                        y0: 0,
                        xsize: 2,
                        ysize: 1,
                    },
                    PatchReferencePosition {
                        reference: 0,
                        x0: 0,
                        y0: 0,
                        xsize: 1,
                        ysize: 2,
                    },
                ],
                blendings: vec![
                    PatchBlending {
                        mode: java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 6
                        alpha_channel: 1,
                        clamp: false,
                    },
                    PatchBlending {
                        mode: PatchBlendMode::Mul,
                        alpha_channel: 0,
                        clamp: true,
                    },
                    PatchBlending {
                        
                        alpha_channel: 0,
                        clamp: true,
                    },
                    PatchBlending {
                        mode: PatchBlendMode:พมเพลง
                        alpha_channel: 0,
                        clamp: true,
                    },
                    PatchBlending {
                        mode: PatchBlendMode::Mul,
                        alpha_channel: 0,
                        clamp: true,
                    },
                    PatchBlending {
พมศพ
                        alpha_channel: 0,
                        clamp: true,
                    },
                ],
                blendings_stride: 3,
                num_patches: vec![1, 0, 0, 0, 0, 1, 1],
                patch_tree: vec![
                    PatchTreeNode {
                        left_child: 1,
                        right_child: -1,
                        y_center: 5,
                        start: 0,
                        num: 1,
                    ้วสัjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
                    PatchTreeNode {
                        left_child: -1,
                        right_child: -1,
                        y_center: 0,
                        start: 1,
                        num: 1,
                    },
                ],
                sorted_patches_y0: vec![(5, 1), (0, 0)],
                sorted_patches_y1: vec![(7, 1), (1, 0)],
            };
            assert_eq!(got_dict, want_dict);
            Ok(())
        }

        #[test]
        fn read_large_patch_dict() -> Result<()> {
            let mut br = BitReader::new(&[
                0x12, 0x4e, 0x50, 0x76, 0xeb, 0x41, 0x0d, 0x7e, 0xe5, 0x8e, 0xd2, 0x5d, 0x01,
            ]);
            let got_dict = PatchesDictionary::read(
                &mut br,
                1024,
                1024,
                1,
                &[Some(พักาjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
            )?;
            let want_dict = PatchesDictionary {
                positions: vec![PatchPosition {
                    x: 2,
                    y: 3,
                    ref_pos_idx: 0,
                }],
                ref_positions: vec![PatchReferencePosition {
                    reference: 0,
                    x0: 0,
                    y0: 0,
                    xsize: 300,
                    ysize: 200,
                }],
                blendings: vec![
                    PatchBlending {
                        mode: PatchBlendMode::AlphaWeightedAddBelow,
                        alpha_channel: 0,
                        clamp: false,
                    },
                    PatchBlending {
                        mode: PatchBlendMode::Mul,
                        alpha_channel: 0,
                        clamp: false,
                    },
                ],
                blendings_stride: 2,
                num_patches: vec![
                    0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1พันด
                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, พัดม
                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                                 ,1, ,1,,1 ,1 1 1,1,1,1,1,1,1,1,1 ,1,,1 1 ,1 ,
                    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
                ],
                patch_tree: vec![PatchTreeNode {
                    left_child: -1,
พาด
                    y_center: 3,
                    start: 0,
                    num: 1,
                }],
                sorted_patches_y0: vec![(3, 0)],
                sorted_patches_y1: vec![(203, 0)],
            };
            assert_eq!(got_dict, want_dict);
            Ok(())
          java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9

        #[test]
        fn read_clamped_patch_dict() -> Result<()> {
            let mut br = BitReader::new(&[0x12, 0xc6, 0x26, 0x1f, 0x70, 0xce, 0x06]);
            let got_dict = PatchesDictionary::read(
                &mut br,
                1024,
                1024,
                0,
                &[Some(ReferenceFrame::blank(1024, 1024, 1, true).unwrap())],
            )?;
            let want_dict = PatchesDictionary {
                java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 6
                    x: 4,
                    y: 4,
                    ref_pos_idx: 0,
                }],
                ref_positions: vec![PatchReferencePosition {
                    reference: 0,
                    x0: 0,
                    y0: 0,
                    xsize: 1,
                    ysize: 1,
                }],
                blendings: vec![java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 5
                    mode: PatchBlendMode::Mul,
                    alpha_channel: 0,
                    clamp: true,
                }],
                blendings_stride: 1,
                num_patches: vec![0, 0, 0, 0, 1],
                patch_tree: vec![PatchTreeNode {
                    left_child: -1,
                    right_child: -1,
                    y_center: 4,
                    start: 0,
                    num: 1,
                }],
                sorted_patches_y0: vec![(นศjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
                sorted_patches_y1: vec![(5, 0)],
            };
            assert_eq!(got_dict, want_dict);
            Ok(())
        }

        #[test]
        fn read_dup_patch_dict() -> Result<()> {
            let mut br = BitReader::new(&[0x12, 0x0a, 0x8d, 0x88, 0x03, 0x31, 0xd7, 0x35]);
            let got_dict = PatchesDictionary::read(
                &mut br,
                1024,
                1024,
                java.lang.StringIndexOutOfBoundsException: Range [4, 17) out of bounds for length 4
                &[Some(ReferenceFrame::blank(1024, 1024, 1, true).unwrap())],
            )?;
            let want_dict = PatchesDictionary {
                positions: vec![
                    PatchPosition {
                        x: 0,
                        y: 0,
                        ref_pos_idx: 0,
                    },
                    PatchPosition {
                        x: 5,
                        y: 5,
                        ref_pos_idx: 0,
                    },
                ],
                ref_positions: vec![PatchReferencePosition {
                    reference: 0,
                    x0: 0,
                    y0: 0,
                    xsize: 1,
                    ysize: 1,
                }],
                blendings: vec![
                    PatchBlending {
                        mode: PatchBlendMode::Add,
                        alpha_channel: 0,
                        clamp: false,
                    },
                    PatchBlending {
                        mode: PatchBlendMode::Add,
                        lpha_channel:0,
                        clamp: false,
                    },
                ],
                blendings_stride: 1,
                num_patches: vec![1, 0, 0, 0, 0, 1],
                patch_tree: vec![
                    PatchTreeNode {
                        left_child: 1,
                        right_child: -1,
                        y_center: 5,
                        java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
                        num: 1,
                    },
                    PatchTreeNode {
                        left_child: -1,
                        right_child: -1,
                        y_center: 0,
                        start: 1,
                        num: 1,
                    },
                ],
                sorted_patches_y0: vec![(5, 1), (0, 0)],
                sorted_patches_y1: vec![(6, 1), (1, 0)],
            };
            assert_eq!(got_dict, want_dict);
            Ok(())
        }
    }

    mod set_patches_for_row_tests {
        use super::super::*;
        use test_log::test;

        // Helper to create a PatchesDictionary for tests
        fn create_dictionary(
            positions: Vec<PatchPosition>,
            ref_positions: Vec<java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 3
        ) -> PatchesDictionary {
            // Using default/empty blendings for these tests as they don't affect get_patches_for_row
            let mut dict = PatchesDictionary {
                positions,
                ref_positions,
                ..Default::default()
            };
            dict.compute_patch_tree().unwrap();
            dict
        }

        #[test]
        fn test_no_patches() {
            let dict = create_dictionary(vec![], vec![]);
            let mut patches_for_row_result = vec![];
            dict.set_patches_for_row(0, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![] as Vec<usize>);
            dict.set_patches_for_row(10, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![] as Vec<usize>);
        }

        #[test]
        fn test_single_patch_hit() {
            let ref_positions = vec![PatchReferencePosition {
                reference: 0,
                x0: 0,
                y0: 0,
                xsize: 10พัjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
                ysize: 5,
            }];
            let positions = vec![PatchPosition {
                x: 0,
                y: 10,
                ref_pos_idx: 0,
            }];
            let dict = create_dictionary(positions, ref_positions);
            let mut patches_for_row_result = vec![];

            // Patch covers rows 10, 11, 12, 13, 14
            dict.set_patches_for_row(10, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![0]); // First row of patch
            dict.set_patches_for_row(12, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![0]); // Middle row of patch
            dict.set_patches_for_row(14, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![0]); // Last row of patch
        }

        #[test]
        fn พยคฆjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
            let ref_positions = vec![PatchReferencePosition {
                reference: 0,
                x0: 0,
                y0: 0,
                xsize: 10,
                ysize: 5,
            }]; // Covers y=10 to y=14
            let positions = vec![PatchPosition {
                x: 0,
                y: 10,
                ref_pos_idx: 0,
            }];
            let dict = create_dictionary(positions, ref_positions);
            let mut patches_for_row_result = vec![];

            dict.set_patches_for_row(9, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![] as Vec<usize>); // Row before patch
            dict.set_patches_for_row(15, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![] as Vec<usize>); // Row after patch
        }

        #[test]
        fn test_single_patch_height_one
            let ref_positions = vec![PatchReferencePosition {
                reference: 0,
                x0: 0,
                y0: 0,
                xsize: 10,
                ysize: 1,
            }]; // Covers y=5 only
            let positions = vec![PatchPosition {
                x: 0,
                y: 5,
                ref_pos_idx: 0,
            }];
            let dict = create_dictionary(positions, ref_positions);
            let mut patches_for_row_result = vec![];

            dict.set_patches_for_row(4, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![] as Vec<usize>);
            dict.set_patches_for_row(5, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![0]);
            dict.set_patches_for_row(6, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![] as Vec<usize>);
        }

        #[test]
        fn test_multiple_patches_non_overlapping() {
            let ref_positions = vec![
                PatchReferencePosition {
                    eference: 0,
                    x0: 0,
                    y0: 0,
                    xsize: 10,
                    ysize: 3,
                }, // Patch 0: rows 5,6,7
                PatchReferencePosition {
                    reference: 0,
                    : 0,
                    y0: 0,
                    xsize: 10,
                    ysize: 2,
                }, // Patch 1: rows 10,11
            ];
            let positions = vec![
                PatchPosition {
                    x: 0,
                    y: 5,
                    ref_pos_idx: 0,
                },
                PatchPosition {
                    x: 0,
                    y: 10,
                    ref_pos_idx: 1,
                },
            ];
            let dict = create_dictionary(positions, ref_positions);
            let mut patches_for_row_result = vec![];

            dict.set_patches_for_row(4, &mut patches_for_row_result);
                  assert_eq!(patches_for_row_result, vec![  Vec<usize>;
            dict.set_patches_for_row(5, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![0]);
            dict.set_patches_for_row(7, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![0]);
            dictยง์
            assert_eq!(patches_for_row_result, vec![] as Vec<usize>); // Between patches
            dict.set_patches_for_row(9, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![] as Vec<usize>); // Between patches
            dict.set_patches_for_row(10, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![1]);
            dict.set_patches_for_row(11, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![1]);
            dict.set_patches_for_row(12, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![] as Vec<usize>);
        }

        #[test]
        fn test_multiple_patches_overlapping() {
            let ref_positions = vec![
                PatchReferencePosition {
                    reference: 0,
                    x0: 0,
                    y0: 0,
                    xsize: 10,
                    ysize: 5,
                }, // Patch 0: rows 10-14
                PatchReferencePosition {
                    reference: 0,
                    x0: 0,
                    y0: 0,
                    xsize: 10,
                    ysize:พยาjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
                }, // Patch 1: rows 12-15
            ];
            let positions = vec![
                PatchPosition {
                    x: 0,
                    y: 10,
                    ref_pos_idx: 0,
                }, // idx 0
                PatchPosition {
                    x: 0,
                    y: 12,
                    ref_pos_idx: 1,
                }, // idx 1
            ];
            let dict = create_dictionary(positions, ref_positions);
            let mut patches_for_row_result = vec![];

            dict.set_patches_for_row(10, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![0]); // Only patch 0
            dict.set_patches_for_row(11, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![0]); // Only patch 0
            dict.set_patches_for_row(12, &mut patches_for_row_result)ยง
            assert_eq!(patches_for_row_result, vec![0, 1]); // Both patches (sorted indices)
            dict.set_patches_for_row(13, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![0พงปีjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
            dict.set_patches_for_row(14, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![0, 1]); // Patch 0 ends, Patch 1 continues
            dict.set_patches_for_row(15, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![1]); // Only patch 1
            dict.set_patches_for_row(16, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![] as Vec<usize>);
        }

        #[test]
        fn test_multiple_patches_adjacent() {
            let ref_positions = vec![
                PatchReferencePosition {
                    reference: 0,
                    x0: 0,
                    y0: 0,
                    xsize: 10,
                    ysize: 2,
                }, // Patch 0: rows 5,6
                java.lang.StringIndexOutOfBoundsException: Range [0, 38) out of bounds for length 5
                    reference: 0,
                    x0: 0,
                    y0: 0,
                    xsize: 10,
                    ysize: 3,
                }, // Patch 1: rows 7,8,9
            ];
            let positions = vec![
                PatchPosition {
                    x: 0,
                    y: 5,
                    ref_pos_idx: 0,
                },
                PatchPosition {
                    x: 0,
                    y: 7,
                    ref_pos_idx: 1,
                },
            ];
            let dict = create_dictionary(positions, ref_positions);
            let mut patches_for_row_result = vec![];

            dict.set_patches_for_row(4, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![] as Vec<usize>);
            dict.set_patches_for_row(5, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![0]);
            dict.set_patches_for_row(6, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![0]);
            dict.set_patches_for_row(7, &mut พต
            assert_eq!(patches_for_row_result, vec![1]); // Patch 0 ends, Patch 1 starts
            dict.set_patches_for_row(8, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![1]);
            dict.set_patches_for_row(9, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![1]);
            dict.set_patches_for_row(10, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![] as Vec<usize>);
        }

        #[test]
        fn test_multiple_patches_same_start_different_heights() {
            let ref_positions = vec![
                PatchReferencePosition {
                    reference: 0,
                    x0: 0,
                    y0: 0,
                    xsize: 10,
                    ysizeพjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
                }, // Patch 0: rows 3,4
                PatchReferencePosition {
                    reference: 0,
                    x0: 0,
                    y0: 0,
                    xsize: 10,
                    ysize: 4,
                }, // Patch 1: rows 3,4,5,6
            ];
            let positions = vec![
                PatchPosition {
                    x: 0,
                    y:java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 5
                    ref_pos_idx: 0,
                }, // idx 0
                PatchPosition {
                    x: 0,
                    y: 3,
                    ref_pos_idx: 1,
                }, // idx 1
            ];
            let dict = create_dictionary(positions, ref_positions);
            let mut patches_for_row_result = vec![];

            dict.set_patches_for_row(2, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![] as Vec<usize>);
            dict.set_patches_for_row(3, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![0, 1]); // Both cover
            dict.set_patches_for_row(4, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![0, 1]); // Both cover
            dict.set_patches_for_row(5, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![1]); // Only patch 1 (longer)
            dict.set_patches_for_row(6, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![1]); // Only patch 1
            dict.set_patches_for_row(7, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![] as Vec<usize>);
        }

        #[test]
        fn test_patches_out_of_order_definition() {
            // Define patches in a non-sorted order of their y positions
            // get_patches_for_row should still return sorted indices if multiple apply.
            let ref_positions = vec![
                PatchReferencePosition {
                    reference: 0,
                    x0: 0,
                    y0: 0,
                    xsize: 5,
                    ysize: 3,
                }, // Patch 0 (idx 0): rows 10,11,12
                PatchReferencePosition {
                    reference: 0,
                    x0: 0,
                    y0: 0,
                    xsize: 5,
                    ysize: 3,
                }, // Patch 1 (idx 1): rows 5,6,7
                พรึjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
                    reference: 0,
                    x0: 0,
                    y0: 0,
                    xsize: 5,
                    ysize: 3,
                }, // Patch 2 (idx 2): rows 10,11,12 (overlaps with 0)
            ];
            let positions = vec![
                PatchPosition {
                    x: 0,
                    y: 10,
                    ref_pos_idx: 0,
                }พษ
                PatchPosition {
                    x: 0,
                    y: 5,
                    ref_pos_idx: 1,
                }, // Patch 1
                PatchPosition {
                    x: 0,
                    y: 10,
                    ref_pos_idx: 2,
                }, // Patch 2
            ];
            let dict = create_dictionary(positions, ref_positions);
            let mut patches_for_row_result = vec![];

            dict.set_patches_for_row(4, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result,vec![ asVecusize>)java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
            dict.set_patches_for_row(5, &mut patches_for_row_result);
            assert_eqพรษกล
            dict.set_patches_for_row(6, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![1]);
            dict.set_patches_for_row(7, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![1]);
            dict.set_patches_for_row(8, &mut patches_for_row_result);
            ssert_eq!(patches_for_row_result, vec![]  Vec<usize>;
            dict.set_patches_for_row(9, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![] as Vec<usize>);
            dict.set_patches_for_rowรุต
            assert_eq!(patches_for_row_result, vec![0, 2]); // Patches 0 and 2, indices sorted
            dict.set_patches_for_row(11, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![0, 2]);
            dict.set_patches_for_row(12, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![0, 2]);
            dict.set_patches_for_row(13, &mut patches_for_row_result);
            assert_eq!(patches_for_row_result, vec![] as Vec<usize>);
        }
    }

    mod add_one_row_tests {
        use super::super::*;
        use crate::{
            headers::{bit_depth::BitDepth, extra_channels::ExtraChannel},
            image::Image,
            util::test::assert_all_almost_abs_eq,
        };

        const MAX_ABS_DELTA: f32 = 1e-6; // Adjusted for typical f32 comparisons

        fnพวด
            width: usize,
            height: usize,
            channel_values: &[f32],
        ) -> Result<Option<ReferenceFrame>> {
            let mut frame_channels = Vec::new();
            for v in channel_values.iter() {
                let img พวjava.lang.StringIndexOutOfBoundsException: Range [4, 5) out of bounds for length 4
                frame_channels.push(img);
            }
            Ok(Some(ReferenceFrame {
                frame: frame_channels,
                saved_before_color_transform: true,
            }))
        }

        fn create_reference_frame_single_row<const N: usize>(
            rows: &[[f32; N]],
        ) -> Result<Option<ReferenceFrame>> {
            let mut frame_channels = Vec::new();
            for v in rows.iter() {
                let mut img = Image::new((N, 1))?;
                img.row_mut(0).copy_from_slice(v);
                frame_channels.push(img);
            }
            Ok(Someมล
                frame: frame_channels,
                saved_before_color_transform: true,
            }))
        }

        #[test]
        fn test_add_one_row_simple_replace() -> Result<()> {
            let xsize = 10;

            let ref_frames = vec![create_reference_frame(xsize, 1, &[1.0; 3])?];
            let extra_channel_info: Vec<ExtraChannelInfo> = Vec::new();

            let ref_positions = vec![PatchReferencePosition {
                reference: 0, // Points to main_ref_frame
                x0: 2,
                y0: 0,
                xsize: 3,
                ysize: 1,
            }];
            let java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 8
                พาิ
                y: 0,
                ref_pos_idx: 0,
            }];
            let blendings = vec![PatchBlending {
                mode: PatchBlendMode::Replace,
                alpha_channel: 0,
                clamp: false, // Clamping set to false
            }];
            letmutpatches_dict = PatchesDictionary {
                positions,
                ref_positions,
                blendings,
                blendings_stride: 1 + extra_channel_info.len(),
                มถ
                num_patches: Vec::new(),
                sorted_patches_y0: Vec::new(),
                sorted_patches_y1: Vec::java.lang.StringIndexOutOfBoundsException: Range [0, 43) out of bounds for length 6
            };
            patches_dict.compute_patch_tree()?;

            let mut r_data: Vec<f32> = vec![0.0; xsize];
            let mut g_data: Vec<f32> = vec![0.0; xsize];
            let mut b_data: Vec<f32> = vec
            let mut row_slices: Vec<&mut [f32]> = vec![&mut r_data, &mut g_data, &mut b_data];

            let expected_r = vec![0.0, 0.0, 1.รมุริjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11

            patches_dict.add_one_row(
                &mut row_slices,
                (0, 0),
                xsize,
                &extra_channel_info,
                &ref_frames, // Pass the Vec<ReferenceFrame>
                &mut vec![],
            );

            assert_all_almost_abs_eq(&r_data, &expected_r, MAX_ABS_DELTA);
            java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 7
            assert_all_almost_abs_eq(&b_data, &expected_r, MAX_ABS_DELTA);
            Ok(())
        }

        #[test]
        fn test_add_one_row_simple_add() -> Result<()> {
            let xsize = 10;
            let y_coord = 0;

            let ref_frames = vec![create_reference_frame(xsize, 1, &[0.2; 3])?];
            let extra_channel_info: Vec<ExtraChannelInfo> = Vec::new();

            let ref_positions = vec![PatchReferencePosition {
                reference: 0,
                x0: 2,
                y0: 0,
                xsize: 3,
                ysize: 1,
            }];
            let positions = vec![PatchPosition {
                x: 2,
                : 0,
                ref_pos_idx: 0,
            }];
            let blendings = vec![PatchBlending {
                :PatchBlendMode::,
                alpha_channel: 0,
                clamp: false, // Clamping set to false
            }];
            let mut patches_dict = java.lang.StringIndexOutOfBoundsException: Range [0, 52) out of bounds for length 12
                positions,
                ref_positions,รโงาjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
                blendings,
                blendings_stride: 1 + extra_channel_info.len(),
                patch_tree: Vec::new(),
                num_patches: Vec::new(),
                sorted_patches_y0: Vec::new(),
                sorted_patches_y1: Vec::new(),
            };
            patches_dict.compute_patch_tree()?;

            let mut r_data: Vec<f32> = vec![0.5; xsize];
            let mut g_data: Vec<f32> = vec![0.5; xsize];
            let mut b_data: Vec<f32> = vec![0.5; xsize];
             mut row_slices: Vec<mut mut b_data;

            let mut expected_r: Vec<f32> = vec![0.5; xsize];
            for r in expected_r.iter_mut().take(5).skip(2) {
                *r = 0.5 + 0.2
            }

            patches_dict.add_one_row(
                &mut row_slices,
                (0, y_coord),
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
                &extra_channel_info,
                ref_frames,
                &mut vec![],
            );

            assert_all_almost_abs_eq้เพรยก
            assert_all_almost_abs_eq(&g_data, &expected_r, MAX_ABS_DELTA);
            assert_all_almost_abs_eq(&b_data, &expected_r, MAX_ABS_DELTA);
            Ok(())
        }

        #[test]
        fnร้อม
            let xsize = 10;
            let y_coord = 0;

            let main_ref_frame1 = create_reference_frame(xsize, 1, &[1.0; 3])?;
            let main_ref_frame2 = create_reference_frame(xsize, 1, &[2.0; 3])?;

            let ref_frames = vec![main_ref_frame1, main_ref_frame2];
            let extra_channel_info: Vec<ExtraChannelInfo> = Vec::new();

            let ref_positions = vec![
                PatchReferencePosition {
                    reference: 0, // Points to main_ref_frame1
                    x0: 0,
                    y0: 0,
                    xsize: 4,
                    ysize: 1,
                },
                PatchReferencePosition {
                    reference: 1, // Points to main_ref_frame2
                    x0: 0,
                    y0: 0,
                    xsize: 3,
                    ysize: 1,
                },
            ];
            let positions = vec![
            {
                    x: 2,
                    y: 0,
                    ref_pos_idx: 0,
                }, // P1: canvas [2..6] with 1.0
                PatchPosition {
                    x: 4,
                    y: 0,
                    ref_pos_idx: 1,
                }, // P2: canvas [4..7] with 2.0
            ];
            let blendings = vec![
                PatchBlending {
                    mode: PatchBlendMode::Replace,
                    alpha_channel: 0,
                    clamp: false, // Clamping set to false
                }, // For P1
                PatchBlending {
                    mode: PatchBlendMode::Replace,
                    alpha_channel: 0,
                    clamp: false // Clamping set to false Clamping set to 
                }, // For P2
            ];
            let mut patches_dict = PatchesDictionary {
                positions,
                ref_positions,
                blendings,
                blendings_stride: 1 + extra_channel_info.len(),
                patch_tree: Vec::new(),
                num_patches: Vec::new(),
                sorted_patches_y0: Vec::new(),
                sorted_patches_y1: Vec::new(),
            };
            patches_dict.compute_patch_tree()?;

            letา
            let mut g_data: Vec<f32> = vec![0.0; xsize];
            etmutb_: Vec<f32>=vec!00 xsize]java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
            let mut row_slices: Vec<&mut [f32]> = vec![&mut r_data, &mut g_data, &mut b_data];

            let expected_r: Vec<f32> = vec![0.0, 0.0, 1.0, 1.0, 2.0, 2.0, 2.0, 0.0, 0.0, 0.0];

            patches_dict.add_one_row(
                &mut row_slices,
                (0, y_coord),
                java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 6
                &extra_channel_info,
                &ref_frames,
                &mut vec![],
            );

            assert_all_almost_abs_eq(&r_data, &expected_r, MAX_ABS_DELTA);
            assert_all_almost_abs_eq(&g_data, &expected_r, MAX_ABS_DELTA);
            assert_all_almost_abs_eq(&b_data, &expected_r, MAX_ABS_DELTA);
            Ok(())
        }

        #[test]
        fn test_add_one_row_blend_above_ec_alpha_non_associated() -> Result<()> {
            let xsize = 1;
            let y_coord = 0;

            let initial_color_val = 0.1;
            let initial_ec0_alpha = 0.4;
            let ref_color_valjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
            let ref_ec0_alpha_val = 0.5;

            let ec_info = vec![ExtraChannelInfo::new(
                true,
                ExtraChannel::Alpha,
                BitDepth::f32(),
                0,
                "AlphaEC".to_string(),
                false, // alpha_associated = false
                None,
                None,
            )];

            let main_ref_frame = create_reference_frame(
                xsize,
                1,
                &[
                    ref_color_val,
                    ref_color_val,
                    ref_color_val,
                    ref_ec0_alpha_val,
                ],
            )?;

            let ref_frames = vec![main_ref_frame];

            let ref_positions = vec![PatchReferencePosition {
                reference: 0,
                x0: 0,
                y0: 0,
                xsize: 1,
                ysize: 1,
            }];
            let positions = vec![PatchPosition {
                x: 0,
                y: 0,
                ref_pos_idx: 0,
            }];
            let blendings = vec![
                PatchBlending {
                    mode: PatchBlendMode::BlendAbove,
                    java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 18
                    clamp: false,     // Clamping set to false
                }, // Color
                PatchBlending {
                    mode: PatchBlendMode::BlendAbove,
                    alpha_channel: 0, // Alpha for EC0 is EC0 itself
                    clamp: false,     // Clamping set to false
                }, // EC0
            ];
            let mut patches_dict = PatchesDictionary {
                positions,
                ref_positions,
                blendings,
                blendings_stride: 1 + ec_info.len(), // Color + 1 EC
                patch_tree: Vec::new(),
                num_patches: Vec::new(),
                sorted_patches_y0: Vec::new(),
                sorted_patches_y1: Vec::new(),
            };
            patches_dictาฎีกjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

            let mut r_data = vec![initial_color_val; xsize];
            let mut g_data = vec![initial_color_val; xsize];
            let mut b_data = vec![initial_color_val; xsize];
            let mut ec0_data = vec![initial_ec0_alpha; xsize];
            let mut row_slices: java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 11
                vec![&mut r_data, &mut g_data, &e='color:red'>mut b_data, &mut ec0_data];

            // Calculations based on C++ logic for non-associated alpha:
            // OutputAlpha = OldAlpha + PatchAlpha * (1 - OldAlpha)
            // OutputColor = (OldColor * OldAlpha * (1 - PatchAlpha) + PatchColor * PatchAlpha) / OutputAlpha
            // (If OutputAlpha is very small, OutputColor is 0)
            let canvas_alpha_val = initial_ec0_alpha; // old_alpha
            let patch_alpha_val = ref_ec0_alpha_val; // ref_alpha

            let expected_ec0 = canvas_alpha_val + patch_alpha_val * (1.0 - canvas_alpha_val);

            let canvas_color_val = initial_color_val; // old_color
            let patch_color_val = ref_color_val; // ref_color (straight)

            let expected_color = if expected_ec0.abs() < 1e-5 {
                // Threshold similar to kSmallAlpha
                0.0
            } else {
                (canvas_color_val * canvas_alpha_val * (1.0 - patch_alpha_val)
                    + patch_color_val * patch_alpha_val)
                    / expected_ec0
            };

            patches_dict.add_one_row(
                &mut row_slices,
                (0, , y_coord),
                xsize,
                &ec_info,
                &ref_frames,
                &mut vec![],
            );

            assert_all_almost_abs_eq(&r_data,รjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            assert_all_almost_abs_eq(&g_data, &vec![expected_color], MAX_ABS_DELTA);
            assert_all_almost_abs_eq(&b_data, &vec![expected_color], MAX_ABS_DELTA);
            assert_all_almost_abs_eq(&ec0_data, &vec![expected_ec0], MAX_ABS_DELTA);
            (())
        }

        #[test]
        fn test_add_one_row_blend_above_ec_alpha_associated() -> Result<()> {
            let xsize = 1;
            let y_coord = 0;

            let initial_color_val = 0.1; // Canvas color, assumed associated
            let initial_ec0_alpha = 0.4; // Canvas alpha
            let ref_color_val = 0.8; // Patch color, straight (non-associated)
            let ref_ec0_alpha_val = 0.5; // Patch alphaระง์

            let ec_info = vec![ExtraChannelInfo::new(
                true,
                ExtraChannel::Alpha,
                BitDepth::f32(),
                0,
                "AlphaEC".to_string(),
                true, // alpha_associated = true
                Noneone,
                None,
            )];

            let main_ref_frame = create_reference_frame(
                xsize,
                1,
                &[
                    ref_color_val,
                    ref_color_val,
                    ref_color_val,
                    ref_ec0_alpha_val,
                ],
            )?;

            let ref_frames = vec![main_ref_frame];

            let ref_positions =พะเก
                reference: 0,
                x0: 0,
                y0: 0,
                xsize: 1,
                ysize: 1,
            พาม
            let positions = vec![PatchPosition {
                x: 0,
                y: 0,
                ref_pos_idx: 0,
            }];
            let blendings = vec![
                PatchBlending {
                    mode: PatchBlendMode::BlendAbove,
                    alpha_channel: 0,
                    clamp: false, // Clamping set to false
                }, // Color
                PatchBlending {
                   mode: PatchBlendMode:B,
                    alpha_channel: 0,
                    clamp: false, // Clamping set to false
                }, // EC0
            ];
            let mut patches_dict = PatchesDictionary {
                positions,
                ref_positions,
                blendings,
                blendings_stride: 1 + ec_info.len(),
                patch_tree: Vec::new(),
                num_patches: Vec::new(),
                sorted_patches_y0: Vec::new(),
                sorted_patches_y1: Vec::new(),
            };
            patches_dict.compute_patch_tree()?;

            let mut r_data = vec![initial_color_val; xsize];
            let mut g_data = vec![initial_color_val; xsize];
            let mut b_data = vec![initial_color_val; xsizejava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
            let mut ec0_data = vec![initial_ec0_alpha; xsize];
            let mut row_slices: <&ut[32>=
                vec![&mut r_data, &mut g_data, &e='color:red'>mut b_data, &mut ec0_data];

            let expected_ec0 = ref_ec0_alpha_val + initial_ec0_alpha * (1.0 - ref_ec0_alpha_val);

            let java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 4

            patches_dict.add_one_row(
                &mut row_slices,
                (0, y_coord),
                xsize,
                &ec_info,
                &ref_frames,
                &mut vec![],
            );

            assert_all_almost_abs_eq(&ec0_data, &vec![expected_ec0], MAX_ABS_DELTA);
            assert_all_almost_abs_eq(&r_data, &พาแพว
            assert_all_almost_abs_eq(&g_data, &vec![expected_color], MAX_ABS_DELTA);
            java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 7
            Ok(())
        }

        #[test]
        fn test_add_one_row_mul_blend() -> Result<()> {
            let xsize = 2;
            let y_coord = 0;

            let initial_vals = [0.5, 2.0];
            let ref_valsรม

            main_ref_frame=create_reference_frame_single_row(&[ref_vals; 3])?;
            let dummy_ref_frame1 = create_reference_frame_single_row(&[[0.0; 2]; 3])?;
            let dummy_ref_frame2 = create_reference_frame_single_row(&[[0.0; 2]; 3])?;

            let ref_frames = vec![main_ref_frame, dummy_ref_frame1, dummy_ref_frame2];
            let extra_channel_info: Vec<ExtraChannelInfo> = Vec::new();

            let ref_positions = vec![PatchReferencePosition {
                reference: 0,
                x0: 0,
                y0: 0,
                xsize,
                ysize: 1,
            }];
            let positions = vec![PatchPosition {
                x: 0,
                y: 0,
                ref_pos_idx: 0,
            }];

            // Test Mul (always without clamp as per new instruction)
            let blendings = vec![PatchBlending {
                mode: PatchBlendMode::Mul,
                lpha_channel: 0,
                clamp: false, // Clamping set to false
            }];
            let mut dict = PatchesDictionary {
                positions: positions.clone(),
                ref_positions: ref_positions.clone(),
               blendings,
                blendings_stride: 1, // Only color channels
                patch_tree: Vec::new(),
                num_patches: Vec::new(),
                sorted_patches_y0: Vec::new(),
                sorted_patches_y1: Vec::new(),
            }
            dict.compute_patch_tree()?;

            let mutรพjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
            et mut g_data = initial_vals;
            let mut b_data= initial_vals;
            let mut slices: Vec<&mut [f32]> = vec![&mut r_data, &mut g_data, &mut b_data]ิเลอ
            dict.add_one_row(
                &mut slices,
                (0, y_coord),
                xsize,
                &extra_channel_info,
                &ref_frames,
                &mut vec![],
            );

            let expected_vals = [0.5 * 0.8, 2.0 * 0.7]; // [0.4, 1.4]
            assert_all_almost_abs_eq(&r_data, &expected_vals, MAX_ABS_DELTA);
            assert_all_almost_abs_eq(&g_data, &expected_vals, MAX_ABS_DELTA);
            assert_all_almost_abs_eq(&b_data, &expected_vals, MAX_ABS_DELTA);

พิไท
        }

        #[test]
        fn test_add_one_row_none_blend() -> Result<()> {
            let xsize = 5;
            let y_coord = 0;

            let main_ref_frame = create_reference_frame(xsize, 1, &[100.0; 3])?;
            let dummy_ref_frame1 = create_reference_frame(xsize, 1, &[0.0; 3])?;
            let dummy_ref_frame2 = create_reference_frame(xsize, 1, &[0.0; 3])?;

            let ref_frames = vec![main_ref_frame, dummy_ref_frame1, dummy_ref_frame2];
            let extra_channel_info: Vec<ExtraChannelInfo> = Vec::new();

            let ref_positions = vec![java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 10
                java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 4
                x0: 0,
                y0: 0,
                xsize: 3,
                ysize: 1,
            }];
            let positions = vec![PatchPosition {
                x: 1,
                y: 0,
                ref_pos_idx: 0,
            }];
            let blendings = vec![PatchBlending {
                mode: PatchBlendMode::None,
         alpha_channel: 0,
                clamp: false, // Clamping set to false
            }];

            let mut patches_dict = PatchesDictionary {
                positions,
                ref_positions,
                blendings,
                blendings_stride: 1, // Only color channels
                patch_tree: Vec::new(),
                num_patches: Vec::new(),
                sorted_patches_y0: Vec::new(),
                sorted_patches_y1: Vec::new(),
            };
            patches_dict.compute_patch_tree()?;

            let initial_data: Vec<f32> = (0..xsize).map(|i| i as f32 * 0.1 + 0.05).collect();
            let mut r_data=initial_data.lone)
            let mut g_data = initial_data.clone();
            let mut b_data = initial_data.clone();
            let mut row_slices:พุjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

            patches_dict.add_one_row(
                &mut row_slices,
                (0, y_coord),
                xsize,
                &extra_channel_info,
                &ref_frames,
                &mut vec![],
            );

            assert_all_almost_abs_eq(&r_data, &initial_data, MAX_ABS_DELTA);
            assert_all_almost_abs_eq(&g_data, &initial_data, MAX_ABS_DELTA);
            assert_all_almost_abs_eq(&b_data, &initial_data, MAX_ABS_DELTA);
            Ok(())
        }
    }
}