office-rs 0.1.1

//! Excel文件修改器模块
//!
//! 提供对现有Excel文件的修改功能，设计原理：
//! 1. 保留原有文件的所有内容和结构
//! 2. 只修改需要更改的部分
//! 3. 确保不支持的功能也能完整保留到新文件中
//! 4. 基于ZIP文件结构进行精确修改

use crate::common::{ ZipEntry, ZipReader, ZipWriter };
use crate::error::{ DocumentError, Result, XlsxError };
use crate::xlsx::{
    Cell,
    CellReference,
    CellValue,
    Workbook,
    Worksheet,
    reader::XlsxReader,
    writer::XlsxWriter,
};
use std::collections::HashMap;
use std::io::{ Cursor, Read, Write };
use std::path::Path;

/// Excel文件修改器
///
/// 用于修改现有的Excel文件，保留所有原有内容
pub struct XlsxModifier {
    /// 原始文件的ZIP条目
    original_entries: HashMap<String, Vec<u8>>,
    /// 工作簿数据
    workbook: Workbook,
    /// 修改标记
    modified_entries: HashMap<String, bool>,
}

/// 修改操作类型
#[derive(Debug, Clone)]
pub enum ModifyOperation {
    /// 设置单元格值
    SetCellValue {
        sheet_name: String,
        cell_ref: CellReference,
        value: CellValue,
    },
    /// 插入行
    InsertRow {
        sheet_name: String,
        row_index: u32,
        count: u32,
    },
    /// 删除行
    DeleteRow {
        sheet_name: String,
        row_index: u32,
        count: u32,
    },
    /// 插入列
    InsertColumn {
        sheet_name: String,
        column_index: u32,
        count: u32,
    },
    /// 删除列
    DeleteColumn {
        sheet_name: String,
        column_index: u32,
        count: u32,
    },
    /// 添加工作表
    AddWorksheet {
        name: String,
    },
    /// 删除工作表
    DeleteWorksheet {
        name: String,
    },
    /// 重命名工作表
    RenameWorksheet {
        old_name: String,
        new_name: String,
    },
}

/// 修改选项
#[derive(Debug, Clone)]
pub struct ModifyOptions {
    /// 是否保留原有格式
    pub preserve_formatting: bool,
    /// 是否保留原有公式
    pub preserve_formulas: bool,
    /// 是否保留原有图表
    pub preserve_charts: bool,
    /// 是否保留原有宏
    pub preserve_macros: bool,
    /// 是否保留原有数据验证
    pub preserve_data_validation: bool,
}

impl Default for ModifyOptions {
    fn default() -> Self {
        Self {
            preserve_formatting: true,
            preserve_formulas: true,
            preserve_charts: true,
            preserve_macros: true,
            preserve_data_validation: true,
        }
    }
}

impl XlsxModifier {
    /// 从文件创建修改器
    pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self> {
        let mut zip_reader = ZipReader::new(path)?;
        let mut original_entries = HashMap::new();

        // 读取所有ZIP条目
        for entry_name in zip_reader.entry_names()? {
            let mut content = Vec::new();
            zip_reader.read_entry(&entry_name, &mut content)?;
            original_entries.insert(entry_name, content);
        }

        // 解析工作簿
        let workbook = {
            let reader = XlsxReader::new();
            reader.read_from_zip_entries(&original_entries)?
        };

        Ok(Self {
            original_entries,
            workbook,
            modified_entries: HashMap::new(),
        })
    }

    /// 从字节数据创建修改器
    pub fn from_bytes(data: &[u8]) -> Result<Self> {
        let cursor = Cursor::new(data);
        let mut zip_reader = ZipReader::from_reader(cursor)?;
        let mut original_entries = HashMap::new();

        // 读取所有ZIP条目
        for entry_name in zip_reader.entry_names()? {
            let mut content = Vec::new();
            zip_reader.read_entry(&entry_name, &mut content)?;
            original_entries.insert(entry_name, content);
        }

        // 解析工作簿
        let workbook = {
            let reader = XlsxReader::new();
            reader.read_from_zip_entries(&original_entries)?
        };

        Ok(Self {
            original_entries,
            workbook,
            modified_entries: HashMap::new(),
        })
    }

    /// 获取工作簿引用
    pub fn workbook(&self) -> &Workbook {
        &self.workbook
    }

    /// 获取可变工作簿引用
    pub fn workbook_mut(&mut self) -> &mut Workbook {
        &mut self.workbook
    }

    /// 执行修改操作
    pub fn apply_operation(&mut self, operation: ModifyOperation) -> Result<()> {
        match operation {
            ModifyOperation::SetCellValue { sheet_name, cell_ref, value } =>
                self.set_cell_value(&sheet_name, cell_ref, value)?,
            ModifyOperation::InsertRow { sheet_name, row_index, count } =>
                self.insert_rows(&sheet_name, row_index, count)?,
            ModifyOperation::DeleteRow { sheet_name, row_index, count } =>
                self.delete_rows(&sheet_name, row_index, count)?,
            ModifyOperation::InsertColumn { sheet_name, column_index, count } =>
                self.insert_columns(&sheet_name, column_index, count)?,
            ModifyOperation::DeleteColumn { sheet_name, column_index, count } =>
                self.delete_columns(&sheet_name, column_index, count)?,
            ModifyOperation::AddWorksheet { name } => self.add_worksheet(name)?,
            ModifyOperation::DeleteWorksheet { name } => self.delete_worksheet(&name)?,
            ModifyOperation::RenameWorksheet { old_name, new_name } => {
                self.rename_worksheet(&old_name, &new_name)?;
            }
        }
        Ok(())
    }

    /// 批量执行修改操作
    pub fn apply_operations(&mut self, operations: Vec<ModifyOperation>) -> Result<()> {
        for operation in operations {
            self.apply_operation(operation)?;
        }
        Ok(())
    }

    /// 设置单元格值
    pub fn set_cell_value(
        &mut self,
        sheet_name: &str,
        cell_ref: CellReference,
        value: CellValue
    ) -> Result<()> {
        let sheet = self.workbook.get_worksheet_mut(sheet_name).ok_or_else(|| {
            DocumentError::Xlsx(XlsxError::WorksheetNotFound {
                name: sheet_name.to_string(),
            })
        })?;

        sheet.set_cell_value(cell_ref.row, cell_ref.column, value);
        self.mark_sheet_modified(sheet_name);
        Ok(())
    }

    /// 插入行
    pub fn insert_rows(&mut self, sheet_name: &str, row_index: u32, count: u32) -> Result<()> {
        let sheet = self.workbook.get_worksheet_mut(sheet_name).ok_or_else(|| {
            DocumentError::Xlsx(XlsxError::WorksheetNotFound {
                name: sheet_name.to_string(),
            })
        })?;

        sheet.insert_rows(row_index, count)?;
        self.mark_sheet_modified(sheet_name);
        Ok(())
    }

    /// 删除行
    pub fn delete_rows(&mut self, sheet_name: &str, row_index: u32, count: u32) -> Result<()> {
        let sheet = self.workbook.get_worksheet_mut(sheet_name).ok_or_else(|| {
            DocumentError::Xlsx(XlsxError::WorksheetNotFound {
                name: sheet_name.to_string(),
            })
        })?;

        sheet.delete_rows(row_index, count)?;
        self.mark_sheet_modified(sheet_name);
        Ok(())
    }

    /// 插入列
    pub fn insert_columns(
        &mut self,
        sheet_name: &str,
        column_index: u32,
        count: u32
    ) -> Result<()> {
        let sheet = self.workbook.get_worksheet_mut(sheet_name).ok_or_else(|| {
            DocumentError::Xlsx(XlsxError::WorksheetNotFound {
                name: sheet_name.to_string(),
            })
        })?;

        sheet.insert_columns(column_index, count)?;
        self.mark_sheet_modified(sheet_name);
        Ok(())
    }

    /// 删除列
    pub fn delete_columns(
        &mut self,
        sheet_name: &str,
        column_index: u32,
        count: u32
    ) -> Result<()> {
        let sheet = self.workbook.get_worksheet_mut(sheet_name).ok_or_else(|| {
            DocumentError::Xlsx(XlsxError::WorksheetNotFound {
                name: sheet_name.to_string(),
            })
        })?;

        sheet.delete_columns(column_index, count)?;
        self.mark_sheet_modified(sheet_name);
        Ok(())
    }

    /// 添加工作表
    pub fn add_worksheet(&mut self, name: String) -> Result<()> {
        self.workbook.add_worksheet(name.clone())?;
        self.mark_sheet_modified(&name);
        self.mark_workbook_modified();
        Ok(())
    }

    /// 删除工作表
    pub fn delete_worksheet(&mut self, name: &str) -> Result<()> {
        self.workbook.remove_worksheet(name)?;
        self.mark_workbook_modified();
        Ok(())
    }

    /// 重命名工作表
    pub fn rename_worksheet(&mut self, old_name: &str, new_name: &str) -> Result<()> {
        self.workbook.rename_worksheet(old_name, new_name)?;
        self.mark_sheet_modified(old_name);
        self.mark_sheet_modified(new_name);
        self.mark_workbook_modified();
        Ok(())
    }

    /// 保存修改到文件
    pub fn save_to_file<P: AsRef<Path>>(&self, path: P, options: &ModifyOptions) -> Result<()> {
        let mut zip_writer = ZipWriter::new(path)?;

        // 写入所有条目
        for (entry_name, content) in &self.original_entries {
            if self.is_entry_modified(entry_name) {
                // 重新生成修改过的条目
                let new_content = self.generate_modified_entry(entry_name, options)?;
                zip_writer.add_entry(entry_name, &new_content)?;
            } else {
                // 直接复制原有条目
                zip_writer.add_entry(entry_name, content)?;
            }
        }

        // 添加新的条目（如新工作表）
        self.add_new_entries(&mut zip_writer, options)?;

        zip_writer.finish()?;
        Ok(())
    }

    /// 保存修改到字节数组
    pub fn save_to_bytes(&self, options: &ModifyOptions) -> Result<Vec<u8>> {
        let mut buffer = Vec::new();
        {
            let cursor = Cursor::new(&mut buffer);
            let mut zip_writer = ZipWriter::from_writer(cursor)?;

            // 写入所有条目
            for (entry_name, content) in &self.original_entries {
                if self.is_entry_modified(entry_name) {
                    // 重新生成修改过的条目
                    let new_content = self.generate_modified_entry(entry_name, options)?;
                    zip_writer.add_entry(entry_name, &new_content)?;
                } else {
                    // 直接复制原有条目
                    zip_writer.add_entry(entry_name, content)?;
                }
            }

            // 添加新的条目（如新工作表）
            self.add_new_entries(&mut zip_writer, options)?;

            zip_writer.finish()?;
        }
        Ok(buffer)
    }

    /// 标记工作表已修改
    fn mark_sheet_modified(&mut self, sheet_name: &str) {
        // 标记相关的XML文件已修改
        let sheet_path = format!(
            "xl/worksheets/sheet{}.xml",
            self.workbook.get_worksheet_index(sheet_name).unwrap_or(1)
        );
        self.modified_entries.insert(sheet_path, true);
    }

    /// 标记工作簿已修改
    fn mark_workbook_modified(&mut self) {
        self.modified_entries.insert("xl/workbook.xml".to_string(), true);
        self.modified_entries.insert("[Content_Types].xml".to_string(), true);
        self.modified_entries.insert("xl/_rels/workbook.xml.rels".to_string(), true);
    }

    /// 检查条目是否已修改
    fn is_entry_modified(&self, entry_name: &str) -> bool {
        self.modified_entries.get(entry_name).copied().unwrap_or(false)
    }

    /// 生成修改过的条目内容
    fn generate_modified_entry(
        &self,
        entry_name: &str,
        options: &ModifyOptions
    ) -> Result<Vec<u8>> {
        // 根据条目类型生成新内容
        if entry_name.starts_with("xl/worksheets/") {
            self.generate_worksheet_xml(entry_name, options)
        } else if entry_name == "xl/workbook.xml" {
            self.generate_workbook_xml(options)
        } else if entry_name == "[Content_Types].xml" {
            self.generate_content_types_xml(options)
        } else if entry_name == "xl/_rels/workbook.xml.rels" {
            self.generate_workbook_rels_xml(options)
        } else {
            // 对于其他文件，返回原内容
            Ok(self.original_entries.get(entry_name).cloned().unwrap_or_default())
        }
    }

    /// 生成工作表XML
    fn generate_worksheet_xml(
        &self,
        entry_name: &str,
        _options: &ModifyOptions
    ) -> Result<Vec<u8>> {
        // 提取工作表索引
        let sheet_index = self.extract_sheet_index_from_path(entry_name)?;
        let sheet_name = self.workbook
            .worksheet_names()
            .get(sheet_index)
            .ok_or_else(|| {
                DocumentError::Xlsx(XlsxError::WorksheetNotFound {
                    name: format!("Sheet at index {}", sheet_index),
                })
            })?;

        let sheet = self.workbook.get_worksheet(sheet_name).ok_or_else(|| {
            DocumentError::Xlsx(XlsxError::WorksheetNotFound {
                name: sheet_name.clone(),
            })
        })?;

        // 使用现有的writer生成XML
        let writer = XlsxWriter::new();
        writer.generate_worksheet_xml(sheet)
    }

    /// 生成工作簿XML
    fn generate_workbook_xml(&self, _options: &ModifyOptions) -> Result<Vec<u8>> {
        let writer = XlsxWriter::new();
        writer.generate_workbook_xml(&self.workbook)
    }

    /// 生成内容类型XML
    fn generate_content_types_xml(&self, _options: &ModifyOptions) -> Result<Vec<u8>> {
        let writer = XlsxWriter::new();
        writer.generate_content_types_xml(&self.workbook)
    }

    /// 生成工作簿关系XML
    fn generate_workbook_rels_xml(&self, _options: &ModifyOptions) -> Result<Vec<u8>> {
        let writer = XlsxWriter::new();
        writer.generate_workbook_rels_xml(&self.workbook)
    }

    /// 添加新条目
    fn add_new_entries(&self, zip_writer: &mut ZipWriter, _options: &ModifyOptions) -> Result<()> {
        // 为新添加的工作表生成XML文件
        for (index, sheet_name) in self.workbook.worksheet_names().iter().enumerate() {
            let sheet_path = format!("xl/worksheets/sheet{}.xml", index + 1);
            if !self.original_entries.contains_key(&sheet_path) {
                // 这是新添加的工作表
                let sheet = self.workbook.get_worksheet(sheet_name).unwrap();
                let writer = XlsxWriter::new();
                let content = writer.generate_worksheet_xml(sheet)?;
                zip_writer.add_entry(&sheet_path, &content)?;
            }
        }
        Ok(())
    }

    /// 从路径提取工作表索引
    fn extract_sheet_index_from_path(&self, path: &str) -> Result<usize> {
        // 从 "xl/worksheets/sheet1.xml" 提取 "1"
        let filename = path
            .split('/')
            .last()
            .ok_or_else(|| DocumentError::Format("Invalid worksheet path".to_string()))?;

        let number_part = filename
            .strip_prefix("sheet")
            .and_then(|s| s.strip_suffix(".xml"))
            .ok_or_else(|| DocumentError::Format("Invalid worksheet filename".to_string()))?;

        let index = number_part
            .parse::<usize>()
            .map_err(|_| DocumentError::Format("Invalid sheet index".to_string()))?;

        Ok(index.saturating_sub(1)) // 转换为0开始的索引
    }
}

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

    #[test]
    fn test_modify_operations() {
        // 这里需要一个测试Excel文件
        // 实际测试需要准备测试数据
    }

    #[test]
    fn test_preserve_content() {
        // 测试内容保留功能
        // 确保修改后不支持的功能仍然存在
    }
}