office-rs 0.1.1

//! Excel (XLSX) 文件读取器
//!
//! 提供读取 XLSX 文件的功能，包括解析工作簿结构、工作表数据和单元格内容。

use crate::common::xml_utils::{ XmlElement, XmlParser };
use crate::common::zip_utils::ZipReader;
use crate::context::ErrorContext;
use crate::error::{ OfficeError, Result };
use crate::xlsx::{
    Cell,
    CellReference,
    CellType,
    CellValue,
    Workbook,
    WorkbookProperties,
    Worksheet,
    WorksheetProperties,
};
use std::collections::HashMap;
use std::fs::File;
use std::io::BufReader;
use std::path::Path;

/// XLSX 文件读取器
pub struct XlsxReader {
    zip_reader: ZipReader<BufReader<File>>,
    shared_strings: Vec<String>,
    workbook_xml: Option<XmlElement>,
}

impl XlsxReader {
    /// 打开 XLSX 文件
    pub fn open<P: AsRef<Path>>(path: P) -> Result<Self> {
        let zip_reader = ZipReader::open_file(&path).map_err(|e| {
            e.with_context(ErrorContext {
                operation: Some("打开XLSX文件".to_string()),
                file_path: Some(path.as_ref().to_string_lossy().to_string()),
                ..Default::default()
            })
        })?;

        let mut reader = Self {
            zip_reader,
            shared_strings: Vec::new(),
            workbook_xml: None,
        };

        // 加载共享字符串
        reader.load_shared_strings()?;

        // 加载工作簿XML
        reader.load_workbook_xml()?;

        Ok(reader)
    }

    /// 读取工作簿
    pub fn read_workbook(&mut self) -> Result<Workbook> {
        let workbook_xml = self.workbook_xml.as_ref().ok_or_else(|| {
            OfficeError::Parse(crate::error::ParseError::MissingElement {
                element: "workbook XML".to_string(),
            })
        })?;

        // 解析工作簿属性
        let properties = self.parse_workbook_properties(workbook_xml)?;

        // 创建空工作簿（不包含默认工作表）
        let mut workbook = Workbook::new_empty();

        // 解析工作表列表
        let worksheet_names = self.parse_worksheet_list(workbook_xml)?;

        // 加载每个工作表
        for (sheet_name, sheet_id) in worksheet_names {
            let worksheet = self.read_worksheet(&sheet_name, sheet_id)?;
            // 直接添加工作表到工作簿
            workbook.add_worksheet_direct(sheet_name, worksheet);
        }

        Ok(workbook)
    }

    /// 读取指定工作表
    pub fn read_worksheet(&mut self, name: &str, sheet_id: u32) -> Result<Worksheet> {
        let sheet_path = format!("xl/worksheets/sheet{}.xml", sheet_id);

        if !self.zip_reader.contains_file(&sheet_path) {
            return Err(
                OfficeError::Parse(crate::error::ParseError::MissingElement {
                    element: format!("worksheet file: {}", sheet_path),
                })
            );
        }

        let xml_content = self.zip_reader.read_file_to_string(&sheet_path)?;
        let parser = XmlParser::new();
        let xml_element = parser.parse_string(&xml_content)?;

        self.parse_worksheet(&xml_element, name)
    }

    /// 加载共享字符串
    fn load_shared_strings(&mut self) -> Result<()> {
        const SHARED_STRINGS_PATH: &str = "xl/sharedStrings.xml";

        if !self.zip_reader.contains_file(SHARED_STRINGS_PATH) {
            // 没有共享字符串文件是正常的
            return Ok(());
        }

        let xml_content = self.zip_reader.read_file_to_string(SHARED_STRINGS_PATH)?;
        let parser = XmlParser::new();
        let xml_element = parser.parse_string(&xml_content)?;

        self.shared_strings = self.parse_shared_strings(&xml_element)?;

        Ok(())
    }

    /// 加载工作簿XML
    fn load_workbook_xml(&mut self) -> Result<()> {
        const WORKBOOK_PATH: &str = "xl/workbook.xml";

        if !self.zip_reader.contains_file(WORKBOOK_PATH) {
            return Err(
                OfficeError::Parse(crate::error::ParseError::MissingElement {
                    element: "workbook file".to_string(),
                })
            );
        }

        let xml_content = self.zip_reader.read_file_to_string(WORKBOOK_PATH)?;
        let parser = XmlParser::new();
        let xml_element = parser.parse_string(&xml_content)?;

        self.workbook_xml = Some(xml_element);

        Ok(())
    }

    /// 解析工作簿属性
    fn parse_workbook_properties(&self, workbook_xml: &XmlElement) -> Result<WorkbookProperties> {
        let mut properties = WorkbookProperties::default();

        // 查找文档属性
        if let Some(props_element) = workbook_xml.find_child("fileVersion") {
            if let Some(app_name) = props_element.get_attribute("appName") {
                properties.title = Some(app_name.clone());
            }
        }

        Ok(properties)
    }

    /// 解析工作表列表
    fn parse_worksheet_list(&self, workbook_xml: &XmlElement) -> Result<Vec<(String, u32)>> {
        let mut worksheets = Vec::new();

        if let Some(sheets_element) = workbook_xml.find_child("sheets") {
            for sheet_element in &sheets_element.children {
                if sheet_element.name == "sheet" {
                    let name = sheet_element.get_attribute("name").ok_or_else(|| {
                        OfficeError::Parse(crate::error::ParseError::MissingElement {
                            element: "worksheet name attribute".to_string(),
                        })
                    })?;

                    let sheet_id_str = sheet_element.get_attribute("sheetId").ok_or_else(|| {
                        OfficeError::Parse(crate::error::ParseError::MissingElement {
                            element: "worksheet sheetId attribute".to_string(),
                        })
                    })?;

                    let sheet_id: u32 = sheet_id_str.parse().map_err(|_| {
                        OfficeError::Parse(crate::error::ParseError::InvalidAttribute {
                            attribute: "sheetId".to_string(),
                            value: sheet_id_str.to_string(),
                        })
                    })?;

                    worksheets.push((name.clone(), sheet_id));
                }
            }
        }

        Ok(worksheets)
    }

    /// 解析工作表
    fn parse_worksheet(&self, xml_element: &XmlElement, name: &str) -> Result<Worksheet> {
        let mut worksheet = Worksheet::new(name.to_string());

        // 查找工作表数据
        if let Some(sheet_data) = xml_element.find_child("sheetData") {
            self.parse_sheet_data(sheet_data, &mut worksheet)?;
        }

        Ok(worksheet)
    }

    /// 解析工作表数据
    fn parse_sheet_data(&self, sheet_data: &XmlElement, worksheet: &mut Worksheet) -> Result<()> {
        for row_element in &sheet_data.children {
            if row_element.name == "row" {
                self.parse_row(row_element, worksheet)?;
            }
        }

        Ok(())
    }

    /// 解析行数据
    fn parse_row(&self, row_element: &XmlElement, worksheet: &mut Worksheet) -> Result<()> {
        for cell_element in &row_element.children {
            if cell_element.name == "c" {
                self.parse_cell(cell_element, worksheet)?;
            }
        }

        Ok(())
    }

    /// 解析单元格
    fn parse_cell(&self, cell_element: &XmlElement, worksheet: &mut Worksheet) -> Result<()> {
        // 获取单元格引用
        let cell_ref = cell_element.get_attribute("r").ok_or_else(|| {
            OfficeError::Parse(crate::error::ParseError::MissingElement {
                element: "cell reference attribute".to_string(),
            })
        })?;

        // 解析单元格引用
        let (row, col) = self.parse_cell_reference(&cell_ref)?;

        // 获取单元格类型
        let cell_type = cell_element.get_attribute("t").map_or("n", |v| v.as_str());

        // 解析单元格值
        let cell_value = if let Some(value_element) = cell_element.find_child("v") {
            let value_text = value_element.text_content.as_deref().unwrap_or("");
            self.parse_cell_value(value_text, cell_type)?
        } else {
            CellValue::Empty
        };

        // 创建单元格引用和单元格
        let cell_reference = CellReference::new(col - 1, row - 1); // 转换为0开始的索引
        let cell = Cell::new(cell_reference, cell_value);
        worksheet.set_cell(cell);

        Ok(())
    }

    /// 解析单元格引用 (如 "A1" -> (1, 1))
    fn parse_cell_reference(&self, cell_ref: &str) -> Result<(u32, u32)> {
        let mut col = 0u32;
        let mut row_start = 0;

        // 解析列部分 (字母)
        for (i, ch) in cell_ref.chars().enumerate() {
            if ch.is_ascii_alphabetic() {
                col = col * 26 + ((ch.to_ascii_uppercase() as u32) - (b'A' as u32) + 1);
            } else {
                row_start = i;
                break;
            }
        }

        // 解析行部分 (数字)
        let row_str = &cell_ref[row_start..];
        let row: u32 = row_str.parse().map_err(|_| {
            OfficeError::Parse(crate::error::ParseError::InvalidAttribute {
                attribute: "cell reference".to_string(),
                value: cell_ref.to_string(),
            })
        })?;

        Ok((row, col))
    }

    /// 解析单元格值
    fn parse_cell_value(&self, value_text: &str, cell_type: &str) -> Result<CellValue> {
        match cell_type {
            "s" => {
                // 共享字符串
                let index: usize = value_text.parse().map_err(|_| {
                    OfficeError::Parse(crate::error::ParseError::InvalidAttribute {
                        attribute: "shared string index".to_string(),
                        value: value_text.to_string(),
                    })
                })?;

                if index < self.shared_strings.len() {
                    Ok(CellValue::Text(self.shared_strings[index].clone()))
                } else {
                    Err(
                        OfficeError::Xlsx(crate::error::XlsxError::SharedStringIndexOutOfRange {
                            index,
                        })
                    )
                }
            }
            "b" => {
                // 布尔值
                match value_text {
                    "1" | "true" => Ok(CellValue::Boolean(true)),
                    "0" | "false" => Ok(CellValue::Boolean(false)),
                    _ =>
                        Err(
                            OfficeError::Parse(crate::error::ParseError::InvalidAttribute {
                                attribute: "boolean value".to_string(),
                                value: value_text.to_string(),
                            })
                        ),
                }
            }
            "n" | _ => {
                // 数字 (默认类型)
                if value_text.is_empty() {
                    Ok(CellValue::Empty)
                } else {
                    value_text
                        .parse::<f64>()
                        .map(CellValue::Number)
                        .map_err(|_| {
                            OfficeError::Parse(crate::error::ParseError::InvalidAttribute {
                                attribute: "number value".to_string(),
                                value: value_text.to_string(),
                            })
                        })
                }
            }
        }
    }

    /// 解析共享字符串
    fn parse_shared_strings(&self, xml_element: &XmlElement) -> Result<Vec<String>> {
        let mut strings = Vec::new();

        for si_element in &xml_element.children {
            if si_element.name == "si" {
                // 查找文本元素
                if let Some(t_element) = si_element.find_child("t") {
                    let text = t_element.text_content.as_deref().unwrap_or("").to_string();
                    strings.push(text);
                } else {
                    // 处理富文本格式
                    let mut rich_text = String::new();
                    for r_element in &si_element.children {
                        if r_element.name == "r" {
                            if let Some(t_element) = r_element.find_child("t") {
                                rich_text.push_str(t_element.text_content.as_deref().unwrap_or(""));
                            }
                        }
                    }
                    strings.push(rich_text);
                }
            }
        }

        Ok(strings)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    // 创建一个测试用的XlsxReader，不包含zip_reader字段的测试
    struct TestXlsxReader {
        shared_strings: Vec<String>,
    }

    impl TestXlsxReader {
        fn new() -> Self {
            Self {
                shared_strings: Vec::new(),
            }
        }

        fn with_shared_strings(shared_strings: Vec<String>) -> Self {
            Self { shared_strings }
        }

        fn parse_cell_reference(&self, cell_ref: &str) -> Result<(u32, u32)> {
            let mut col = 0u32;
            let mut row_start = 0;

            // 解析列部分 (字母)
            for (i, ch) in cell_ref.chars().enumerate() {
                if ch.is_ascii_alphabetic() {
                    col = col * 26 + ((ch.to_ascii_uppercase() as u32) - (b'A' as u32) + 1);
                } else {
                    row_start = i;
                    break;
                }
            }

            // 解析行部分 (数字)
            let row_str = &cell_ref[row_start..];
            let row: u32 = row_str.parse().map_err(|_| {
                OfficeError::Parse(crate::error::ParseError::InvalidAttribute {
                    attribute: "cell reference".to_string(),
                    value: cell_ref.to_string(),
                })
            })?;

            Ok((row, col))
        }

        fn parse_cell_value(&self, value_text: &str, cell_type: &str) -> Result<CellValue> {
            match cell_type {
                "s" => {
                    // 共享字符串
                    let index: usize = value_text.parse().map_err(|_| {
                        OfficeError::Parse(crate::error::ParseError::InvalidAttribute {
                            attribute: "shared string index".to_string(),
                            value: value_text.to_string(),
                        })
                    })?;

                    if index < self.shared_strings.len() {
                        Ok(CellValue::Text(self.shared_strings[index].clone()))
                    } else {
                        Err(
                            OfficeError::Xlsx(crate::error::XlsxError::SharedStringIndexOutOfRange {
                                index,
                            })
                        )
                    }
                }
                "b" => {
                    // 布尔值
                    match value_text {
                        "1" | "true" => Ok(CellValue::Boolean(true)),
                        "0" | "false" => Ok(CellValue::Boolean(false)),
                        _ =>
                            Err(
                                OfficeError::Parse(crate::error::ParseError::InvalidAttribute {
                                    attribute: "boolean value".to_string(),
                                    value: value_text.to_string(),
                                })
                            ),
                    }
                }
                "n" | _ => {
                    // 数字 (默认类型)
                    if value_text.is_empty() {
                        Ok(CellValue::Empty)
                    } else {
                        value_text
                            .parse::<f64>()
                            .map(CellValue::Number)
                            .map_err(|_| {
                                OfficeError::Parse(crate::error::ParseError::InvalidAttribute {
                                    attribute: "number value".to_string(),
                                    value: value_text.to_string(),
                                })
                            })
                    }
                }
            }
        }
    }

    #[test]
    fn test_parse_cell_reference() {
        let reader = TestXlsxReader::new();

        assert_eq!(reader.parse_cell_reference("A1").unwrap(), (1, 1));
        assert_eq!(reader.parse_cell_reference("B2").unwrap(), (2, 2));
        assert_eq!(reader.parse_cell_reference("Z26").unwrap(), (26, 26));
        assert_eq!(reader.parse_cell_reference("AA27").unwrap(), (27, 27));
    }

    #[test]
    fn test_parse_cell_value() {
        let reader = TestXlsxReader::with_shared_strings(
            vec!["Hello".to_string(), "World".to_string()]
        );

        // 测试数字
        assert_eq!(reader.parse_cell_value("123.45", "n").unwrap(), CellValue::Number(123.45));

        // 测试布尔值
        assert_eq!(reader.parse_cell_value("1", "b").unwrap(), CellValue::Boolean(true));
        assert_eq!(reader.parse_cell_value("0", "b").unwrap(), CellValue::Boolean(false));

        // 测试共享字符串
        assert_eq!(
            reader.parse_cell_value("0", "s").unwrap(),
            CellValue::Text("Hello".to_string())
        );
        assert_eq!(
            reader.parse_cell_value("1", "s").unwrap(),
            CellValue::Text("World".to_string())
        );
    }
}