#include "pch.h"
#include "CreoManager.h"
#include <wfcAssembly.h>
#include <pfcBase.h>
#include <pfcGlobal.h>
#include <pfcExport.h>
#include <pfcModel.h>
#include <pfcFeature.h>
#include <pfcSolid.h>
#include <wfcSolid.h>
#include <wfcFeatureInstructions.h>
#include <stdcols.h>
#include <ctime>
#include <sstream>

#include <iomanip>
#include <fstream>
#include <windows.h>
#include <vector>
#include <map>
#include <string>
#include <set>
#include <cstdlib>
#include <algorithm>
#include <functional>
#include <cmath>

// 防止Windows宏冲突
#ifdef max
#undef max
#endif
#ifdef min  
#undef min
#endif


// 构造函数：简化实现
CreoManager::CreoManager() {
    // 配置设置可能需要通过config.pro文件或其他方式
    // 暂时移除代码中的配置设置
}

CreoManager& CreoManager::Instance() {
    static CreoManager instance;
    return instance;
}

CreoStatus CreoManager::GetCreoStatus() {
    CreoStatus status;
    SessionInfo sessionInfo = GetSessionInfo();
    
    status.is_connected = sessionInfo.is_valid;
    status.version = sessionInfo.version;
    status.build = sessionInfo.build;
    
    if (sessionInfo.is_valid) {
        // 获取工作目录
        try {
            xstring workdir = sessionInfo.session->GetCurrentDirectory();
            status.working_directory = XStringToString(workdir);
        }
        catch (...) {
            status.working_directory = "Failed to get working directory";
        }
        status.session_id = 1;
    } else {
        status.working_directory = "Failed to connect to Creo";
        status.session_id = 0;
    }
    
    return status;
}

ModelStatus CreoManager::GetModelStatus() {
    ModelStatus status;
    SessionInfo sessionInfo = GetSessionInfo();
    
    if (!sessionInfo.is_valid) {
        return status;
    }
    
    try {
        pfcModel_ptr current_model = sessionInfo.session->GetCurrentModel();
        if (current_model) {
            status.has_model = true;
            
            // 获取模型名称和文件名
            try {
                xstring name_xstr = current_model->GetFileName();
                status.name = XStringToString(name_xstr);
                status.filename = status.name;
            }
            catch (...) {
                status.name = "Failed to get model name";
                status.filename = "Failed to get filename";
            }
            
            // 获取模型类型
            try {
                pfcModelType model_type = current_model->GetType();
                switch (model_type) {
                    case pfcMDL_PART:
                        status.type = "Part";
                        status.is_assembly = false;
                        break;
                    case pfcMDL_ASSEMBLY:
                        status.type = "Assembly";
                        status.is_assembly = true;
                        break;
                    case pfcMDL_DRAWING:
                        status.type = "Drawing";
                        status.is_assembly = false;
                        break;
                    default:
                        status.type = "";
                        status.is_assembly = false;
                        break;
                }
            }
            catch (...) {
                status.type = "Failed to get model type";
                status.is_assembly = false;
            }
            
            // 获取模型文件大小（装配体统计所有零件和子装配体的总大小）
            try {
                if (status.is_assembly) {
                    // 装配体：统计所有组件的文件大小
                    status.file_size = CalculateAssemblyTotalSize(current_model);
                } else {
                    // 单个零件：直接获取文件大小
                    status.file_size = GetModelFileSize(current_model);
                }
            }
            catch (...) {
                status.file_size = "Exception getting file size";
            }
            
            // 检查模型是否已修改
            try {
                status.is_modified = current_model->GetIsModified();
            }
            catch (...) {
                status.is_modified = false; // 默认值：未修改
            }
            
            // 获取真实的零件数量和装配体层级
            if (status.is_assembly) {
                try {
                    wfcWAssembly_ptr wAssembly = wfcWAssembly::cast(current_model);
                    if (wAssembly) {
                        // 获取所有显示的组件
                        wfcWComponentPaths_ptr components = wAssembly->ListDisplayedComponents();
                        if (components) {
                            status.total_parts = components->getarraysize();
                        } else {
                            status.total_parts = 0;
                        }
                        status.assembly_levels = SafeCalculateAssemblyLevels(wAssembly);
                    } else {
                        status.total_parts = 0;
                        status.assembly_levels = 0;
                    }
                }
                catch (...) {
                    status.total_parts = 0;
                    status.assembly_levels = 0;
                }
            } else {
                // 非装配体（零件）的真实数据
                status.total_parts = 1;
                status.assembly_levels = 1;
            }
            
            // 解析软件信息
            std::string full_version = sessionInfo.version;
            size_t space_pos = full_version.find(" ");
            if (space_pos != std::string::npos) {
                status.software = full_version.substr(0, space_pos);
                status.version = full_version.substr(space_pos + 1);
            } else {
                status.software = "Failed to parse software name";
                status.version = "Failed to parse version";
            }
            
            // 设置其他信息
            status.connection_time = GetCurrentTimeString();
            status.open_time = status.connection_time;
            status.connection_status = "Connected";
        }
    }
    catch (...) {
        status.has_model = false;
        status.name = "Failed to access model";
        status.filename = "Failed to access model";
        status.type = "Failed to access model";
        status.is_assembly = false;
        status.total_parts = 0;
        status.assembly_levels = 0;
        status.software = "Failed to access model";
        status.version = "Failed to access model";
        status.connection_time = "Failed to get time";
        status.open_time = "Failed to get time";
        status.connection_status = "Failed to get status";
        status.file_size = "Failed to access model";
    }
    
    return status;
}

bool CreoManager::ShowMessage(const std::string& message) {
    SessionInfo sessionInfo = GetSessionInfo();
    
    if (!sessionInfo.is_valid) {
        return false;
    }
    
    try {
        xstring msg_xstr = StringToXString(message);
        sessionInfo.wSession->UIShowMessageDialog(msg_xstr, NULL);
        return true;
    }
    catch (...) {
        return false;
    }
}

std::string CreoManager::XStringToString(const xstring& xstr) {
    try {
        // 安全检查：空xstring处理
        if (xstr.IsNull()) {
            return "";
        }
        
        std::wstring wstr(xstr);
        if (wstr.empty()) {
            return "";
        }
        
        // 长度限制检查，防止过长字符串导致内存问题
        if (wstr.length() > 32767) {  // Windows API限制
            return "";
        }
        
        // 使用WideCharToMultiByte进行正确的UTF-8编码转换
        int wstr_len = static_cast<int>(wstr.length());
        int size_needed = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), wstr_len, NULL, 0, NULL, NULL);
        if (size_needed <= 0 || size_needed > 65535) {  // 安全边界检查
            return "";
        }
        
        std::string result(size_needed, 0);
        int convert_result = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), wstr_len, &result[0], size_needed, NULL, NULL);
        if (convert_result != size_needed) {
            return "";  // 转换失败
        }
        
        return result;
    }
    catch (const std::bad_alloc&) {
        return "";  // 内存分配失败
    }
    catch (const std::length_error&) {
        return "";  // 字符串长度错误
    }
    catch (...) {
        return "";
    }
}

xstring CreoManager::StringToXString(const std::string& str) {
    try {
        if (str.empty()) {
            return xstring();
        }
        
        // 长度限制检查，防止过长字符串导致内存问题
        if (str.length() > 65535) {  // 合理的长度限制
            return xstring();
        }
        
        // 验证输入字符串是否包含无效字符
        for (char c : str) {
            if (c == '\0' && &c != &str.back()) {  // 中间包含null字符
                return xstring();
            }
        }
        
        // 使用MultiByteToWideChar进行正确的UTF-8解码转换
        int str_len = static_cast<int>(str.length());
        int size_needed = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.c_str(), str_len, NULL, 0);
        if (size_needed <= 0 || size_needed > 32767) {  // 安全边界检查
            return xstring();
        }
        
        std::wstring wstr(size_needed, 0);
        int convert_result = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, str.c_str(), str_len, &wstr[0], size_needed);
        if (convert_result != size_needed) {
            return xstring();  // 转换失败
        }
        
        return xstring(wstr.c_str());
    }
    catch (const std::bad_alloc&) {
        return xstring();  // 内存分配失败
    }
    catch (const std::length_error&) {
        return xstring();  // 字符串长度错误
    }
    catch (...) {
        return xstring();
    }
}

// 路径分离和验证函数
std::pair<std::string, std::string> CreoManager::ParseFilePath(const std::string& file_path) {
    std::string dirname, filename;
    
    if (file_path.empty()) {
        return std::make_pair("", "");
    }
    
    // 支持Windows和Unix路径分隔符
    size_t pos = file_path.find_last_of("/\\");
    if (pos != std::string::npos) {
        dirname = file_path.substr(0, pos);
        filename = file_path.substr(pos + 1);
    } else {
        dirname = "";
        filename = file_path;
    }
    
    // 基本验证：文件名不能为空
    if (filename.empty()) {
        return std::make_pair("", "");
    }
    
    // 验证文件名不包含非法字符
    const std::string invalid_chars = "<>:\"|?*";
    if (filename.find_first_of(invalid_chars) != std::string::npos) {
        return std::make_pair("", "");
    }
    
    return std::make_pair(dirname, filename);
}

std::string CreoManager::GetCurrentTimeString() {
    std::time_t now = std::time(nullptr);
    std::tm* local_tm = std::localtime(&now);
    
    std::ostringstream oss;
    oss << std::put_time(local_tm, "%Y-%m-%d %H:%M:%S");
    return oss.str();
}

std::string CreoManager::GetCurrentTimeStringISO() {
    std::time_t now = std::time(nullptr);
    std::tm* utc_tm = std::gmtime(&now);
    
    std::ostringstream oss;
    oss << std::put_time(utc_tm, "%Y-%m-%dT%H:%M:%S");
    oss << ".000000Z"; // 添加微秒和UTC标识
    return oss.str();
}

CreoManager::SessionInfo CreoManager::GetSessionInfo() {
    SessionInfo info;
    info.is_valid = false;
    
    try {
        info.session = pfcGetCurrentSessionWithCompatibility(pfcC4Compatible);
        if (info.session) {
            info.wSession = wfcWSession::cast(info.session);
            if (info.wSession) {
                // 获取版本信息
                int version_num = info.wSession->GetReleaseNumericVersion();
                xstring date_code = info.wSession->GetDisplayDateCode();
                
                // 尝试获取真实的软件名称
                std::string software_name = "Creo";  // 基础名称，如果无法获取更详细的名称
                
                std::ostringstream version_str;
                version_str << software_name << " " << version_num << ".0";
                info.version = version_str.str();
                info.build = XStringToString(date_code);
                info.is_valid = true;
            } else {
                info.version = "Failed to get version";
                info.build = "Failed to get build";
            }
        } else {
            info.version = "Failed to connect to Creo";
            info.build = "Failed to connect to Creo";
        }
    }
    catch (...) {
        info.version = "Failed to get version";
        info.build = "Failed to get build";
    }
    
    return info;
}

std::string CreoManager::GetFileSize(const std::string& filepath) {
    try {
        if (filepath.empty()) {
            return "Empty filepath";
        }
        
        // 复用现有的字符串转换逻辑
        xstring xpath = StringToXString(filepath);
        std::wstring wpath(xpath);
        
        WIN32_FILE_ATTRIBUTE_DATA fileInfo;
        if (GetFileAttributesExW(wpath.c_str(), GetFileExInfoStandard, &fileInfo)) {
            LARGE_INTEGER size;
            size.HighPart = fileInfo.nFileSizeHigh;
            size.LowPart = fileInfo.nFileSizeLow;
            
            double file_size_mb = static_cast<double>(size.QuadPart) / (1024.0 * 1024.0);
            
            std::ostringstream oss;
            oss << std::fixed << std::setprecision(1) << file_size_mb << "MB";
            return oss.str();
        } else {
            DWORD error = GetLastError();
            std::ostringstream oss;
            oss << "File access failed (Error: " << error << ") Path: " << filepath;
            return oss.str();
        }
    }
    catch (...) {
        return "Exception in GetFileSize";
    }
}

int CreoManager::SafeCalculateAssemblyLevels(wfcWAssembly_ptr assembly) {
    try {
        if (!assembly) {
            return 1;
        }
        
        // 使用ComponentPath分析装配体层级深度
        wfcWComponentPaths_ptr components = assembly->ListDisplayedComponents();
        if (!components) {
            return 1;
        }
        
        int component_count = components->getarraysize();
        if (component_count == 0) {
            return 1;
        }
        
        int max_level = 1;
        // 移除组件数量限制，检查所有组件
        
        for (int i = 0; i < component_count; i++) {
            try {
                wfcWComponentPath_ptr comp_path = components->get(i);
                if (comp_path) {
                    // 使用GetComponentIds获取组件路径
                    xintsequence_ptr ids = comp_path->GetComponentIds();
                    if (ids) {
                        // 路径深度就是装配体层级
                        int path_depth = ids->getarraysize();
                        if (path_depth > max_level) {
                            max_level = path_depth;
                        }
                    }
                }
            }
            catch (...) {
                // 跳过有问题的组件
                continue;
            }
        }
        
        return max_level;
        
    }
    catch (...) {
        return 1;
    }
}

std::string CreoManager::GetModelFileSize(pfcModel_ptr model) {
    try {
        if (!model) {
            return "0.0MB";
        }
        
        // 先检查模型是否可以安全调用GetDescr
        try {
            pfcModelDescriptor_ptr descr = model->GetDescr();
            if (!descr) {
                return "0.0MB";
            }
        } catch (...) {
            // 如果GetDescr失败，可能是轻量级模型，尝试其他方法
            try {
                xstring origin = model->GetOrigin();
                std::string origin_str = XStringToString(origin);
                if (!origin_str.empty()) {
                    return GetFileSize(origin_str);
                }
            } catch (...) {
                // 所有方法都失败，返回默认值
                return "0.0MB";
            }
            return "0.0MB";
        }
        
        // 使用origin路径获取文件大小
        try {
            xstring origin = model->GetOrigin();
            std::string origin_str = XStringToString(origin);
            if (!origin_str.empty()) {
                return GetFileSize(origin_str);
            }
        } catch (...) {
            return "0.0MB";
        }
        
        return "0.0MB";
    }
    catch (...) {
        return "0.0MB";
    }
}

double CreoManager::ParseMBFromSizeString(const std::string& size_str) {
    try {
        if (size_str.find("MB") != std::string::npos) {
            size_t mb_pos = size_str.find("MB");
            std::string size_num = size_str.substr(0, mb_pos);
            return std::stod(size_num);
        }
        return 0.0;
    }
    catch (...) {
        return 0.0;
    }
}

std::string CreoManager::CalculateAssemblyTotalSize(pfcModel_ptr model) {
    try {
        wfcWAssembly_ptr assembly = wfcWAssembly::cast(model);
        if (!assembly) {
            return "Not an assembly";
        }
        
        double total_size_bytes = 0;
        int processed_count = 0;
        
        // 首先添加主装配体文件大小
        std::string main_size = GetModelFileSize(model);
        double main_mb = ParseMBFromSizeString(main_size);
        if (main_mb > 0) {
            total_size_bytes += main_mb * 1024 * 1024;
            processed_count++;
        }
        
        // 使用ListDisplayedComponents获取组件（保持原有逻辑）
        wfcWComponentPaths_ptr components = assembly->ListDisplayedComponents();
        if (components) {
            int component_count = components->getarraysize();
            
            for (int i = 0; i < component_count; i++) {
                try {
                    wfcWComponentPath_ptr comp_path = components->get(i);
                    if (comp_path) {
                        pfcSolid_ptr leaf_solid = comp_path->GetLeaf();
                        if (leaf_solid) {
                            pfcModel_ptr comp_model = pfcModel::cast(leaf_solid);
                            if (comp_model) {
                                std::string comp_size = GetModelFileSize(comp_model);
                                double comp_mb = ParseMBFromSizeString(comp_size);
                                if (comp_mb > 0) {
                                    total_size_bytes += comp_mb * 1024 * 1024;
                                    processed_count++;
                                }
                            }
                        }
                    }
                }
                catch (...) {
                    continue;
                }
            }
        }
        
        // 转换为MB并返回
        double total_mb = total_size_bytes / (1024.0 * 1024.0);
        std::ostringstream oss;
        oss << std::fixed << std::setprecision(1) << total_mb << "MB (from " << processed_count << " files)";
        return oss.str();
        
    }
    catch (...) {
        return "Exception in CalculateAssemblyTotalSize";
    }
}

ExportResult CreoManager::ExportModelToSTEP(const std::string& export_path, const std::string& geom_flags) {
    ExportResult result;
    
    SessionInfo sessionInfo = GetSessionInfo();
    
    if (!sessionInfo.is_valid) {
        result.error_message = "Creo session not available";
        return result;
    }
    
    try {
        pfcModel_ptr current_model = sessionInfo.session->GetCurrentModel();
        if (!current_model) {
            result.error_message = "No current model loaded";
            return result;
        }
        
        // 检查导出路径是否有效
        if (export_path.empty()) {
            result.error_message = "Invalid export path";
            return result;
        }
        
        // 检查模型类型是否支持导出
        pfcModelType model_type = current_model->GetType();
        if (model_type != pfcMDL_PART && model_type != pfcMDL_ASSEMBLY) {
            result.error_message = "Model type not supported for export";
            return result;
        }
        
        // 创建几何导出标志
        pfcGeomExportFlags_ptr geometryFlags = pfcGeomExportFlags::Create();
        
        // 创建STEP导出指令
        pfcSTEPExportInstructions_ptr exportInstructions = 
            pfcSTEPExportInstructions::Create(geometryFlags);
        
        // 执行导出 - 使用xrstring类型
        xrstring export_path_xrstr = export_path.c_str();
        current_model->Export(export_path_xrstr, pfcExportInstructions::cast(exportInstructions));
        
        // 检查导出文件是否存在（使用Windows API）
        WIN32_FILE_ATTRIBUTE_DATA fileInfo;
        if (GetFileAttributesExA(export_path.c_str(), GetFileExInfoStandard, &fileInfo)) {
            result.success = true;
            result.export_path = export_path;
            result.file_size = GetFileSize(export_path);
            result.format = "step";
            result.export_time = GetCurrentTimeStringISO();
            result.software = "Creo Parametric";
            
            // 获取原始文件信息
            try {
                xstring name_xstr = current_model->GetFileName();
                result.original_file = XStringToString(name_xstr);
            } catch (...) {
                result.original_file = "Unknown";
            }
            
            // 解析目录和文件名
            size_t last_slash = export_path.find_last_of("\\/");
            if (last_slash != std::string::npos) {
                result.dirname = export_path.substr(0, last_slash);
                result.filename = export_path.substr(last_slash + 1);
            } else {
                result.dirname = "";
                result.filename = export_path;
            }
            
        } else {
            result.error_message = "Export file not created";
        }
        
    }
    catch (...) {
        result.error_message = "Export operation failed";
    }
    
    return result;
}

// 保存模型功能实现
SaveResult CreoManager::SaveModel() {
    SaveResult result;
    
    SessionInfo sessionInfo = GetSessionInfo();
    
    if (!sessionInfo.is_valid) {
        result.error_message = "Creo session not available";
        return result;
    }
    
    try {
        pfcModel_ptr current_model = sessionInfo.session->GetCurrentModel();
        if (!current_model) {
            result.error_message = "No current model loaded";
            return result;
        }
        
        // 获取文件信息
        xstring original_name = current_model->GetFileName();
        result.original_file = XStringToString(original_name);
        result.software = "Creo Parametric";
        
        // 执行保存操作
        current_model->Save();
        
        // 设置成功结果
        result.save_time = GetCurrentTimeStringISO();
        result.file_size = GetModelFileSize(current_model);
        result.success = true;
        
    }
    catch (const pfcXToolkitBadInputs&) {
        result.error_message = "Bad input parameters";
    }
    catch (const pfcXToolkitGeneralError&) {
        result.error_message = "Creo toolkit error";
    }
    catch (const pfcXToolkitInvalidName&) {
        result.error_message = "Invalid file name";
    }
    catch (const pfcXToolkitCantWrite&) {
        result.error_message = "Cannot write to file";
    }
    catch (const pfcXToolkitCantOpen&) {
        result.error_message = "Cannot open file";
    }
    catch (const std::exception& e) {
        result.error_message = "Standard error: " + std::string(e.what());
    }
    catch (...) {
        result.error_message = "Unknown error during save operation";
    }
    
    return result;
}

// 关闭模型功能实现
CloseResult CreoManager::CloseModel(bool force_close) {
    CloseResult result;
    
    SessionInfo sessionInfo = GetSessionInfo();
    
    if (!sessionInfo.is_valid) {
        result.error_message = "Creo session not available";
        return result;
    }
    
    try {
        pfcModel_ptr current_model = sessionInfo.session->GetCurrentModel();
        if (!current_model) {
            result.error_message = "No current model loaded";
            return result;
        }
        
        // 获取模型信息
        xstring model_name_xstr = current_model->GetFileName();
        result.model_name = XStringToString(model_name_xstr);
        
        // 检查模型是否已修改
        result.was_modified = current_model->GetIsModified();
        
        // 如果模型已修改且不是强制关闭，则需要处理
        if (result.was_modified && !force_close) {
            result.error_message = "Model has unsaved changes. Use force_close=true to close without saving.";
            return result;
        }
        
        // 执行关闭操作
        current_model->Erase();
        
        // 设置成功结果
        result.close_time = GetCurrentTimeStringISO();
        result.success = true;
        
    }
    catch (const pfcXToolkitBadInputs&) {
        result.error_message = "Bad input parameters";
    }
    catch (const pfcXToolkitGeneralError&) {
        result.error_message = "Creo toolkit error";
    }
    catch (const pfcXToolkitInvalidName&) {
        result.error_message = "Invalid model name";
    }
    catch (const std::exception& e) {
        result.error_message = "Standard error: " + std::string(e.what());
    }
    catch (...) {
        result.error_message = "Unknown error during close operation";
    }
    
    return result;
}

// 打开模型功能
OpenResult CreoManager::OpenModel(const std::string& file_path, const std::string& open_mode) {
    OpenResult result;
    
    // 分离目录和文件名（内联实现，避免成员函数调用问题）
    std::string dirname, filename;
    size_t pos = file_path.find_last_of("/\\");
    if (pos != std::string::npos) {
        dirname = file_path.substr(0, pos);
        filename = file_path.substr(pos + 1);
    } else {
        dirname = "";
        filename = file_path;
    }
    
    SessionInfo sessionInfo = GetSessionInfo();
    
    if (!sessionInfo.is_valid) {
        result.error_message = "Creo session not available";
        return result;
    }
    
    try {
        // 验证路径解析结果
        if (filename.empty()) {
            result.error_message = "Invalid file path: " + file_path;
            return result;
        }
        
        // 创建模型描述符用于检查（符合CREOSON标准）
        xstring filename_xstr = StringToXString(filename);
        pfcModelDescriptor_ptr checkDesc = pfcModelDescriptor::CreateFromFileName(filename_xstr);
        
        // 检查模型是否已在会话中打开（使用描述符，符合CREOSON标准模式）
        // 对应CREOSON中的: session.getModelFromDescr(descr)
        pfcModel_ptr opened_model = nullptr;
        try {
            opened_model = sessionInfo.session->GetModelFromDescr(checkDesc);
        } catch (...) {
            // 模型未在内存中，稍后需要从磁盘加载
            opened_model = nullptr;
        }
        
        if (!dirname.empty()) {
            xstring workdir = StringToXString(dirname);
            sessionInfo.session->ChangeDirectory(workdir);
        }

        // 重用已创建的模型描述符（避免重复创建）
        // 使用RetrieveModel打开模型（对应CREOSON的session.retrieveModel(descr)）

        opened_model = sessionInfo.session->RetrieveModel(checkDesc);

        
        // 检查模型是否成功打开
        if (!opened_model) {
            result.error_message = "Failed to open model '" + filename + "' from directory '" + dirname + "'";
            return result;
        }
        
        // 设置返回结果
        result.success = true;
        result.model_name = XStringToString(opened_model->GetFileName());
        result.file_path = file_path;
        result.open_time = GetCurrentTimeStringISO();
        
        // 确定模型类型
        try {
            pfcModelType model_type = opened_model->GetType();
            switch (model_type) {
                case pfcMDL_ASSEMBLY:
                    result.model_type = "assembly";
                    result.is_assembly = true;
                    try {
                        pfcSolid_ptr solid = pfcSolid::cast(opened_model);
                        if (solid) {
                            pfcFeatures_ptr features = solid->ListFeaturesByType(false, pfcFEATTYPE_COMPONENT);
                            result.total_parts = features ? features->getarraysize() : 0;
                        }
                    } catch (...) {
                        result.total_parts = 0;
                    }
                    break;
                case pfcMDL_PART:
                    result.model_type = "part";
                    result.is_assembly = false;
                    result.total_parts = 0;
                    break;
                case pfcMDL_DRAWING:
                    result.model_type = "drawing";
                    result.is_assembly = false;
                    result.total_parts = 0;
                    break;
                default:
                    result.model_type = "unknown";
                    result.is_assembly = false;
                    result.total_parts = 0;
                    break;
            }
        } catch (...) {
            result.model_type = "unknown";
            result.is_assembly = false;
            result.total_parts = 0;
        }
        
        result.file_size = GetModelFileSize(opened_model);
        result.model_in_session = true;
        result.window_model_match = true;
        
    }
    catch (const xthrowable& e) {
        result.error_message = "OTK error opening model '" + filename + "': Creo API exception occurred";
    }
    catch (const std::exception& e) {
        result.error_message = "Standard exception opening model '" + filename + "': " + std::string(e.what());
    }
    catch (...) {
        result.error_message = "Unknown error opening model '" + filename + "' from directory '" + dirname + "'";
    }
    
    return result;
}

// 层级分析主方法
HierarchyAnalysisResult CreoManager::AnalyzeModelHierarchy(const HierarchyAnalysisRequest& request) {
    HierarchyAnalysisResult result;
    SessionInfo sessionInfo = GetSessionInfo();
    
    if (!sessionInfo.is_valid) {
        result.error_message = "Creo session not available";
        return result;
    }
    
    try {
        pfcModel_ptr current_model = sessionInfo.session->GetCurrentModel();
        if (!current_model) {
            result.error_message = "No current model loaded";
            return result;
        }
        
        // 检查是否为装配体
        if (current_model->GetType() != pfcMDL_ASSEMBLY) {
            result.error_message = "Current model is not an assembly";
            return result;
        }
        
        // 转换为装配体
        wfcWAssembly_ptr assembly = wfcWAssembly::cast(current_model);
        if (!assembly) {
            result.error_message = "Failed to cast model to assembly";
            return result;
        }
        
        // 初始化结果（SOTA算法）
        result.project_name = request.project_name.empty() ? 
            XStringToString(current_model->GetFileName()) : request.project_name;
        result.total_levels = 0;
        result.total_components = 0;
        result.hierarchy.clear();
        
        // 创建根装配体组件信息
        ComponentInfo root_component;
        
        // 获取根装配体文件名
        try {
            xstring filename_xstr = current_model->GetFileName();
            root_component.id = XStringToString(filename_xstr);
        } catch (...) {
            try {
                xstring origin = current_model->GetOrigin();
                std::string origin_str = XStringToString(origin);
                size_t pos = origin_str.find_last_of("/\\");
                if (pos != std::string::npos) {
                    root_component.id = origin_str.substr(pos + 1);
                } else {
                    root_component.id = origin_str;
                }
            } catch (...) {
                root_component.id = "root_assembly.asm";
            }
        }
        
        // 设置根装配体属性
        root_component.name = root_component.id;
        root_component.type = "assembly";
        root_component.level = 0;
        root_component.path = root_component.id;
        root_component.full_path = root_component.id;
        root_component.file_size = GetModelFileSize(current_model);
        root_component.deletion_safety = "forbidden";
        root_component.is_visible = true;
        root_component.model_type = "MDL_ASSEMBLY";
        root_component.children_count = 0; // 将在递归后计算
        
        // 初始化层级0并添加根装配体
        result.hierarchy.push_back(std::vector<ComponentInfo>());
        result.hierarchy[0].push_back(root_component);
        
        // 使用新的SOTA递归算法分析子组件（从层级1开始）
        AnalyzeAssemblyNode(assembly, 1, root_component.name, root_component.path, result);
        
        // 计算根装配体的children_count
        if (result.hierarchy.size() > 1) {
            result.hierarchy[0][0].children_count = result.hierarchy[1].size();
        }
        
        // 计算最终统计
        result.total_levels = result.hierarchy.size();
        
        // 计算总组件数（从所有层级统计）
        result.total_components = 0;
        for (const auto& level : result.hierarchy) {
            result.total_components += level.size();
        }
        
        // 设置成功状态
        result.success = true;
        result.message = "Hierarchy analysis completed";
        
        return result;
        
    } catch (const std::exception& e) {
        result.error_message = "Exception during hierarchy analysis: " + std::string(e.what());
    } catch (...) {
        result.error_message = "Unknown exception during hierarchy analysis";
    }
    
    return result;
}
// 评估删除安全性
std::string CreoManager::EvaluateDeletionSafety(const ComponentInfo& component) {
    if (component.level == 0) {
        return "forbidden";  // 主装配体不能删除
    }
    
    if (component.type == "assembly") {
        return "risky";  // 子装配体删除有风险
    }
    
    return "moderate";  // 零件删除相对安全
}

// 获取组件文件大小 (使用更安全的方法)
std::string CreoManager::GetComponentFileSize(wfcWComponentPath_ptr component_path) {
    try {
        pfcSolid_ptr leaf_model = component_path->GetLeaf();
        if (leaf_model) {
            // 使用更安全的转换方法
            pfcModel_ptr model = pfcModel::cast(leaf_model);
            if (model) {
                return GetModelFileSize(model);
            }
        }
    } catch (...) {
        // 捕获所有异常，返回默认值
    }
    
    return "0.0MB";
}

// 获取模型类型字符串
std::string CreoManager::GetModelTypeString(pfcModelType model_type) {
    switch (model_type) {
        case pfcMDL_ASSEMBLY:
            return "MDL_ASSEMBLY";
        case pfcMDL_PART:
            return "MDL_PART";
        case pfcMDL_DRAWING:
            return "MDL_DRAWING";
        default:
            return "MDL_UNKNOWN";
    }
}

// 计算子组件数量
int CreoManager::CountChildComponents(wfcWComponentPath_ptr component_path) {
    try {
        pfcSolid_ptr leaf_model = component_path->GetLeaf();
        if (leaf_model && leaf_model->GetType() == pfcMDL_ASSEMBLY) {
            wfcWAssembly_ptr sub_assembly = wfcWAssembly::cast(leaf_model);
            if (sub_assembly) {
                wfcWComponentPaths_ptr sub_components = sub_assembly->ListDisplayedComponents();
                if (sub_components) {
                    return sub_components->getarraysize();
                }
            }
        }
    } catch (...) {
        // 忽略错误
    }
    
    return 0;
}

// =============== SOTA层级分析算法 ===============

void CreoManager::AnalyzeAssemblyNode(wfcWAssembly_ptr assembly, 
                                     int level, 
                                     const std::string& parentName, 
                                     const std::string& currentPath,
                                     HierarchyAnalysisResult& result) {
    if (!assembly) return;
    
    try {
        // 更新最大层级深度  
        if (level + 1 > result.total_levels) {
            result.total_levels = level + 1;
        }
        
        // 确保层级容器足够大
        while (result.hierarchy.size() <= level) {
            result.hierarchy.push_back(std::vector<ComponentInfo>());
        }
        
        // 使用ListFeaturesByType获取所有组件特征（包括隐藏的）
        pfcFeatures_ptr features = assembly->ListFeaturesByType(xfalse, pfcFEATTYPE_COMPONENT);
        if (!features) return;
        
        int features_count = features->getarraysize();
        if (features_count <= 0) return;
        
        // 遍历所有组件特征
        for (int i = 0; i < features_count; i++) {
            try {
                pfcFeature_ptr feature = features->get(i);
                if (!feature) continue;
                
                // 转换为组件特征
                pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
                if (!compFeat) continue;
                
                // 加载模型一次（避免重复调用）
                pfcModel_ptr childModel = LoadComponentModel(compFeat);
                
                // 创建组件信息，传递已加载的模型
                ComponentInfo component = CreateComponentFromFeature(compFeat, level, parentName, currentPath, childModel);
                
                // 添加到当前层级
                result.hierarchy[level].push_back(component);
                
                // 递归处理子装配体
                if (component.type == "assembly" && childModel) {
                    try {
                        if (childModel->GetType() == pfcMDL_ASSEMBLY) {
                            wfcWAssembly_ptr childAssembly = wfcWAssembly::cast(childModel);
                            if (childAssembly) {
                                // 递归分析子装配体
                                AnalyzeAssemblyNode(childAssembly, level + 1, 
                                                  component.name, component.path, result);
                            }
                        }
                    } catch (...) {
                        // 处理无法加载的子装配体
                    }
                }
                
            } catch (...) {
                continue; // 忽略单个组件错误
            }
        }
        
        // children_count在CreateComponentFromFeature中已经设置
        
    } catch (...) {
        // 处理整体错误
    }
}

ComponentInfo CreoManager::CreateComponentFromFeature(pfcComponentFeat_ptr compFeat, 
                                                    int level, 
                                                    const std::string& parentName, 
                                                    const std::string& currentPath,
                                                    pfcModel_ptr preloadedModel) {
    ComponentInfo component;
    component.level = level;
    component.children_count = 0;
    component.is_visible = true;
    component.file_size = "0.0MB";
    component.deletion_safety = "moderate";
    
    try {
        // 获取组件模型描述符
        auto modelDescr = compFeat->GetModelDescr();
        if (modelDescr) {
            // 获取文件名作为ID
            xstring filename_xstr = modelDescr->GetFileName();
            component.id = XStringToString(filename_xstr);
            
            // 生成显示名称（去掉扩展名并格式化）
            component.name = component.id;
            size_t ext_pos = component.name.find_last_of(".");
            if (ext_pos != std::string::npos) {
                component.name = component.name.substr(0, ext_pos);
            }
            
            // 格式化显示名称
            if (!component.name.empty()) {
                component.name[0] = std::toupper(component.name[0]);
                for (size_t i = 1; i < component.name.size(); i++) {
                    if (component.name[i-1] == '_' || component.name[i-1] == ' ') {
                        component.name[i] = std::toupper(component.name[i]);
                    } else {
                        component.name[i] = std::tolower(component.name[i]);
                    }
                }
                std::replace(component.name.begin(), component.name.end(), '_', ' ');
            }
            
            // 设置组件类型
            if (modelDescr->GetType() == pfcMDL_ASSEMBLY) {
                component.type = "assembly";
                component.model_type = "MDL_ASSEMBLY";
            } else {
                component.type = "part";
                component.model_type = "MDL_PART";
            }
            
            // 构建完整路径
            if (currentPath.empty()) {
                component.path = component.id;
            } else {
                component.path = currentPath + "/" + component.id;
            }
            component.full_path = component.path;
            
            // 使用预加载的模型获取文件大小
            try {
                if (preloadedModel) {
                    component.file_size = GetModelFileSize(preloadedModel);
                    
                    // 对于装配体，直接计算子组件数量（避免重复API调用）
                    if (component.type == "assembly" && preloadedModel->GetType() == pfcMDL_ASSEMBLY) {
                        wfcWAssembly_ptr assembly = wfcWAssembly::cast(preloadedModel);
                        if (assembly) {
                            try {
                                pfcFeatures_ptr childFeatures = assembly->ListFeaturesByType(xfalse, pfcFEATTYPE_COMPONENT);
                                if (childFeatures) {
                                    component.children_count = childFeatures->getarraysize();
                                }
                            } catch (...) {
                                component.children_count = 0;
                            }
                        }
                    }
                } else {
                    component.file_size = "0.0MB";
                }
            } catch (...) {
                component.file_size = "0.0MB";
            }
        }
        
    } catch (...) {
        // 使用默认值
        component.id = "unknown_component_" + std::to_string(level);
        component.name = "Unknown Component";
        component.type = "part";
        component.path = currentPath + "/" + component.id;
        component.full_path = component.path;
    }
    
    return component;
}

pfcModel_ptr CreoManager::LoadComponentModel(pfcComponentFeat_ptr compFeat) {
    try {
        auto modelDescr = compFeat->GetModelDescr();
        if (!modelDescr) return nullptr;
        
        SessionInfo sessionInfo = GetSessionInfo();
        if (!sessionInfo.is_valid) return nullptr;
        
        // 尝试从会话中获取已加载的模型
        try {
            return sessionInfo.session->GetModelFromDescr(modelDescr);
        } catch (pfcXToolkitError&) {
            // 模型未加载，返回nullptr
            return nullptr;
        }
        
    } catch (...) {
        return nullptr;
    }
}

// 层级删除功能实现
CreoManager::HierarchyDeleteResult CreoManager::DeleteHierarchyComponents(const std::string& project_name, int target_level) {
    HierarchyDeleteResult result;
    result.target_level = target_level;
    
    SessionInfo sessionInfo = GetSessionInfo();
    if (!sessionInfo.is_valid) {
        result.error_message = "Creo session not available";
        return result;
    }
    
    try {
        pfcModel_ptr current_model = sessionInfo.session->GetCurrentModel();
        if (!current_model) {
            result.error_message = "No current model loaded";
            return result;
        }
        
        // 检查是否为装配体
        if (current_model->GetType() != pfcMDL_ASSEMBLY) {
            result.error_message = "Current model is not an assembly";
            return result;
        }
        
        // 转换为装配体
        wfcWAssembly_ptr assembly = wfcWAssembly::cast(current_model);
        if (!assembly) {
            result.error_message = "Failed to cast model to assembly";
            return result;
        }
        
        // target_level=2表示保留2层，删除第3层的组件
        // 层级映射：target_level=2 -> 删除level_3 -> currentLevel=2
        int deleteLevel = target_level - 1;
        
        // 收集删除统计信息
        std::map<int, std::vector<std::string>> componentsToDeleteByLevel;
        int total_deleted = 0;
        int successful_count = 0;
        int failed_count = 0;
        
        // 递归遍历到指定层级直接删除
        std::function<void(wfcWAssembly_ptr, int)> deleteAtLevel = [&](wfcWAssembly_ptr currentAssembly, int currentLevel) {
            if (!currentAssembly || currentLevel > deleteLevel) return;
            
            try {
                pfcFeatures_ptr features = currentAssembly->ListFeaturesByType(xfalse, pfcFEATTYPE_COMPONENT);
                
                // 正常执行，无需调试输出
                
                if (features) {
                    if (currentLevel == deleteLevel) {
                        // 在目标层级：获取所有组件并删除
                        xintsequence_ptr featIds = xintsequence::create();
                        std::vector<std::string> levelComponents;
                        for (int i = 0; i < features->getarraysize(); i++) {
                            pfcFeature_ptr feature = features->get(i);
                            pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
                            if (compFeat) {
                                // 记录组件信息用于响应
                                try {
                                    auto modelDescr = compFeat->GetModelDescr();
                                    if (modelDescr) {
                                        xstring filename_xstr = modelDescr->GetFileName();
                                        std::string filename = XStringToString(filename_xstr);
                                        levelComponents.push_back(filename);
                                        total_deleted++;
                                    }
                                } catch (...) {
                                    // 忽略获取文件名失败的组件
                                }
                                
                                // 添加到删除列表
                                int featId = feature->GetId();
                                featIds->append(featId);
                            }
                        }
                        
                        // 执行删除
                        if (featIds->getarraysize() > 0) {
                            try {
                                wfcWSolid_ptr wsolid = wfcWSolid::cast(currentAssembly);
                                if (wsolid) {
                                    
                                    // 使用SuppressFeatures方法，更安全地"删除"组件
                                    wfcFeatSuppressOrDeleteOptions_ptr options = wfcFeatSuppressOrDeleteOptions::create();
                                    options->append(wfcFEAT_SUPP_OR_DEL_NO_OPTS);
                                    
                                    // 创建重生成指令，允许失败
                                    wfcWRegenInstructions_ptr regenInstr = wfcWRegenInstructions::Create();
                                    
                                    // 执行抑制操作（更安全，不会破坏引用关系）
                                    wsolid->SuppressFeatures(featIds, options, regenInstr);
                                    
                                    // 手动重生成模型
                                    try {
                                        currentAssembly->Regenerate(nullptr);
                                    } catch (...) {
                                        // 重生成失败不影响抑制操作
                                    }
                                    
                                    successful_count += featIds->getarraysize();
                                    
                                    // 记录成功抑制的组件 - 累积而不是覆盖
                                    if (componentsToDeleteByLevel.find(deleteLevel + 1) == componentsToDeleteByLevel.end()) {
                                        componentsToDeleteByLevel[deleteLevel + 1] = std::vector<std::string>();
                                    }
                                    componentsToDeleteByLevel[deleteLevel + 1].insert(
                                        componentsToDeleteByLevel[deleteLevel + 1].end(),
                                        levelComponents.begin(), 
                                        levelComponents.end()
                                    );
                                } else {
                                    failed_count += featIds->getarraysize();
                                }
                            } catch (...) {
                                failed_count += featIds->getarraysize();
                            }
                        }
                    } else if (currentLevel < deleteLevel) {
                        // 还没到目标层级：只对装配体组件继续递归
                        for (int i = 0; i < features->getarraysize(); i++) {
                            pfcFeature_ptr feature = features->get(i);
                            pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
                            if (compFeat) {
                                auto modelDescr = compFeat->GetModelDescr();
                                if (modelDescr && modelDescr->GetType() == pfcMDL_ASSEMBLY) {
                                    pfcModel_ptr childModel = LoadComponentModel(compFeat);
                                    if (childModel && childModel->GetType() == pfcMDL_ASSEMBLY) {
                                        wfcWAssembly_ptr childAssembly = wfcWAssembly::cast(childModel);
                                        if (childAssembly) {
                                            deleteAtLevel(childAssembly, currentLevel + 1);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            } catch (...) {
                // 忽略单个装配体的错误
            }
        };
        
        // 从根装配体开始删除（层级0）
        deleteAtLevel(assembly, 0);
        
        result.deleted_components = componentsToDeleteByLevel;
        result.total_deleted = total_deleted;
        result.original_levels = 0;  // 临时设置，避免异常值
        
        // 删除完成后重新生成模型
        if (successful_count > 0) {
            try {
                assembly->Regenerate(nullptr);
            } catch (...) {
                // 重新生成失败不影响删除结果
            }
        }
        
        result.successful = successful_count;
        result.failed = failed_count;
        result.final_levels = target_level + 1;  // 删除后的层级数
        
        if (failed_count == 0) {
            result.success = true;
            result.message = "All components suppressed successfully (safer than deletion)";
        } else {
            result.success = (successful_count > 0);
            result.message = "Suppression completed with " + std::to_string(failed_count) + " failures";
        }
        
    } catch (const std::exception& e) {
        result.error_message = "Exception during suppression: " + std::string(e.what());
    } catch (...) {
        result.error_message = "Unknown error during suppression";
    }
    
    return result;
}

// 薄壳化分析实现 
CreoManager::ShellAnalysisResult CreoManager::AnalyzeShellFeatures(const ShellAnalysisRequest& request) {
    ShellAnalysisResult result;
    
    try {
        // 获取会话信息
        SessionInfo sessionInfo = GetSessionInfo();
        if (!sessionInfo.is_valid) {
            result.error_message = "Cannot connect to CREOSON server";
            return result;
        }
        
        // 获取当前模型
        pfcModel_ptr currentModel = sessionInfo.session->GetCurrentModel();
        if (!currentModel) {
            result.error_message = "Cannot get shell analysis results, please ensure a model is open in Creo";
            return result;
        }
        
        // === 第3步调试：添加基本特征分析逻辑 ===
        
        // 基本模型信息
        bool is_assembly = false;
        try {
            is_assembly = (currentModel->GetType() == pfcModelType::pfcMDL_ASSEMBLY);
        } catch (...) {
            is_assembly = false;
        }
        
        // 设置基本参数
        result.analysis_parameters.preserve_external_surfaces = request.preserve_external_surfaces;
        result.analysis_parameters.min_wall_thickness = request.min_wall_thickness;
        result.analysis_parameters.confidence_threshold = request.confidence_threshold;
        result.analysis_parameters.assembly_analysis = is_assembly;
        
        // === 真正的薄壳化分析算法 ===
        // 基于包络盒边界识别法 + 层次结构增强 + 特征安全性评估
        
        int total_features = 0;
        int deletable_features = 0;
        int preserved_features = 0;
        int shell_surfaces = 0;
        int internal_surfaces = 0;
        
        // 外壳特征白名单（基于算法原理）
        std::set<std::string> shell_feature_whitelist;
        
        try {
            if (!is_assembly) {
                // === 零件模型薄壳化分析 ===
                pfcSolid_ptr solid = pfcSolid::cast(currentModel);
                if (solid) {
                    pfcFeatures_ptr features = solid->ListFeaturesByType(NULL);
                    if (features) {
                        total_features = features->getarraysize();
                        
                        // === 第1步：真实几何包络盒计算（基于OTK API）===
                        pfcOutline3D_ptr global_outline = nullptr;
                        double tolerance = 0.1;  // 默认容差，后续根据模型大小调整
                        
                        try {
                            // 使用OTK API获取零件的真实几何边界
                            global_outline = solid->EvalOutline(nullptr);  // 使用默认坐标系
                            
                            if (global_outline) {
                                pfcPoint3D_ptr minPoint = global_outline->get(0);
                                pfcPoint3D_ptr maxPoint = global_outline->get(1);
                                
                                // 计算真实对角线长度
                                double dx = maxPoint->get(0) - minPoint->get(0);
                                double dy = maxPoint->get(1) - minPoint->get(1);
                                double dz = maxPoint->get(2) - minPoint->get(2);
                                double diagonal_length = sqrt(dx*dx + dy*dy + dz*dz);
                                
                                // 基于真实模型大小设置容差
                                tolerance = diagonal_length * 0.001;  // 0.1%容差
                            }
                        } catch (...) {
                            // 如果无法获取边界框，使用默认容差
                            tolerance = 1.0;
                        }
                        
                        // 第2步：外壳识别算法 - 基于包络盒边界识别法
                        for (int i = 0; i < total_features; i++) {
                            try {
                                pfcFeature_ptr feature = features->get(i);
                                if (feature) {
                                    pfcFeatureType feat_type = feature->GetFeatType();
                                    std::string feat_name = "";
                                    
                                    // 安全获取特征名称 - 生成标准格式名称
                                    try {
                                        xstring xstr_name = feature->GetName();
                                        if (xstr_name != xstringnil && !xstr_name.IsEmpty()) {
                                            feat_name = XStringToString(xstr_name);
                                        } else {
                                            // 使用特征类型+编号格式
                                            pfcFeatureType feat_type = feature->GetFeatType();
                                            std::string type_name = GetFeatureTypeName(feat_type);
                                            feat_name = type_name + "_" + std::to_string(i + 1);
                                        }
                                    } catch (...) {
                                        // 获取失败时，使用特征类型+编号格式
                                        try {
                                            pfcFeatureType feat_type = feature->GetFeatType();
                                            std::string type_name = GetFeatureTypeName(feat_type);
                                            feat_name = type_name + "_" + std::to_string(i + 1);
                                        } catch (...) {
                                            feat_name = "FEATURE_" + std::to_string(i + 1);
                                        }
                                    }
                                    
                                    // === 基于真实几何的薄壳化分析 ===
                                    double confidence = 0.5;  // 基础置信度，基于几何分析调整
                                    bool is_shell_feature = false;
                                    bool is_internal_feature = false;
                                    bool feature_touches_boundary = false;
                                    
                                    try {
                                        // === 真实几何分析：判断特征是否接触模型边界 ===
                                        feature_touches_boundary = AnalyzeFeatureGeometry(feature, global_outline, tolerance);
                                        
                                        // 基于几何位置的分类
                                        if (feature_touches_boundary) {
                                            // 特征接触模型边界 -> 可能是外壳特征
                                            is_shell_feature = true;
                                            shell_feature_whitelist.insert(feat_name);
                                            confidence = 0.2;  // 低置信度删除，倾向保留
                                            shell_surfaces++;
                                            
                                            // 进一步检查特征类型
                                            if (feat_type == pfcFeatureType::pfcFEATTYPE_PROTRUSION ||
                                                feat_type == pfcFeatureType::pfcFEATTYPE_SHELL ||
                                                feat_type == pfcFeatureType::pfcFEATTYPE_DOME ||
                                                feat_type == pfcFeatureType::pfcFEATTYPE_TORUS) {
                                                // 构建外形的特征且接触边界 -> 强制保留
                                                confidence = 0.05;
                                            }
                                        } else {
                                            // 特征完全在内部 -> 内部特征
                                            is_internal_feature = true;
                                            confidence = 0.8;  // 高置信度删除
                                            internal_surfaces++;
                                            
                                            // 内部特征的具体分类
                                            if (feat_type == pfcFeatureType::pfcFEATTYPE_CUT ||
                                                feat_type == pfcFeatureType::pfcFEATTYPE_HOLE ||
                                                feat_type == pfcFeatureType::pfcFEATTYPE_ROUND ||
                                                feat_type == pfcFeatureType::pfcFEATTYPE_CHAMFER) {
                                                // 明确的内部加工特征 -> 激进删除
                                                confidence = 0.95;
                                            }
                                        }
                                        
                                        // 标准件识别（优先级最高）
                                        if (IsStandardPart(feat_name)) {
                                            confidence = 0.99;  // 标准件强制删除
                                            is_internal_feature = true;
                                            is_shell_feature = false;
                                        }
                                        
                                        // 用户设置：保护外部表面
                                        if (request.preserve_external_surfaces && is_shell_feature) {
                                            confidence = std::min(confidence, 0.1);  // 强制保留外部表面
                                        }
                                        
                                    } catch (...) {
                                        // 几何分析失败，回退到基于特征类型的简单判断
                                        if (feat_type == pfcFeatureType::pfcFEATTYPE_CUT ||
                                            feat_type == pfcFeatureType::pfcFEATTYPE_HOLE) {
                                            confidence = 0.7;  // 中等置信度删除
                                            is_internal_feature = true;
                                        } else {
                                            confidence = 0.3;  // 低置信度删除，倾向保留
                                        }
                                    }
                                    
                                    // 置信度限制
                                    confidence = std::min(1.0, std::max(0.0, confidence));
                                    
                                    // 第4步：激进特征分类（降低删除阈值）
                                    if (confidence > 0.8) {
                                        // 安全删除：高置信度的内部特征
                                        FeatureDeletion deletion;
                                        deletion.id = i + 1;
                                        deletion.name = feat_name;
                                        deletion.type = GetFeatureTypeName(feat_type);
                                        deletion.reason = IsStandardPart(feat_name) ? 
                                            "Internal feature, safe for removal" :
                                            "Internal feature, safe for removal";
                                        deletion.confidence = confidence;
                                        deletion.volume_reduction = 
                                            (feat_type == pfcFeatureType::pfcFEATTYPE_CUT) ? 8 :
                                            (feat_type == pfcFeatureType::pfcFEATTYPE_HOLE) ? 6 : 4;
                                        deletion.component_type = "FEATURE";
                                        
                                        // 获取零件文件信息（零件模式 - 真实失败处理）
                                        if (currentModel) {
                                            try {
                                                xstring part_name = currentModel->GetFileName();
                                                if (part_name != xstringnil && !part_name.IsEmpty()) {
                                                    deletion.part_file = XStringToString(part_name);
                                                }
                                                // 如果获取失败，part_file保持空值
                                                
                                                // 尝试获取完整路径
                                                try {
                                                    xstring full_path = currentModel->GetFullName();
                                                    if (full_path != xstringnil && !full_path.IsEmpty()) {
                                                        deletion.part_path = XStringToString(full_path);
                                                    }
                                                } catch (...) {
                                                    // GetFullName失败，尝试GetOrigin
                                                    try {
                                                        xstring origin = currentModel->GetOrigin();
                                                        if (origin != xstringnil && !origin.IsEmpty()) {
                                                            deletion.part_path = XStringToString(origin);
                                                        }
                                                    } catch (...) {
                                                        // GetOrigin也失败，part_path保持空值
                                                    }
                                                }
                                                
                                            } catch (...) {
                                                // 所有方法都失败，part_file和part_path保持空值
                                            }
                                        }
                                        // currentModel为空时，part_file和part_path保持空值
                                        
                                        result.safe_deletions.push_back(deletion);
                                        deletable_features++;
                                        
                                    } else if (confidence > 0.5 && !is_shell_feature) {
                                        // 建议删除：中等置信度的非外壳特征
                                        FeatureDeletion suggestion;
                                        suggestion.id = i + 1;
                                        suggestion.name = feat_name;
                                        suggestion.type = GetFeatureTypeName(feat_type);
                                        suggestion.reason = "Suggest deletion - review recommended";
                                        suggestion.confidence = confidence;
                                        suggestion.volume_reduction = 3;
                                        suggestion.component_type = "FEATURE";
                                        
                                        // 获取零件文件信息（零件模式 - 真实失败处理）
                                        if (currentModel) {
                                            try {
                                                xstring part_name = currentModel->GetFileName();
                                                if (part_name != xstringnil && !part_name.IsEmpty()) {
                                                    suggestion.part_file = XStringToString(part_name);
                                                }
                                                // 如果获取失败，part_file保持空值
                                                
                                                // 尝试获取完整路径
                                                try {
                                                    xstring full_path = currentModel->GetFullName();
                                                    if (full_path != xstringnil && !full_path.IsEmpty()) {
                                                        suggestion.part_path = XStringToString(full_path);
                                                    }
                                                } catch (...) {
                                                    // GetFullName失败，尝试GetOrigin
                                                    try {
                                                        xstring origin = currentModel->GetOrigin();
                                                        if (origin != xstringnil && !origin.IsEmpty()) {
                                                            suggestion.part_path = XStringToString(origin);
                                                        }
                                                    } catch (...) {
                                                        // GetOrigin也失败，part_path保持空值
                                                    }
                                                }
                                                
                                            } catch (...) {
                                                // 所有方法都失败，part_file和part_path保持空值
                                            }
                                        }
                                        // currentModel为空时，part_file和part_path保持空值
                                        
                                        result.suggested_deletions.push_back(suggestion);
                                        
                                    } else {
                                        // 保留：低置信度或外壳特征
                                        FeatureDeletion preserve;
                                        preserve.id = i + 1;
                                        preserve.name = feat_name;
                                        preserve.type = GetFeatureTypeName(feat_type);
                                        preserve.reason = is_shell_feature ? 
                                            "Shell feature - preserve model appearance" :
                                            "Structural feature - preserve";
                                        preserve.confidence = confidence;
                                        preserve.volume_reduction = 0;
                                        preserve.component_type = "FEATURE";
                                        
                                        // 获取零件文件信息（零件模式 - 真实失败处理）
                                        if (currentModel) {
                                            try {
                                                xstring part_name = currentModel->GetFileName();
                                                if (part_name != xstringnil && !part_name.IsEmpty()) {
                                                    preserve.part_file = XStringToString(part_name);
                                                }
                                                // 如果获取失败，part_file保持空值
                                                
                                                // 尝试获取完整路径
                                                try {
                                                    xstring full_path = currentModel->GetFullName();
                                                    if (full_path != xstringnil && !full_path.IsEmpty()) {
                                                        preserve.part_path = XStringToString(full_path);
                                                    }
                                                } catch (...) {
                                                    // GetFullName失败，尝试GetOrigin
                                                    try {
                                                        xstring origin = currentModel->GetOrigin();
                                                        if (origin != xstringnil && !origin.IsEmpty()) {
                                                            preserve.part_path = XStringToString(origin);
                                                        }
                                                    } catch (...) {
                                                        // GetOrigin也失败，part_path保持空值
                                                    }
                                                }
                                                
                                            } catch (...) {
                                                // 所有方法都失败，part_file和part_path保持空值
                                            }
                                        }
                                        // currentModel为空时，part_file和part_path保持空值
                                        
                                        result.preserve_list.push_back(preserve);
                                        preserved_features++;
                                    }
                                }
                            } catch (...) {
                                continue;
                            }
                        }
                    }
                }
            } else {
                // === 装配体薄壳化分析（标准算法实现）===
                wfcWAssembly_ptr assembly = wfcWAssembly::cast(currentModel);
                if (assembly) {
                    
                    // === 第1步：数据获取 ===
                    pfcFeatures_ptr features = assembly->ListFeaturesByType(xfalse, pfcFEATTYPE_COMPONENT);
                    if (features) {
                        total_features = features->getarraysize();
                        
                        // 递归收集所有层级组件
                        std::vector<std::pair<pfcFeature_ptr, std::string>> all_components;
                        
                        // 获取根装配体名称作为路径起点（保留扩展名）
                        std::string root_assembly_name = "";
                        try {
                            xstring filename_xstr = currentModel->GetFileName();
                            if (filename_xstr != xstringnil && !filename_xstr.IsEmpty()) {
                                root_assembly_name = XStringToString(filename_xstr);
                                // 保留扩展名显示完整文件名
                                // 注意：这里显示的是Creo中当前打开的模型文件名
                            } else {
                                root_assembly_name = "ROOT_ASSEMBLY.asm";
                            }
                        } catch (...) {
                            root_assembly_name = "ROOT_ASSEMBLY.asm";
                        }
                        
                        CollectAllComponentsForShellAnalysis(assembly, root_assembly_name, all_components);
                        total_features = (int)all_components.size();
                        
                        // === 第2步：外壳识别算法 - 全局包络盒计算 ===
                        pfcOutline3D_ptr global_bbox = nullptr;
                        double tolerance = 0.1;
                        
                        try {
                            pfcSolid_ptr assemblySolid = pfcSolid::cast(assembly);
                            if (assemblySolid) {
                                global_bbox = assemblySolid->EvalOutline(nullptr);
                                if (global_bbox) {
                                    pfcPoint3D_ptr minPoint = global_bbox->get(0);
                                    pfcPoint3D_ptr maxPoint = global_bbox->get(1);
                                    
                                    // 计算对角线长度设置容差
                                    double dx = maxPoint->get(0) - minPoint->get(0);
                                    double dy = maxPoint->get(1) - minPoint->get(1);
                                    double dz = maxPoint->get(2) - minPoint->get(2);
                                    double diagonal_length = sqrt(dx*dx + dy*dy + dz*dz);
                                    tolerance = diagonal_length * 0.001;  // 标准容差：对角线长度 * 1e-3
                                }
                            }
                        } catch (...) {
                            tolerance = 1.0;  // 默认容差
                        }
                        
                        // === 第3步：外壳特征白名单构建 ===
                        std::set<std::string> shell_feature_whitelist;
                        
                        // 对每个组件进行边界判定
                        for (int i = 0; i < total_features; i++) {
                            try {
                                pfcFeature_ptr feature = all_components[i].first;
                                if (feature) {
                                    std::string comp_name = "";
                                    try {
                                        xstring xstr_name = feature->GetName();
                                        if (xstr_name != xstringnil && !xstr_name.IsEmpty()) {
                                            comp_name = XStringToString(xstr_name);
                                        } else {
                                            comp_name = "Component_" + std::to_string(i + 1);
                                        }
                                    } catch (...) {
                                        comp_name = "Component_" + std::to_string(i + 1);
                                    }
                                    
                                    // === 边界判定算法 ===
                                    bool is_on_boundary = false;
                                    try {
                                        pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
                                        if (compFeat && global_bbox) {
                                            pfcModelDescriptor_ptr modelDesc = compFeat->GetModelDescr();
                                            if (modelDesc) {
                                                pfcSession_ptr session = pfcGetCurrentSession();
                                                pfcModel_ptr componentModel = nullptr;
                                                try {
                                                    componentModel = session->GetModelFromDescr(modelDesc);
                                                } catch (...) {
                                                    componentModel = nullptr;
                                                }
                                                
                                                if (componentModel) {
                                                    pfcSolid_ptr componentSolid = pfcSolid::cast(componentModel);
                                                    if (componentSolid) {
                                                        pfcOutline3D_ptr comp_bbox = componentSolid->EvalOutline(nullptr);
                                                        if (comp_bbox) {
                                                            pfcPoint3D_ptr comp_min = comp_bbox->get(0);
                                                            pfcPoint3D_ptr comp_max = comp_bbox->get(1);
                                                            pfcPoint3D_ptr global_min = global_bbox->get(0);
                                                            pfcPoint3D_ptr global_max = global_bbox->get(1);
                                                            
                                                            // === 标准边界判定：if (S.min_extent ≈ global_min) OR (S.max_extent ≈ global_max) ===
                                                            if (abs(comp_min->get(0) - global_min->get(0)) < tolerance ||
                                                                abs(comp_min->get(1) - global_min->get(1)) < tolerance ||
                                                                abs(comp_min->get(2) - global_min->get(2)) < tolerance ||
                                                                abs(comp_max->get(0) - global_max->get(0)) < tolerance ||
                                                                abs(comp_max->get(1) - global_max->get(1)) < tolerance ||
                                                                abs(comp_max->get(2) - global_max->get(2)) < tolerance) {
                                                                is_on_boundary = true;
                                                                shell_feature_whitelist.insert(comp_name);
                                                                shell_surfaces++;
                                                            } else {
                                                                internal_surfaces++;
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    } catch (...) {
                                        // 边界判定失败，默认为内部组件
                                        internal_surfaces++;
                                    }
                                }
                            } catch (...) {
                                continue;
                            }
                        }
                        
                        // === 第4步：特征分类（标准置信度算法）===
                        for (int i = 0; i < total_features; i++) {
                            try {
                                pfcFeature_ptr feature = all_components[i].first;
                                std::string component_path = all_components[i].second;
                                if (feature) {
                                    std::string comp_name = "";
                                    
                                    // 安全获取组件文件名（与路径中的名称保持一致）
                                    try {
                                        pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
                                        if (compFeat) {
                                            auto modelDescr = compFeat->GetModelDescr();
                                            if (modelDescr) {
                                                xstring filename_xstr = modelDescr->GetFileName();
                                                if (filename_xstr != xstringnil && !filename_xstr.IsEmpty()) {
                                                    comp_name = XStringToString(filename_xstr);
                                                    // 保留扩展名，与路径中的名称保持一致
                                                } else {
                                                    comp_name = "Component_" + std::to_string(i + 1);
                                                }
                                            } else {
                                                comp_name = "Component_" + std::to_string(i + 1);
                                            }
                                        } else {
                                            comp_name = "Component_" + std::to_string(i + 1);
                                        }
                                    } catch (...) {
                                        comp_name = "Component_" + std::to_string(i + 1);
                                    }
                                    
                                    // === 标准置信度计算算法 ===
                                    double confidence = 0.5;  // 基础置信度
                                    bool is_standard = IsStandardPart(comp_name);
                                    bool is_internal = IsInternalPart(feature, currentModel);
                                    bool is_in_shell_whitelist = (shell_feature_whitelist.find(comp_name) != shell_feature_whitelist.end());
                                    std::string deletion_reason = "Standard shell analysis";
                                    
                                    // === 标准置信度算法：按文档实现 ===
                                    // confidence = calculate_deletion_confidence(feature, shell_whitelist, hierarchy)
                                    
                                    // === 优先级判断：避免逻辑冲突 ===
                                    // 规则1：标准件（最高优先级）
                                    if (is_standard) {
                                        confidence += 0.4;  // 提高到0.9，确保进入safeDeletions
                                        deletion_reason = "Standard part detected";
                                    }
                                    // 规则2：外壳特征判断（不能与内部组件冲突）
                                    else if (is_in_shell_whitelist) {
                                        confidence -= 0.4;
                                        deletion_reason = "Shell feature - boundary component";
                                    }
                                    // 规则3：内部组件判断（与外壳特征互斥）
                                    else if (is_internal) {
                                        confidence += 0.35; // 提高到0.85，确保进入safeDeletions
                                        deletion_reason = "Internal part by geometry";
                                    }
                                    
                                    // 规则4：层级深度分析（BOM层次结构增强 - 修复版本）
                                    int path_depth = std::count(component_path.begin(), component_path.end(), '/');
                                    
                                    // 安全检查：前2层级的组件（包括根装配体的直接子组件）需要谨慎处理
                                    if (path_depth <= 1) {
                                        // 根层级组件（如ROOT.asm/SUB.asm），强制保留主要装配体
                                        if (component_path.find(".asm") != std::string::npos) {
                                            confidence -= 0.3;  // 降低装配体删除置信度
                                            if (deletion_reason == "Standard shell analysis") {
                                                deletion_reason = "Root level assembly - preserve structure";
                                            }
                                        }
                                    } else if (path_depth == 2) {
                                        // 第二层级（如ROOT.asm/SUB.asm/PART.prt），适度提高删除置信度
                                        if (component_path.find(".asm") != std::string::npos) {
                                            // 子装配体保持谨慎
                                            confidence += 0.1;
                                        } else {
                                            // 零件可以适度提高
                                            confidence += 0.15;
                                        }
                                        if (deletion_reason == "Standard shell analysis") {
                                            deletion_reason = "Second level component";
                                        }
                                    } else if (path_depth >= 4) {
                                        // 很深层级（4层以上），可以较激进删除
                                        confidence += 0.3;
                                        if (deletion_reason == "Standard shell analysis") {
                                            deletion_reason = "Very deep hierarchy component";
                                        }
                                    } else if (path_depth == 3) {
                                        // 第三层级，适度提高删除置信度
                                        confidence += 0.2;
                                        if (deletion_reason == "Standard shell analysis") {
                                            deletion_reason = "Deep hierarchy component";
                                        }
                                    }
                                    
                                    // 限制置信度范围
                                    confidence = std::min(1.0, std::max(0.0, confidence));
                                    
                                    // === 特征安全性评估算法分类（按文档标准）===
                                    
                                    if (confidence > 0.8) {
                                        // Safe Deletions: 内部特征 + 非外壳表面 + confidence > 0.8
                                        FeatureDeletion deletion;
                                        deletion.id = i + 1;
                                        deletion.name = comp_name;
                                        deletion.type = "COMPONENT";
                                        deletion.reason = deletion_reason;
                                        deletion.confidence = confidence;
                                        deletion.volume_reduction = 5;  // 合理估算值
                                        deletion.component_type = "COMPONENT";
                                        
                                        // 获取组件文件信息（装配体模式 - 确保信息完整性）
                                        try {
                                            pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
                                            if (compFeat) {
                                                auto modelDescr = compFeat->GetModelDescr();
                                                if (modelDescr) {
                                                    xstring filename_xstr = modelDescr->GetFileName();
                                                    if (filename_xstr != xstringnil && !filename_xstr.IsEmpty()) {
                                                        deletion.part_file = XStringToString(filename_xstr);
                                                    }
                                                    // 如果获取失败，part_file保持空值
                                                    deletion.part_path = component_path;
                                                } else {
                                                    // modelDescr为空，part_file保持空值
                                                    deletion.part_path = component_path;
                                                }
                                            } else {
                                                // compFeat为空，part_file保持空值
                                                deletion.part_path = component_path;
                                            }
                                        } catch (...) {
                                            // 组件信息获取失败，part_file和part_path保持空值
                                        }
                                        
                                        result.safe_deletions.push_back(deletion);
                                        deletable_features++;
                                        
                                    } else if (confidence >= 0.5 && confidence <= 0.8) {
                                        // Suggested Deletions: 部分内部特征 + confidence 0.5-0.8
                                        FeatureDeletion suggestion;
                                        suggestion.id = i + 1;
                                        suggestion.name = comp_name;
                                        suggestion.type = "COMPONENT";
                                        suggestion.reason = deletion_reason;
                                        suggestion.confidence = confidence;
                                        suggestion.volume_reduction = 3;  // 合理估算值
                                        suggestion.component_type = "COMPONENT";
                                        
                                        // 获取组件文件信息（装配体模式 - 确保信息完整性）
                                        try {
                                            pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
                                            if (compFeat) {
                                                auto modelDescr = compFeat->GetModelDescr();
                                                if (modelDescr) {
                                                    xstring filename_xstr = modelDescr->GetFileName();
                                                    if (filename_xstr != xstringnil && !filename_xstr.IsEmpty()) {
                                                        suggestion.part_file = XStringToString(filename_xstr);
                                                    }
                                                    // 如果获取失败，part_file保持空值
                                                    suggestion.part_path = component_path;
                                                } else {
                                                    // modelDescr为空，part_file保持空值
                                                    suggestion.part_path = component_path;
                                                }
                                            } else {
                                                // compFeat为空，part_file保持空值
                                                suggestion.part_path = component_path;
                                            }
                                        } catch (...) {
                                            // 组件信息获取失败，part_file和part_path保持空值
                                        }
                                        
                                        result.suggested_deletions.push_back(suggestion);
                                        
                                    } else {
                                        // Preserve: 外壳特征 + 基础结构特征 + confidence < 0.5
                                        FeatureDeletion preserve;
                                        preserve.id = i + 1;
                                        preserve.name = comp_name;
                                        preserve.type = "COMPONENT";
                                        preserve.reason = deletion_reason;
                                        preserve.confidence = confidence;
                                        preserve.volume_reduction = 0;
                                        preserve.component_type = "COMPONENT";
                                        
                                        // 获取组件文件信息（装配体模式 - 确保信息完整性）
                                        try {
                                            pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
                                            if (compFeat) {
                                                auto modelDescr = compFeat->GetModelDescr();
                                                if (modelDescr) {
                                                    xstring filename_xstr = modelDescr->GetFileName();
                                                    if (filename_xstr != xstringnil && !filename_xstr.IsEmpty()) {
                                                        preserve.part_file = XStringToString(filename_xstr);
                                                    }
                                                    // 如果获取失败，part_file保持空值
                                                    preserve.part_path = component_path;
                                                } else {
                                                    // modelDescr为空，part_file保持空值
                                                    preserve.part_path = component_path;
                                                }
                                            } else {
                                                // compFeat为空，part_file保持空值
                                                preserve.part_path = component_path;
                                            }
                                        } catch (...) {
                                            // 组件信息获取失败，part_file和part_path保持空值
                                        }
                                        
                                        result.preserve_list.push_back(preserve);
                                        preserved_features++;
                                    }
                                }
                            } catch (...) {
                                continue;
                            }
                        }
                    }
                }
            }
        } catch (...) {
            total_features = 0;
            deletable_features = 0;
            preserved_features = 0;
        }
        
        // 设置薄壳化分析统计信息
        result.analysis_parameters.total_features = total_features;
        result.analysis_parameters.deletable_features = deletable_features;
        result.analysis_parameters.preserved_features = preserved_features;
        result.analysis_parameters.surface_count = shell_surfaces + internal_surfaces;
        result.analysis_parameters.shell_surfaces = shell_surfaces;
        result.analysis_parameters.internal_surfaces = internal_surfaces;
        result.analysis_parameters.shell_feature_whitelist = (int)shell_feature_whitelist.size();
        
        // 计算预估效果（基于删除建议 - 改进的合理化算法）
        int total_safe_deletions = (int)result.safe_deletions.size();
        int total_suggested_deletions = (int)result.suggested_deletions.size();
        int total_deletable_items = total_safe_deletions + total_suggested_deletions;
        
        if (total_deletable_items > 0 && total_features > 0) {
            // 基于删除项目数量的合理化计算
            double deletion_ratio = (double)total_deletable_items / (double)total_features;
            
            // 体积优化估算（基于删除比例，最大不超过50%）
            int volume_reduction_percent = std::min(50, (int)(deletion_ratio * 30 + total_safe_deletions * 2));
            
            // 文件大小优化估算（通常比体积优化低一些）
            int file_size_reduction_percent = std::min(40, volume_reduction_percent * 3 / 4);
            
            // 性能提升估算（基于删除的复杂度，最大2.5倍）
            double performance_multiplier = std::min(2.5, 1.0 + deletion_ratio * 1.2 + total_safe_deletions * 0.05);
            
            result.estimated_reduction.volume_reduction = std::to_string(volume_reduction_percent) + "%";
            result.estimated_reduction.file_size_reduction = std::to_string(file_size_reduction_percent) + "%";
            
            std::ostringstream perf_stream;
            perf_stream << std::fixed << std::setprecision(1) << performance_multiplier << "x";
            result.estimated_reduction.performance_improvement = perf_stream.str();
        } else {
            result.estimated_reduction.volume_reduction = "0%";
            result.estimated_reduction.file_size_reduction = "0%";
            result.estimated_reduction.performance_improvement = "1.0x";
        }
        
        // 装配体层次分析（如果是装配体）
        if (is_assembly) {
            result.analysis_parameters.hierarchy_analysis.enabled = true;
            result.analysis_parameters.hierarchy_analysis.total_parts = 0;
            result.analysis_parameters.hierarchy_analysis.outer_parts = 0;
            result.analysis_parameters.hierarchy_analysis.internal_parts = 0;
            result.analysis_parameters.hierarchy_analysis.containment_relationships = 0;
            result.analysis_parameters.hierarchy_analysis.performance_stats["total_analysis_time"] = "Shell analysis complete - bbox boundary identification + hierarchy enhancement";
            result.analysis_parameters.hierarchy_analysis.performance_stats["api_calls_made"] = "BBox + Surface + FeatureType + StandardPart + WallThickness + Confidence";
        }
        
        result.success = true;
        
    } catch (const std::exception& e) {
        result.error_message = "Server internal error: " + std::string(e.what());
    } catch (...) {
        result.error_message = "Server internal error: unknown exception";
    }
    
    return result;
}

// 辅助方法：获取特征类型名称
std::string CreoManager::GetFeatureTypeName(pfcFeatureType feat_type) {
    switch (feat_type) {
        case pfcFeatureType::pfcFEATTYPE_PROTRUSION: return "EXTRUDE";
        case pfcFeatureType::pfcFEATTYPE_CUT: return "CUT";
        case pfcFeatureType::pfcFEATTYPE_SHELL: return "SHELL";
        case pfcFeatureType::pfcFEATTYPE_HOLE: return "HOLE";
        case pfcFeatureType::pfcFEATTYPE_ROUND: return "ROUND";
        case pfcFeatureType::pfcFEATTYPE_CHAMFER: return "CHAMFER";
        case pfcFeatureType::pfcFEATTYPE_DATUM_PLANE: return "DATUM_PLANE";
        case pfcFeatureType::pfcFEATTYPE_DATUM_AXIS: return "DATUM_AXIS";
        case pfcFeatureType::pfcFEATTYPE_COMPONENT: return "COMPONENT";
        default: return "UNKNOWN";
    }
}

// 辅助方法：判断是否为外部表面特征
bool CreoManager::IsExternalSurface(pfcFeature_ptr feature, bool preserve_external) {
    if (!preserve_external) return false;
    
    // 基础判断逻辑（占位实现，后续可优化）
    pfcFeatureType feat_type = feature->GetFeatType();
    
    // 外壳特征通常是外部表面
    if (feat_type == pfcFeatureType::pfcFEATTYPE_SHELL) {
        return true;
    }
    
    // 其他基础判断规则
    // 这里可以加入更复杂的表面分析逻辑
    return false;
}

// 辅助方法：检查壁厚
bool CreoManager::CheckWallThickness(pfcFeature_ptr feature, double min_thickness) {
    // 基础壁厚检查逻辑（占位实现）
    // 实际实现需要几何分析算法
    
    pfcFeatureType feat_type = feature->GetFeatType();
    
    // 简单规则：某些特征类型认为符合壁厚要求
    if (feat_type == pfcFeatureType::pfcFEATTYPE_CUT || 
        feat_type == pfcFeatureType::pfcFEATTYPE_HOLE) {
        return true;  // 切削和孔特征通常可以删除
    }
    
    return false;
}

// === 薄壳化算法核心实现 ===

// 删除了模拟包络盒计算 - 薄壳化分析直接基于特征类型

// 删除了模拟表面数据函数 - 薄壳化分析直接基于特征进行

// 删除了模拟表面识别算法 - 直接基于特征类型进行判断

// 5. 标准件识别算法
bool CreoManager::IsStandardPart(const std::string& part_name) {
    // 标准件关键词列表
    std::vector<std::string> standard_keywords = {
        "SCREW", "BOLT", "NUT", "WASHER", "BEARING",
        "GASKET", "SEAL", "O-RING", "SPRING", "PIN",
        "螺钉", "螺栓", "螺母", "垫圈", "轴承", "弹簧",
        "screw", "bolt", "nut", "washer", "bearing", "spring"
    };
    
    std::string upper_name = part_name;
    std::transform(upper_name.begin(), upper_name.end(), upper_name.begin(), ::toupper);
    
    for (const auto& keyword : standard_keywords) {
        if (upper_name.find(keyword) != std::string::npos) {
            return true;
        }
    }
    
    return false;
}

// 6. 内部零件判断（基于几何算法）
bool CreoManager::IsInternalPart(pfcFeature_ptr feature, pfcModel_ptr model) {
    // 首先基于特征类型判断（明确的内部特征）
    pfcFeatureType feat_type = feature->GetFeatType();
    if (feat_type == pfcFeatureType::pfcFEATTYPE_CUT ||
        feat_type == pfcFeatureType::pfcFEATTYPE_HOLE) {
        return true;
    }
    
    // === 基于几何算法的内部组件识别 ===
    try {
        // 对于组件特征，尝试获取其几何信息
        if (feat_type == pfcFeatureType::pfcFEATTYPE_COMPONENT) {
            pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
            if (compFeat) {
                // 获取组件模型
                pfcModel_ptr componentModel = nullptr;
                try {
                    pfcModelDescriptor_ptr modelDesc = compFeat->GetModelDescr();
                    if (modelDesc) {
                        pfcSession_ptr session = pfcGetCurrentSession();
                        try {
                            componentModel = session->GetModelFromDescr(modelDesc);
                        } catch (...) {
                            // 模型不在内存中，返回nullptr
                            componentModel = nullptr;
                        }
                    }
                } catch (...) {
                    // 模型获取失败，使用几何分析
                }
                
                if (componentModel) {
                    // === 算法1：基于体积比例判断 ===
                    try {
                        pfcSolid_ptr componentSolid = pfcSolid::cast(componentModel);
                        pfcSolid_ptr parentSolid = pfcSolid::cast(model);
                        
                        if (componentSolid && parentSolid) {
                            // 获取质量属性来计算体积
                            pfcMassProperty_ptr compMass = componentSolid->GetMassProperty(nullptr);
                            pfcMassProperty_ptr parentMass = parentSolid->GetMassProperty(nullptr);
                            
                            if (compMass && parentMass) {
                                double compVolume = compMass->GetVolume();
                                double parentVolume = parentMass->GetVolume();
                                
                                // 小体积组件（<5%总体积）更可能是内部组件
                                if (compVolume / parentVolume < 0.05) {
                                    return true;
                                }
                            }
                        }
                    } catch (...) {
                        // 质量属性获取失败，继续其他算法
                    }
                    
                    // === 算法2：基于包络盒分析 ===
                    try {
                        pfcSolid_ptr componentSolid = pfcSolid::cast(componentModel);
                        pfcSolid_ptr parentSolid = pfcSolid::cast(model);
                        
                        if (componentSolid && parentSolid) {
                            pfcOutline3D_ptr compOutline = componentSolid->EvalOutline(nullptr);
                            pfcOutline3D_ptr parentOutline = parentSolid->EvalOutline(nullptr);
                            
                            if (compOutline && parentOutline) {
                                // 计算组件包络盒
                                pfcPoint3D_ptr compMin = compOutline->get(0);
                                pfcPoint3D_ptr compMax = compOutline->get(1);
                                pfcPoint3D_ptr parentMin = parentOutline->get(0);
                                pfcPoint3D_ptr parentMax = parentOutline->get(1);
                                
                                // 计算距离边界的最小距离
                                double minDistToEdge = std::min({
                                    compMin->get(0) - parentMin->get(0),  // X方向距离左边界
                                    parentMax->get(0) - compMax->get(0),  // X方向距离右边界
                                    compMin->get(1) - parentMin->get(1),  // Y方向距离
                                    parentMax->get(1) - compMax->get(1),
                                    compMin->get(2) - parentMin->get(2),  // Z方向距离
                                    parentMax->get(2) - compMax->get(2)
                                });
                                
                                // 计算总尺寸作为参考
                                double parentDiagonal = sqrt(
                                    pow(parentMax->get(0) - parentMin->get(0), 2) +
                                    pow(parentMax->get(1) - parentMin->get(1), 2) +
                                    pow(parentMax->get(2) - parentMin->get(2), 2)
                                );
                                
                                // 如果组件距离边界较远（>5%对角线距离），认为是内部组件
                                if (minDistToEdge > parentDiagonal * 0.05) {
                                    return true;
                                }
                            }
                        }
                    } catch (...) {
                        // 包络盒分析失败
                    }
                }
            }
        }
    } catch (...) {
        // 几何分析失败，回退到特征类型判断
    }
    
    return false;
}

// 薄壳化分析递归方法：收集所有层级的组件
void CreoManager::CollectAllComponentsForShellAnalysis(wfcWAssembly_ptr assembly, 
                                                      const std::string& parentPath,
                                                      std::vector<std::pair<pfcFeature_ptr, std::string>>& allComponents) {
    if (!assembly) return;
    
    try {
        // 获取当前装配体的所有组件（包括隐藏的）
        pfcFeatures_ptr features = assembly->ListFeaturesByType(xfalse, pfcFEATTYPE_COMPONENT);
        if (!features) return;
        
        for (int i = 0; i < features->getarraysize(); i++) {
            try {
                pfcFeature_ptr feature = features->get(i);
                if (!feature) continue;
                
                // 获取组件文件名（参考层级分析的方法）
                std::string comp_name = "";
                try {
                    pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
                    if (compFeat) {
                        auto modelDescr = compFeat->GetModelDescr();
                        if (modelDescr) {
                            xstring filename_xstr = modelDescr->GetFileName();
                            if (filename_xstr != xstringnil && !filename_xstr.IsEmpty()) {
                                comp_name = XStringToString(filename_xstr);
                                // 保留扩展名显示完整文件名
                            } else {
                                comp_name = "Component_" + std::to_string(i + 1);
                            }
                        } else {
                            comp_name = "Component_" + std::to_string(i + 1);
                        }
                    } else {
                        comp_name = "Component_" + std::to_string(i + 1);
                    }
                } catch (...) {
                    comp_name = "Component_" + std::to_string(i + 1);
                }
                
                // 构建完整路径（与层级分析逻辑保持一致）
                std::string full_path;
                if (parentPath.empty()) {
                    // 根层级组件：使用文件名作为路径（与层级分析一致）
                    full_path = comp_name;
                } else {
                    full_path = parentPath + "/" + comp_name;
                }
                
                // 添加到组件列表
                allComponents.push_back(std::make_pair(feature, full_path));
                
                // 如果是子装配体，递归分析
                try {
                    pfcComponentFeat_ptr compFeat = pfcComponentFeat::cast(feature);
                    if (compFeat) {
                        pfcModel_ptr childModel = LoadComponentModel(compFeat);
                        if (childModel) {
                            wfcWAssembly_ptr childAssembly = wfcWAssembly::cast(childModel);
                            if (childAssembly) {
                                // 递归收集子装配体的组件
                                CollectAllComponentsForShellAnalysis(childAssembly, full_path, allComponents);
                            }
                        }
                    }
                } catch (...) {
                    // 处理无法加载的子装配体，继续处理下一个
                    continue;
                }
                
            } catch (...) {
                continue; // 忽略单个组件错误
            }
        }
        
    } catch (...) {
        // 处理整体错误
    }
}

// 真实几何分析：判断特征是否接触模型边界
bool CreoManager::AnalyzeFeatureGeometry(pfcFeature_ptr feature, pfcOutline3D_ptr globalOutline, double tolerance) {
    if (!feature || !globalOutline) {
        return false;  // 无法分析，假设不接触边界
    }
    
    try {
        // 获取全局边界框
        pfcPoint3D_ptr globalMin = globalOutline->get(0);
        pfcPoint3D_ptr globalMax = globalOutline->get(1);
        
        // 目前OTK没有直接的"特征边界框"API，我们使用特征类型来推断
        // 这是基于特征语义的几何分析，比完全的猜测更准确
        
        pfcFeatureType feat_type = feature->GetFeatType();
        
        // === 基于特征语义的边界分析 ===
        
        // 1. 构建外形的特征通常接触边界
        if (feat_type == pfcFeatureType::pfcFEATTYPE_PROTRUSION ||
            feat_type == pfcFeatureType::pfcFEATTYPE_SHELL ||
            feat_type == pfcFeatureType::pfcFEATTYPE_DOME ||
            feat_type == pfcFeatureType::pfcFEATTYPE_TORUS) {
            return true;  // 这些特征定义模型外形，必定接触边界
        }
        
        // 2. 基础几何特征通常在边界上
        if (feat_type == pfcFeatureType::pfcFEATTYPE_FIRST) {
            return true;  // 基础特征在边界
        }
        
        // 3. 内部加工特征通常不接触边界
        if (feat_type == pfcFeatureType::pfcFEATTYPE_CUT ||
            feat_type == pfcFeatureType::pfcFEATTYPE_HOLE ||
            feat_type == pfcFeatureType::pfcFEATTYPE_ROUND ||
            feat_type == pfcFeatureType::pfcFEATTYPE_CHAMFER ||
            feat_type == pfcFeatureType::pfcFEATTYPE_RIB ||
            feat_type == pfcFeatureType::pfcFEATTYPE_DRAFT) {
            
            // 对于加工特征，进一步分析
            // 倒角和圆角可能在边界上（修饰外形）
            if (feat_type == pfcFeatureType::pfcFEATTYPE_ROUND ||
                feat_type == pfcFeatureType::pfcFEATTYPE_CHAMFER) {
                return true;  // 倒角圆角通常修饰外形，接触边界
            }
            
            // CUT和HOLE通常是内部特征
            return false;  // 不接触边界
        }
        
        // 4. 基准特征通常与边界无关
        if (feat_type == pfcFeatureType::pfcFEATTYPE_DATUM_PLANE ||
            feat_type == pfcFeatureType::pfcFEATTYPE_DATUM_AXIS ||
            feat_type == pfcFeatureType::pfcFEATTYPE_DATUM_POINT ||
            feat_type == pfcFeatureType::pfcFEATTYPE_COORD_SYS) {
            return false;  // 基准特征不影响几何边界
        }
        
        // 5. 装配体特征
        if (feat_type == pfcFeatureType::pfcFEATTYPE_COMPONENT) {
            // 组件特征需要进一步分析，这里暂时假设接触边界
            return true;
        }
        
        // 6. 其他特征类型的默认处理
        // 对于不确定的特征类型，采用保守策略（假设接触边界）
        return true;
        
    } catch (...) {
        // 分析失败，采用保守策略
        return true;  // 假设接触边界，避免错误删除重要特征
    }
}