office-rs 0.1.1

//! Excel工作簿模块
//! 提供工作簿管理、工作表操作等功能

use crate::error::{ OfficeError, Result, XlsxError };
use crate::xlsx::worksheet::Worksheet;
use std::collections::HashMap;
use std::path::Path;

/// 工作簿属性
#[derive(Debug, Clone)]
pub struct WorkbookProperties {
    /// 工作簿标题
    pub title: Option<String>,
    /// 作者
    pub author: Option<String>,
    /// 公司
    pub company: Option<String>,
    /// 创建时间
    pub created: Option<String>,
    /// 修改时间
    pub modified: Option<String>,
    /// 版本
    pub version: Option<String>,
}

/// Excel工作簿
#[derive(Debug, Clone)]
pub struct Workbook {
    /// 工作簿属性
    pub properties: WorkbookProperties,
    /// 工作表集合（按名称索引）
    worksheets: HashMap<String, Worksheet>,
    /// 工作表顺序（保持插入顺序）
    worksheet_order: Vec<String>,
    /// 活动工作表名称
    active_worksheet: Option<String>,
    /// 共享字符串表
    shared_strings: Vec<String>,
}

impl WorkbookProperties {
    /// 创建新的工作簿属性
    pub fn new() -> Self {
        Self {
            title: None,
            author: None,
            company: None,
            created: None,
            modified: None,
            version: None,
        }
    }

    /// 设置标题
    pub fn with_title(mut self, title: String) -> Self {
        self.title = Some(title);
        self
    }

    /// 设置作者
    pub fn with_author(mut self, author: String) -> Self {
        self.author = Some(author);
        self
    }

    /// 设置公司
    pub fn with_company(mut self, company: String) -> Self {
        self.company = Some(company);
        self
    }

    /// 设置版本
    pub fn with_version(mut self, version: String) -> Self {
        self.version = Some(version);
        self
    }
}

impl Workbook {
    /// 创建新的工作簿
    pub fn new() -> Self {
        let mut workbook = Self {
            properties: WorkbookProperties::new(),
            worksheets: HashMap::new(),
            worksheet_order: Vec::new(),
            active_worksheet: None,
            shared_strings: Vec::new(),
        };

        // 默认添加一个工作表
        workbook
            .add_worksheet("Sheet1".to_string())
            .map_err(|e| {
                OfficeError::Xlsx(XlsxError::WorksheetCreationFailed {
                    name: e.to_string(),
                })
            })
            .unwrap();

        workbook
    }

    /// 创建空的工作簿（不包含默认工作表）
    pub fn new_empty() -> Self {
        Self {
            properties: WorkbookProperties::new(),
            worksheets: HashMap::new(),
            worksheet_order: Vec::new(),
            active_worksheet: None,
            shared_strings: Vec::new(),
        }
    }

    /// 从文件路径打开工作簿
    pub fn open<P: AsRef<Path>>(path: P) -> Result<Self> {
        let mut reader = crate::xlsx::XlsxReader::open(path)?;
        reader.read_workbook()
    }

    /// 添加工作表
    pub fn add_worksheet(&mut self, name: String) -> Result<()> {
        if self.worksheets.contains_key(&name) {
            return Err(
                OfficeError::Xlsx(XlsxError::WorksheetCreationFailed {
                    name: format!("工作表 '{}' 已存在", name),
                })
            );
        }

        let worksheet = Worksheet::new(name.clone());
        self.worksheets.insert(name.clone(), worksheet);
        self.worksheet_order.push(name.clone());

        // 如果这是第一个工作表，设置为活动工作表
        if self.active_worksheet.is_none() {
            self.active_worksheet = Some(name);
        }

        Ok(())
    }

    /// 创建新的工作表，使用默认命名规则（Sheet1, Sheet2, ...）
    pub fn new_worksheet(&mut self) -> Worksheet {
        let name = self.generate_next_sheet_name();
        Worksheet::new(name)
    }

    /// 生成下一个默认工作表名称
    fn generate_next_sheet_name(&self) -> String {
        let mut index = 1;
        loop {
            let name = format!("Sheet{}", index);
            if !self.worksheets.contains_key(&name) {
                return name;
            }
            index += 1;
        }
    }

    /// 直接添加工作表（用于读取器，不进行重复检查）
    pub fn add_worksheet_direct(&mut self, name: String, worksheet: Worksheet) {
        self.worksheets.insert(name.clone(), worksheet);
        self.worksheet_order.push(name.clone());

        // 如果这是第一个工作表，设置为活动工作表
        if self.active_worksheet.is_none() {
            self.active_worksheet = Some(name);
        }
    }

    /// 获取工作表
    pub fn get_worksheet(&self, name: &str) -> Option<&Worksheet> {
        self.worksheets.get(name)
    }

    /// 获取可变工作表
    pub fn get_worksheet_mut(&mut self, name: &str) -> Option<&mut Worksheet> {
        self.worksheets.get_mut(name)
    }

    /// 获取工作表（按索引）
    pub fn get_worksheet_by_index(&self, index: usize) -> Option<&Worksheet> {
        self.worksheet_order.get(index).and_then(|name| self.worksheets.get(name))
    }

    /// 获取可变工作表（按索引）
    pub fn get_worksheet_by_index_mut(&mut self, index: usize) -> Option<&mut Worksheet> {
        if let Some(name) = self.worksheet_order.get(index).cloned() {
            self.worksheets.get_mut(&name)
        } else {
            None
        }
    }

    /// 删除工作表
    pub fn remove_worksheet(&mut self, name: &str) -> Result<Worksheet> {
        if !self.worksheets.contains_key(name) {
            return Err(
                OfficeError::Xlsx(XlsxError::WorksheetNotFound {
                    name: name.to_string(),
                })
            );
        }

        // 不能删除最后一个工作表
        if self.worksheets.len() == 1 {
            return Err(OfficeError::Structure("不能删除最后一个工作表".to_string()));
        }

        // 从顺序列表中移除
        self.worksheet_order.retain(|n| n != name);

        // 如果删除的是活动工作表，设置新的活动工作表
        if self.active_worksheet.as_ref() == Some(&name.to_string()) {
            self.active_worksheet = self.worksheet_order.first().cloned();
        }

        // 移除工作表
        Ok(self.worksheets.remove(name).unwrap())
    }

    /// 重命名工作表
    pub fn rename_worksheet(&mut self, old_name: &str, new_name: String) -> Result<()> {
        if !self.worksheets.contains_key(old_name) {
            return Err(
                OfficeError::Xlsx(XlsxError::WorksheetNotFound {
                    name: old_name.to_string(),
                })
            );
        }

        if self.worksheets.contains_key(&new_name) {
            return Err(
                OfficeError::Xlsx(XlsxError::WorksheetNotFound {
                    name: format!("工作表 '{}' 已存在", new_name),
                })
            );
        }

        // 获取工作表并更新名称
        let mut worksheet = self.worksheets.remove(old_name).unwrap();
        worksheet.set_name(new_name.clone());

        // 更新映射
        self.worksheets.insert(new_name.clone(), worksheet);

        // 更新顺序列表
        if let Some(pos) = self.worksheet_order.iter().position(|n| n == old_name) {
            self.worksheet_order[pos] = new_name.clone();
        }

        // 更新活动工作表名称
        if self.active_worksheet.as_ref() == Some(&old_name.to_string()) {
            self.active_worksheet = Some(new_name);
        }

        Ok(())
    }

    /// 获取所有工作表名称
    pub fn worksheet_names(&self) -> &[String] {
        &self.worksheet_order
    }

    /// 获取工作表数量
    pub fn worksheet_count(&self) -> usize {
        self.worksheets.len()
    }

    /// 获取活动工作表
    pub fn active_worksheet(&self) -> Option<&Worksheet> {
        self.active_worksheet.as_ref().and_then(|name| self.worksheets.get(name))
    }

    /// 获取可变活动工作表
    pub fn active_worksheet_mut(&mut self) -> Option<&mut Worksheet> {
        if let Some(name) = self.active_worksheet.clone() {
            self.worksheets.get_mut(&name)
        } else {
            None
        }
    }

    /// 设置活动工作表
    pub fn set_active_worksheet(&mut self, name: &str) -> Result<()> {
        if !self.worksheets.contains_key(name) {
            return Err(
                OfficeError::Xlsx(XlsxError::WorksheetNotFound {
                    name: name.to_string(),
                })
            );
        }

        self.active_worksheet = Some(name.to_string());
        Ok(())
    }

    /// 获取活动工作表名称
    pub fn active_worksheet_name(&self) -> Option<&str> {
        self.active_worksheet.as_deref()
    }

    /// 移动工作表位置
    pub fn move_worksheet(&mut self, name: &str, new_index: usize) -> Result<()> {
        if !self.worksheets.contains_key(name) {
            return Err(
                OfficeError::Xlsx(XlsxError::WorksheetNotFound {
                    name: name.to_string(),
                })
            );
        }

        if new_index >= self.worksheet_order.len() {
            return Err(OfficeError::Structure("工作表索引超出范围".to_string()));
        }

        // 找到当前位置
        if let Some(current_index) = self.worksheet_order.iter().position(|n| n == name) {
            // 移除并插入到新位置
            let worksheet_name = self.worksheet_order.remove(current_index);
            self.worksheet_order.insert(new_index, worksheet_name);
        }

        Ok(())
    }

    /// 获取所有工作表的迭代器
    pub fn worksheets(&self) -> impl Iterator<Item = &Worksheet> {
        self.worksheet_order.iter().filter_map(|name| self.worksheets.get(name))
    }

    /// 添加共享字符串
    pub fn add_shared_string(&mut self, text: String) -> usize {
        // 检查是否已存在
        if let Some(index) = self.shared_strings.iter().position(|s| s == &text) {
            return index;
        }

        // 添加新的共享字符串
        self.shared_strings.push(text);
        self.shared_strings.len() - 1
    }

    /// 获取共享字符串
    pub fn get_shared_string(&self, index: usize) -> Result<&str> {
        self.shared_strings
            .get(index)
            .map(|s| s.as_str())
            .ok_or_else(|| OfficeError::Xlsx(XlsxError::SharedStringIndexOutOfRange { index }))
    }

    /// 获取所有共享字符串
    pub fn shared_strings(&self) -> &[String] {
        &self.shared_strings
    }

    /// 保存到文件
    pub fn save<P: AsRef<Path>>(&self, path: P) -> Result<()> {
        let mut writer = crate::xlsx::XlsxWriter::create(path)?;
        writer.write_workbook(self)
    }

    /// 另存为
    pub fn save_as<P: AsRef<Path>>(&self, path: P) -> Result<()> {
        self.save(path)
    }
}

impl Default for WorkbookProperties {
    fn default() -> Self {
        Self::new()
    }
}

impl Default for Workbook {
    fn default() -> Self {
        Self::new()
    }
}

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

    #[test]
    fn test_workbook_basic_operations() {
        let mut workbook = Workbook::new();

        // 测试默认工作表
        assert_eq!(workbook.worksheet_count(), 1);
        assert_eq!(workbook.worksheet_names()[0], "Sheet1");

        // 添加新工作表
        workbook.add_worksheet("Sheet2".to_string()).unwrap();
        assert_eq!(workbook.worksheet_count(), 2);

        // 测试获取工作表
        let sheet1 = workbook.get_worksheet("Sheet1").unwrap();
        assert_eq!(sheet1.name(), "Sheet1");
    }

    #[test]
    fn test_worksheet_operations() {
        let mut workbook = Workbook::new();

        // 在工作表中设置值
        {
            let sheet = workbook.get_worksheet_mut("Sheet1").unwrap();
            sheet.set_cell_value_by_reference("A1", CellValue::Text("Hello".to_string())).unwrap();
            sheet.set_cell_value_by_reference("B1", CellValue::Number(42.0)).unwrap();
        }

        // 验证值
        let sheet = workbook.get_worksheet("Sheet1").unwrap();
        let cell_a1 = sheet.get_cell(0, 0).unwrap();
        assert_eq!(cell_a1.value, CellValue::Text("Hello".to_string()));

        let cell_b1 = sheet.get_cell(0, 1).unwrap();
        assert_eq!(cell_b1.value, CellValue::Number(42.0));
    }

    #[test]
    fn test_worksheet_management() {
        let mut workbook = Workbook::new();

        // 添加工作表
        workbook.add_worksheet("Test Sheet".to_string()).unwrap();
        assert_eq!(workbook.worksheet_count(), 2);

        // 重命名工作表
        workbook.rename_worksheet("Test Sheet", "Renamed Sheet".to_string()).unwrap();
        assert!(workbook.get_worksheet("Renamed Sheet").is_some());
        assert!(workbook.get_worksheet("Test Sheet").is_none());

        // 设置活动工作表
        workbook.set_active_worksheet("Renamed Sheet").unwrap();
        assert_eq!(workbook.active_worksheet_name(), Some("Renamed Sheet"));
    }

    #[test]
    fn test_shared_strings() {
        let mut workbook = Workbook::new();

        // 添加共享字符串
        let index1 = workbook.add_shared_string("Hello".to_string());
        let index2 = workbook.add_shared_string("World".to_string());
        let index3 = workbook.add_shared_string("Hello".to_string()); // 重复

        assert_eq!(index1, 0);
        assert_eq!(index2, 1);
        assert_eq!(index3, 0); // 应该返回已存在的索引

        // 获取共享字符串
        assert_eq!(workbook.get_shared_string(0).unwrap(), "Hello");
        assert_eq!(workbook.get_shared_string(1).unwrap(), "World");
    }

    #[test]
    fn test_worksheet_api() {
        let mut workbook = Workbook::new();
        workbook.add_worksheet("Data".to_string()).unwrap();

        // 测试工作表访问
        assert!(workbook.get_worksheet_mut("Sheet1").is_some());
        assert!(workbook.get_worksheet_mut("Data").is_some());
        assert!(workbook.get_worksheet_mut("NonExistent").is_none());

        // 测试工作表名称列表
        let names = workbook.worksheet_names();
        assert_eq!(names.len(), 2);
        assert!(names.contains(&"Sheet1".to_string()));
        assert!(names.contains(&"Data".to_string()));
    }
}