use crate::ocr::metadata::Resize;

use crate::ocr::color_filter::{HsvRange, apply_to_image};
// use ddddocr_tract::session::{ModelOutput, OcrSession};
use crate::utils::image_convert::png_rgba_white_preprocess;
use crate::utils::image_processor::{convert_to_grayscale, resize_image};
use image::DynamicImage;
use serde::Serialize;
use std::borrow::Cow;
use std::fmt;
// use tract_onnx::prelude::tract_ndarray::{ Ix2, s};
// use tract_onnx::prelude::{DatumType, Tensor, tract_ndarray};
// ！！！【核心纠正】：彻底弃用 tract_ndarray，全线转用标准 ndarray
use ndarray::ArrayView2;
// pub enum ModelOutput {
//     Indices(ndarray::Array1<i64>), // 拥有完整所有权的 1维数组，可任意传递和返回
//     Logits(ndarray::Array2<f32>),  // 拥有完整所有权的 2维矩阵，可任意传递和返回
// }
use crate::error::{ImagePreprocessError, Result, TensorError};
use crate::{OcrEngine, OcrOutput};
use tracing::{ warn};
#[derive(Debug, Clone, Serialize)]
pub enum OcrResult {
    /// 纯文本分支（对应 probability = false）
    Text(String),
    /// 包含全量概率的分支（对应 probability = true）
    Probability {
        text: String,
        /// 满额概率矩阵 [Steps, Classes]
        probabilities: Vec<Vec<f32>>,
        /// 全局平均置信度
        confidence: f64,
    },
    /// 不支持的模型或未知输出
    Unsupported { message: String },
}
impl OcrResult {
    /// 消费自身，直接提取最终文本
    pub fn into_text(self) -> String {
        match self {
            OcrResult::Text(text) => text,
            OcrResult::Probability { text, .. } => text,
            OcrResult::Unsupported { message } => {
                // 作为库，这里可以返回空，或者直接携带错误信息，取决于你的设计
                format!("Error: {}", message)
            }
        }
    }
}
impl fmt::Display for OcrResult {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            OcrResult::Text(text) => {
                // 纯文本分支，直接输出文本内容
                write!(f, "{}", text)
            }
            OcrResult::Probability {
                text,
                probabilities,
                confidence,
            } => {
                // 概率分支，友好地展示文本以及百分比形式的置信度
                // 1. 基本信息
                write!(f, "{} (置信度: {:.2}%)", text, confidence * 100.0)?;

                // 2. 概率矩阵流式安全打印
                write!(f, " [概率矩阵预览: ")?;

                let max_steps_to_show = 10;
                let take_steps = probabilities.iter().take(max_steps_to_show);

                for (i, step_probs) in take_steps.enumerate() {
                    if i > 0 {
                        write!(f, ", ")?;
                    }

                    // 为了防止单行内部数据过长，单行也做一下截断保护（比如每行最多显示前 3 个概率）
                    let max_classes_to_show = 3;
                    write!(f, "[")?;
                    for (j, prob) in step_probs.iter().take(max_classes_to_show).enumerate() {
                        if j > 0 {
                            write!(f, ", ")?;
                        }
                        write!(f, "{:.4}", prob)?;
                    }
                    if step_probs.len() > max_classes_to_show {
                        write!(f, ", ..")?;
                    }
                    write!(f, "]")?;
                }

                // 如果总 Step 数量超过 10，末尾追加 .. 表示截断
                if probabilities.len() > max_steps_to_show {
                    write!(f, ", ..")?;
                }
                write!(f, "]")
            }
            OcrResult::Unsupported { message } => {
                // 错误分支，直观输出异常原因
                write!(f, "未识别成功: {}", message)
            }
        }
    }
}

pub struct Ocr<'a> {
    pub(crate) session: &'a dyn OcrEngine,
    pub(crate) png_fix: bool,
    pub(crate) probability: bool,
    /// 颜色过滤：保留的颜色列表
    pub(crate) final_color_ranges: Result<Option<Vec<HsvRange>>, ImagePreprocessError>,

    /// 字符集范围
    pub(crate) final_charset_indices: Option<Vec<usize>>,
}

impl<'a> Ocr<'a> {
    // 初始化任务，设置默认参数

    pub fn new(session: &'a dyn OcrEngine) -> Self {
        Ocr {
            session,
            png_fix: false, // 默认值
            probability: false,
            final_color_ranges: Ok(None),
            final_charset_indices: None,
        }
    }
}
impl<'a> Ocr<'a> {
    pub fn predict(&self, image: &DynamicImage) -> Result<OcrResult> {
        println!("当前颜色过滤器状态: {:?}", self.final_color_ranges);

        // =====================================================================
        // 管道节点 1: 颜色过滤流水线
        // 使用 Cow (Copy-On-Write) 智能指针。
        // 如果未开启过滤，img_cow 内部只是持有原图的【只读借用】，发生【零内存分配】！
        // =====================================================================
        let img_cow = match &self.final_color_ranges {
            Err(err_msg) => {
                // return Err(anyhow::anyhow!(
                //     "颜色过滤器初始化失败，全链路短路: {}",
                //     err_msg
                // ));
                return Err(ImagePreprocessError::FilterConfigInvalid(
                    err_msg.to_string(),
                ))?;
            }
            Ok(None) => {
                // 核心优化点：直接借用原图，不发生任何克隆
                Cow::Borrowed(image)
            }
            Ok(Some(ranges)) => {
                // 只有真正需要过滤时，才在内部提取像素并生成清洗后的 Owned 新图
                let filtered_img = apply_to_image(image, ranges)?;
                Cow::Owned(filtered_img)
            }
        };
        let tensor = self.preprocess_image(&img_cow)?;

        let raw_tensor = self.session.inference(tensor)?;

        // 3. 后处理分流：直接返回 OcrResult
        // let ocr_output = match raw_tensor.datum_type() {
        //     DatumType::I64 => self.process_i64_tensor(raw_tensor)?,
        //     DatumType::F32 => self.process_f32_tensor(raw_tensor)?,
        //     _ => OcrResult::Unsupported {
        //         message: format!("不支持的模型输出数据类型: {:?}", raw_tensor.datum_type()),
        //     },
        // };

        // let raw_indices = self.ocr.extract_indices_from_tensor(&raw_tensor)?;
        // // 步骤 2: 将索引切片 `&[i64]` 传给解码器进行 CTC 去重和字符映射
        // let final_text = self.ctc_decode_to_string(&raw_indices);
        let ocr_output = self.process_model_output(raw_tensor)?;
        Ok(ocr_output)
    }
    /// 对应 Python 的 _preprocess_image
    /// 负责：透明背景修复 -> 灰度化 -> 按比例 Resize -> 归一化 -> 4维张量转换
    fn preprocess_image(&self, img: &DynamicImage) -> Result<ndarray::Array4<f32>,ImagePreprocessError> {
        // 1. 获取模型元数据配置
        let meta = self.session.metadata();
        let norm = &meta.normalization; // 获取归一化器

        // A. 修复 PNG 透明背景 (内部逻辑你之前已实现)
        let current_img = if self.png_fix && img.color().has_alpha() {
            // 只有满足条件才去触发分配，生成新图
            Cow::Owned(png_rgba_white_preprocess(img))
        } else {
            // 正常情况下，仅仅是再次安全借用，无开销
            Cow::Borrowed(img)
        };

        // 3. 管道节点 2: 根据 Resize 策略计算目标宽高并进行缩放
        let (target_w, target_h) = match meta.resize {
            Resize::Fixed(w, h) => (w, h),
            Resize::DynamicWidth(h) => {
                // 高度固定，宽度根据原始比例动态计算：W_target = W_orig * (H_target / H_orig)
                let w =
                    (current_img.width() as f32 * (h as f32 / current_img.height() as f32)) as u32;
                (w, h)
            }
            Resize::Square(size) => {
                // 单字识别模型，直接缩放为正方形
                (size, size)
            }
        };
        // 执行缩放
        let resized_img = resize_image(&current_img, target_w, target_h);

        // 4. 管道节点 3: 颜色通道转换（单通道灰度 vs 三通道 RGB）与 4D 张量填充
        let array4 = match meta.channel {
            // --- 情况 A: 单通道（灰度图），对应 Python 的 len(shape) == 2 展开 ---
            1 => {
                let gray_img = convert_to_grayscale(&resized_img);

                let array = ndarray::Array4::from_shape_fn(
                    (1, 1, target_h as usize, target_w as usize),
                    |(_, _, y, x)| {
                        let pixel = gray_img.get_pixel(x as u32, y as u32)[0] as f32;
                        // pixel / 255.0 // 严格对齐 Python 归一化 [0.0, 1.0]
                        // (pixel / 255.0 - 0.5) / 0.5
                        norm.normalize(pixel)
                    },
                );
                array
            }

            // --- 情况 B: 三通道（RGB），对应 Python 的 transpose(2, 0, 1) 的 CHW 布局 ---
            3 => {
                let rgb_img = resized_img.to_rgb8();

                let array = ndarray::Array4::from_shape_fn(
                    (1, 3, target_h as usize, target_w as usize),
                    |(_, c, y, x)| {
                        let pixel = rgb_img.get_pixel(x as u32, y as u32)[c] as f32;
                        // pixel / 255.0 // 严格对齐 Python 归一化 [0.0, 1.0]
                        // (pixel / 255.0 - 0.5) / 0.5
                        norm.normalize(pixel)
                    },
                );
                // Tensor::from(array)
                array
            }

            // _ => return Err(anyhow::anyhow!("不支持的通道数配置: {}", meta.channel)),
            _ => {
                return Err(ImagePreprocessError::UnsupportedChannels(
                    meta.channel as usize,
                ));
            }
        };
        Ok(array4)
        // Ok(tensor)

        // let h = 64u32;
        // let w = (current_img.width() as f32 * (h as f32 / current_img.height() as f32)) as u32;
        // let gray_img = convert_to_grayscale(&current_img);
        // let resized = resize_image(&gray_img, w, h);
        // // resized.save("debug_preprocessed.png").unwrap();
        // // 1. 预处理：转灰度 -> Resize -> 归一化
        // // let resized = img.resize_exact(w, h, FilterType::Lanczos3).to_luma8();
        //
        // // 使用 tract_ndarray 构造，避免版本冲突
        // let array =
        //     tract_ndarray::Array4::from_shape_fn((1, 1, h as usize, w as usize), |(_, _, y, x)| {
        //         let pixel = resized.get_pixel(x as u32, y as u32)[0] as f32;
        //         (pixel / 255.0 - 0.5) / 0.5
        //     });
        //
        // let tensor = Tensor::from(array);
        //
        // Ok(tensor)
    }

    // 这段代码未来直接放入 ddddocr-core
    fn process_model_output(&self, output: OcrOutput) -> Result<OcrResult,TensorError> {
        match output {
            OcrOutput::Indices(array1) => {
                // 对应你原来的 process_i64_tensor
                let slice = array1
                    .as_slice()
                    // .ok_or_else(|| anyhow::anyhow!("内存不连续，无法执行零拷贝解码"))?;
                    .ok_or_else(|| TensorError::NonContiguousMemory)?;
                let final_text = self.ctc_decode_to_string(slice);

                if self.probability {
                    Ok(OcrResult::Probability {
                        text: final_text,
                        probabilities: vec![],
                        confidence: 1.0,
                    })
                } else {
                    Ok(OcrResult::Text(final_text))
                }
            }
            OcrOutput::Logits(matrix_view) => {
                // 对应你原来的 process_f32_tensor
                // 注意：此时的 matrix_view 已经是干净的标准的 ndarray::Array2<f32>，且保证是 [Steps, Classes] 2D 形状
                if self.probability {
                    let (probabilities_list, confidence, predicted_indices) =
                        self.compute_f32_full_probability(matrix_view.view());
                    let final_text = self.ctc_decode_to_string(&predicted_indices);
                    Ok(OcrResult::Probability {
                        text: final_text,
                        probabilities: probabilities_list,
                        confidence: confidence as f64,
                    })
                } else {
                    let predicted_indices: Vec<i64> = matrix_view
                        .outer_iter()
                        .map(|row| {
                            row.iter()
                                .enumerate()
                                .max_by(|(_, a), (_, b)| a.total_cmp(b))
                                .map(|(idx, _)| idx as i64)
                                .unwrap_or(0)
                        })
                        .collect();

                    let final_text = self.ctc_decode_to_string(&predicted_indices);
                    Ok(OcrResult::Text(final_text))
                }
            }
        }
    }
}
impl<'a> Ocr<'a> {
    fn is_valid_indices(&self, idx: usize) -> bool {
        if idx >= self.session.metadata().charset.size() {
            return false;
        }

        match &self.final_charset_indices {
            Some(v) => v.binary_search(&idx).is_ok(),
            None => true,
        }
    }
    /// 【按需延迟打印】：当用户真的需要“知道当前有哪些限制字符”时，一秒反查并打印
    /// 这里的 &str 完美借用了自 tokens，依然是彻底的零拷贝！
    pub fn valid_tokens(&self) -> Vec<&str> {
        let charset = &self.session.metadata().charset;
        let tokens = &charset.tokens;
        match &self.final_charset_indices {
            Some(indices) => indices
                .iter()
                .filter_map(|&idx| tokens.get(idx).map(|cow| cow.as_ref()))
                .collect(),
            // 如果是 None，现场映射出全量 Token 视图给外部
            None => tokens.iter().map(|cow| cow.as_ref()).collect(),
        }
    }
    pub fn valid_size(&self) -> usize {
        match &self.final_charset_indices {
            Some(indices) => indices.len(),
            None => self.session.metadata().charset.tokens.len(),
        }
    }
    /// 变体 B 核心处理器：单次遍历 2D 视图，融合计算 Softmax、Argmax、置信度并输出概率大包
    fn compute_f32_full_probability(
        &self,
        matrix_view: ArrayView2<f32>,
    ) -> (Vec<Vec<f32>>, f32, Vec<i64>) {
        let steps = matrix_view.nrows();
        let classes = matrix_view.ncols();

        // 1. 预分配满额概率矩阵内存
        let mut prob_matrix = ndarray::Array2::<f32>::zeros((steps, classes));
        let mut predicted_indices = Vec::with_capacity(steps);
        let mut confidence_sum = 0.0f32;

        // 2. 融合单次遍历
        for (step_idx, row) in matrix_view.outer_iter().enumerate() {
            // 寻找当前 Step 的最大值和最大值索引 (Argmax)
            let (row_max_idx, max_logit) = row
                .iter()
                .enumerate()
                .max_by(|(_, a), (_, b)| a.total_cmp(b))
                .map(|(idx, &val)| (idx, val))
                .unwrap_or((0, 0.0));

            predicted_indices.push(row_max_idx as i64);

            // 计算单行 exp 溢出防范和
            let mut exp_sum = 0.0f32;
            for &val in row.iter() {
                exp_sum += (val - max_logit).exp();
            }

            // 归一化 Softmax 顺序写入
            for (class_idx, &val) in row.iter().enumerate() {
                prob_matrix[[step_idx, class_idx]] = (val - max_logit).exp() / exp_sum;
            }

            // 当前 Step 最大概率在线累加
            confidence_sum += 1.0f32 / exp_sum;
        }

        // 3. 统计全局平均置信度
        let confidence = if steps > 0 {
            confidence_sum / steps as f32
        } else {
            1.0
        };

        // 4. 将矩阵转化为标准安全序列化格式 [Steps, Classes]
        let probabilities_list: Vec<Vec<f32>> =
            prob_matrix.outer_iter().map(|row| row.to_vec()).collect();

        (probabilities_list, confidence, predicted_indices)
    }
    /// 变体 A 专属提取器：直接从 I64 Tensor 零拷贝提取 CTC 文本与初始概率包
    // fn process_i64_tensor(&self, raw_tensor: Tensor) -> anyhow::Result<OcrResult> {
    //     // 1. 拿到底层的动态维度只读视图
    //     let view = raw_tensor.to_array_view::<i64>()?;
    //
    //     // 2. 索要底层连续的只读切片引用
    //     let slice = view
    //         .as_slice()
    //         .ok_or_else(|| anyhow::anyhow!("I64 模型输出内存不连续，无法执行零拷贝解码"))?;
    //
    //     // 3. 直接喂给 CTC 解码器（无任何物理克隆开销）
    //     let final_text = self.ctc_decode_to_string(slice);
    //
    //     // 4. 组装返回
    //     if self.probability {
    //         Ok(OcrResult::Probability {
    //             text: final_text,
    //             probabilities: vec![], // I64 模型物理上丢失了全量 Logits 分值网，降级处理
    //             confidence: 1.0,       // 判定即百分之百置信
    //         })
    //     } else {
    //         Ok(OcrResult::Text(final_text))
    //     }
    // }
    // /// 变体二（F32）的总体管线：负责降维，并分流文本和概率
    // fn process_f32_tensor(&self, raw_tensor: Tensor) -> anyhow::Result<OcrResult> {
    //     let shape = raw_tensor.shape();
    //     println!("模型输出shape数据: {:?}", shape);
    //     let view = raw_tensor.to_array_view::<f32>()?;
    //
    //     // 1. 极其纯粹的、无拷贝的多维 Shape 压扁清洗
    //     let (steps, classes, data_dyn_view) = match shape.len() {
    //         3 => {
    //             if shape[1] == 1 {
    //                 // 形状: [Steps, 1, Classes] -> 你的原有逻辑
    //                 (shape[0], shape[2], view.into_dyn())
    //             } else if shape[0] == 1 {
    //                 // 形状: [1, Steps, Classes] -> 另一种常见导出格式
    //                 (shape[1], shape[2], view.into_dyn())
    //             } else {
    //                 // 默认取第一个 batch: [Batch, Steps, Classes]
    //                 // 使用 slice 对应 Python 的 output[0, :, :]
    //                 let sliced = view.slice(s![0, .., ..]);
    //                 (shape[1], shape[2], sliced.into_dyn())
    //             }
    //         }
    //         // 形状: [Steps, Classes] -> 已经剥离了 Batch 维度
    //         2 => (shape[0], shape[1], view.into_dyn()),
    //         // 形状: [Classes] -> 单字符输出（对应 Python 的 ndim == 0 保护逻辑）
    //         // 我们把它虚构成一个 [1, Classes] 的 2D 矩阵来复用后面的 argmax 逻辑
    //         1 => (1, shape[0], view.into_dyn()),
    //         _ => return Err(anyhow::anyhow!("不支持的输出维度: {:?}", shape)),
    //     };
    //     let matrix_cow = data_dyn_view
    //         .to_shape(Ix2(steps, classes))
    //         .map_err(|e| anyhow::anyhow!("转换为2D静态矩阵失败: {:?}", e))?;
    //
    //     let matrix_view: ArrayView2<f32> = matrix_cow.view();
    //
    //     // 2. 根据业务参数明确分流
    //     if self.probability {
    //         // 走向 B1：调用刚刚拆分出来的“全量概率计算器”
    //         let (probabilities_list, confidence, predicted_indices) =
    //             self.compute_f32_full_probability(matrix_view);
    //         // 5. 执行 CTC 解码
    //         let final_text = self.ctc_decode_to_string(&predicted_indices);
    //
    //         Ok(OcrResult::Probability {
    //             text: final_text,
    //             probabilities: probabilities_list,
    //             confidence: confidence as f64,
    //         })
    //     } else {
    //         // 走向 B2：极速免 Softmax 提取纯文本（代码保持原地提取，简单短小不需要再拆）
    //         let predicted_indices: Vec<i64> = matrix_view
    //             .outer_iter()
    //             .map(|row| {
    //                 row.iter()
    //                     .enumerate()
    //                     .max_by(|(_, a), (_, b)| a.total_cmp(b))
    //                     .map(|(idx, _)| idx as i64)
    //                     .unwrap_or(0)
    //             })
    //             .collect();
    //
    //         let final_text = self.ctc_decode_to_string(&predicted_indices);
    //         Ok(OcrResult::Text(final_text))
    //     }
    // }
    /// 获取有效字符索引列表 (用于外部验证或过滤)
    fn ctc_decode_to_string(&self, predicted_indices: &[i64]) -> String {
        println!("indices模型输出原始数据: {:?}", predicted_indices);
        let charset = &self.session.metadata().charset;
        let tokens = &charset.tokens;
        // let valid_indices = &charset.valid_indices;

        // 对应 _ctc_decode_indices 的逻辑：去重、去 blank (0)
        let mut res = String::new();
        let mut prev_idx: i64 = -1;

        for &idx in predicted_indices {
            // 1. CTC 去重：如果是连续重复的，直接跳过
            if idx == prev_idx {
                continue;
            }
            // 【关键核心】只要不是连续重复，立刻更新 prev_idx 状态，绝对不能被后续的过滤短路！
            prev_idx = idx;

            // 2. CTC 过滤 Blank (0)
            if idx == 0 {
                continue;
            }
            // 3. 类型安全转换
            let u_idx = match usize::try_from(idx) {
                Ok(u) => u,
                Err(_) => continue,
            };

            // 史诗级加速点：如果是 None，说明没限制，根本不进入分支，直接放行！
            // 只有当有具体限制（Some）时，才去跑 4-5 次 CPU 寄存器级别的二分查找
            if let Some(ref indices) = self.final_charset_indices {
                if indices.binary_search(&u_idx).is_err() {
                    continue;
                }
            }

            // 5. 字符映射
            if let Some(char_str) = tokens.get(u_idx) {
                res.push_str(char_str);
            }
            else {
                warn!("警告: 预测索引 {} 超出字符集范围", u_idx);
            }
        }
        res
    }
}