/**
 * XML处理模块
 * @type {module}
 */

/**
 * 解析XML内容
 * @param {string} content - XML内容字符串
 * @returns {Object} 包含解析结果的对象 {xmlDoc, error, basicXml}
 */
export function parseXmlContent(content) {
    const parser = new DOMParser();
    let xmlDoc;
    let error = null;
    let basicXml = null;
    
    try {
        xmlDoc = parser.parseFromString(content, 'application/xml');
        // 检查解析错误
        const parseError = xmlDoc.querySelector('parsererror');
        if (parseError) {
            throw new Error('XML解析错误');
        }
    } catch (parseError) {
        error = parseError;
        
        // 如果内容为空或解析失败，提示用户无法解析xml文件内容
        if (!content.trim()) {
            // 提示用户无法解析xml文件内容
            alert('无法解析xml文件内容');
            return { xmlDoc: null, error: '无法解析xml文件内容', basicXml: null };
        }
    }
    
    return { xmlDoc, error, basicXml };
}

/**
 * 确保命令列表格式正确
 * @param {Document} xmlDoc - XML文档对象
 * @returns {Element|null} - 命令列表元素
 */
export function ensureCommandListFormat(xmlDoc) {
    if (!xmlDoc) return null;
    
    const rootElement = xmlDoc.documentElement;
    if (!rootElement) return null;
    
    // 查找CommandList元素
    let commandListElement = rootElement.querySelector('CommandList');
    
    // 如果不存在，创建一个新的
    if (!commandListElement) {
        commandListElement = xmlDoc.createElement('CommandList');
        rootElement.appendChild(commandListElement);
    }
    
    return commandListElement;
}

/**
 * 从可视化编辑器更新XML
 * @param {Document} xmlDoc - XML文档对象
 * @returns {string} 更新后的XML字符串
 */
export function updateXmlFromVisualEditor(xmlDoc) {
    if (!xmlDoc) return '';
    
    const modifiedXml = new XMLSerializer().serializeToString(xmlDoc);
    return modifiedXml;
}

/**
 * 根据路径更新元素值
 * @param {Document} xmlDoc - XML文档对象
 * @param {string} path - 元素路径
 * @param {string} value - 新值
 * @returns {boolean} 更新是否成功
 */
export function updateElementByPath(xmlDoc, path, value) {
    if (!xmlDoc) return false;
    
    try {
        // 分割路径
        const pathParts = path.split('/').filter(p => p);
        let currentElement = xmlDoc.documentElement;
        
        // 跳过根元素
        for (let i = 1; i < pathParts.length; i++) {
            const part = pathParts[i];
            
            // 查找子元素
            let found = false;
            for (let j = 0; j < currentElement.children.length; j++) {
                if (currentElement.children[j].nodeName === part) {
                    currentElement = currentElement.children[j];
                    found = true;
                    break;
                }
            }
            
            if (!found) {
                throw new Error(`找不到元素: ${path}`);
            }
        }
        
        // 更新元素值
        currentElement.textContent = value;
        return true;
    } catch (error) {
        console.error('更新元素失败:', error);
        return false;
    }
}

/**
 * 更新元素值
 * @param {Document} xmlDoc - XML文档对象
 * @param {string} elementName - 元素名称
 * @param {string} value - 元素值
 * @returns {Element|null} 更新的元素
 */
export function updateElementValue(xmlDoc, elementName, value) {
    if (!xmlDoc) return null;
    
    const root = xmlDoc.documentElement;
    let element = null;
    
    // 查找元素
    for (let i = 0; i < root.children.length; i++) {
        if (root.children[i].nodeName === elementName) {
            element = root.children[i];
            break;
        }
    }
    
    // 如果元素不存在则创建
    if (!element) {
        element = xmlDoc.createElement(elementName);
        root.appendChild(element);
    }
    
    // 更新值
    element.textContent = value;
    return element;
}

/**
 * 添加新元素
 * @param {Document} xmlDoc - XML文档对象
 * @param {Element} parentElement - 父元素
 * @param {string} name - 元素名称
 * @param {string} value - 元素值
 * @returns {Element|null} 新创建的元素
 */
export function addElement(xmlDoc, parentElement, name, value) {
    if (!xmlDoc || !parentElement) return null;
    
    try {
        // 创建新元素
        const newElement = xmlDoc.createElement(name);
        
        // 设置值
        if (value) {
            newElement.textContent = value;
        }
        
        // 添加到父元素
        parentElement.appendChild(newElement);
        return newElement;
    } catch (error) {
        console.error('添加元素失败:', error);
        return null;
    }
}

/**
 * 删除元素
 * @param {Element} element - 要删除的元素
 * @returns {boolean} 删除是否成功
 */
export function deleteElement(element) {
    if (!element || !element.parentNode) return false;
    
    try {
        element.parentNode.removeChild(element);
        return true;
    } catch (error) {
        console.error('删除元素失败:', error);
        return false;
    }
}