const { getDBConnection } = require('./file-utils');
const { deleteDataInterfaceTable, createDataInterfaceTable, copyDataInterfaceTable } = require('./data-interface-utils');

// 获取所有构型
function getConfigurations(planeName) {
  try {
    const db = getDBConnection(true);
    
    let query = `
      SELECT * FROM Configuration
    `;
    
    const params = [];
    if (planeName) {
      query += ` WHERE PlaneName = ?`;
      params.push(planeName);
    }
    
    query += ` ORDER BY ConfID ASC`;
    
    const configs = db.prepare(query).all(...params);
    
    return configs;
  } catch (error) {
    console.error('获取构型列表失败:', error);
    throw error;
  }
}

// 根据ID获取构型
function getConfigurationById(confId) {
  try {
    const db = getDBConnection(true);
    
    const config = db.prepare(`
      SELECT * FROM Configuration
      WHERE ConfID = ?
    `).get(confId);
    
    return config;
  } catch (error) {
    console.error(`获取构型ID ${confId} 失败:`, error);
    throw error;
  }
}

/**
 * 复制模型组及其下的模型
 * @param {number} sourceConfId - 源构型ID
 * @param {number} targetConfId - 目标构型ID
 */
function copyModelGroupsAndModels(sourceConfId, targetConfId) {
    try {
        const db = getDBConnection();
        
        // 1. 获取源构型的所有模型组
        const sourceGroups = db.prepare(`
            SELECT * FROM LoadModelGroups
            WHERE ConfID = ?
        `).all(sourceConfId);
        
        // 2. 复制每个模型组及其下的模型
        for (const group of sourceGroups) {
            // 2.1 插入新的模型组
            db.prepare(`
                INSERT INTO LoadModelGroups (
                    ConfID, GroupName, Freq, Priority, CPUAff
                ) VALUES (?, ?, ?, ?, ?)
            `).run(
                targetConfId,
                group.GroupName,
                group.Freq,
                group.Priority,
                group.CPUAff
            );
            
            // 2.2 获取新插入的模型组ID
            const newGroupId = db.prepare('SELECT GroupID FROM LoadModelGroups WHERE rowid = last_insert_rowid()').get().GroupID;
            
            // 2.3 获取并复制该组下的所有模型
            const sourceModels = db.prepare(`
                SELECT * FROM LoadModels
                WHERE GroupID = ?
            `).all(group.GroupID);
            
            // 2.4 插入新的模型
            for (const model of sourceModels) {
                db.prepare(`
                    INSERT INTO LoadModels (
                        GroupID, ClassName, ModelVersion, ModelName
                    ) VALUES (?, ?, ?, ?)
                `).run(
                    newGroupId,
                    model.ClassName,
                    model.ModelVersion,
                    model.ModelName
                );
            }
        }
    } catch (error) {
        console.error('复制模型组和模型失败:', error);
        throw error;
    }
}

/**
 * 复制服务
 * @param {number} sourceConfId - 源构型ID
 * @param {number} targetConfId - 目标构型ID
 */
function copyServices(sourceConfId, targetConfId) {
    try {
        const db = getDBConnection();
        
        // 1. 获取源构型的所有服务
        const sourceServices = db.prepare(`
            SELECT * FROM LoadServices
            WHERE ConfID = ?
        `).all(sourceConfId);
        
        // 2. 复制每个服务
        for (const service of sourceServices) {
            db.prepare(`
                INSERT INTO LoadServices (
                    ConfID, ClassName, ServiceVersion, ServiceName
                ) VALUES (?, ?, ?, ?)
            `).run(
                targetConfId,
                service.ClassName,
                service.ServiceVersion,
                service.ServiceName
            );
        }
    } catch (error) {
        console.error('复制服务失败:', error);
        throw error;
    }
}

// 创建新构型
function createConfiguration(configData) {
  try {
    // 验证必填字段
    const requiredFields = ['ConfName', 'WorkPath', 'DomainID'];
    for (const field of requiredFields) {
      if (!configData[field]) {
        throw new Error(`${field} 是必填字段`);
      }
    }

    const db = getDBConnection();
    
    const result = db.prepare(`
      INSERT INTO Configuration (
        PlaneName, ConfName, OSName, OSVersion, RTXVersion,
        CPUAffinity, WorkPath, ModelsPath, ServicesPath,
        DomainID, ConsoleDebug, ConsoleInfo, ConsoleWarning,
        ConsoleError, LogDebug, LogInfo, LogWarning, LogError
      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
    `).run(
      configData.PlaneName || 'C909',
      configData.ConfName,
      configData.OSName || 'Debian 11',
      configData.OSVersion || '5.10.0-32-rt-amd64',
      configData.RTXVersion || 'preempt-rt',
      configData.CPUAffinity || '0,1',
      configData.WorkPath,
      configData.ModelsPath || 'Models/',
      configData.ServicesPath || 'Services/',
      configData.DomainID,
      configData.ConsoleDebug !== undefined ? configData.ConsoleDebug : 1,
      configData.ConsoleInfo !== undefined ? configData.ConsoleInfo : 1,
      configData.ConsoleWarning !== undefined ? configData.ConsoleWarning : 1,
      configData.ConsoleError !== undefined ? configData.ConsoleError : 1,
      configData.LogDebug !== undefined ? configData.LogDebug : 0,
      configData.LogInfo !== undefined ? configData.LogInfo : 1,
      configData.LogWarning !== undefined ? configData.LogWarning : 1,
      configData.LogError !== undefined ? configData.LogError : 1
    );

    const newConfId = result.lastInsertRowid;

    // 处理数据接口表和复制相关数据
    if (configData.sourceConfId) {
      // 如果有源构型，复制接口表
      copyDataInterfaceTable(configData.sourceConfId, newConfId);
      // 复制模型组和模型
      copyModelGroupsAndModels(configData.sourceConfId, newConfId);
      // 复制服务
      copyServices(configData.sourceConfId, newConfId);
    } else {
      // 如果没有源构型，创建新的接口表
      createDataInterfaceTable(newConfId);
    }
    
    return {
      success: true,
      confId: newConfId,
      message: '构型创建成功'
    };
  } catch (error) {
    console.error('创建构型失败:', error);
    throw error;
  }
}

// 更新构型
function updateConfiguration(configData) {
  try {
    // 验证必填字段
    if (!configData.ConfID) {
      throw new Error('ConfID 是必填字段');
    }

    const db = getDBConnection();
    
    // 检查构型是否存在
    const existingConfig = db.prepare(`
      SELECT COUNT(*) as count FROM Configuration
      WHERE ConfID = ?
    `).get(configData.ConfID);
    
    if (existingConfig.count === 0) {
      throw new Error('要更新的构型不存在');
    }
    
    const result = db.prepare(`
      UPDATE Configuration
      SET PlaneName = ?,
          ConfName = ?,
          OSName = ?,
          OSVersion = ?,
          RTXVersion = ?,
          CPUAffinity = ?,
          WorkPath = ?,
          ModelsPath = ?,
          ServicesPath = ?,
          DomainID = ?,
          ConsoleDebug = ?,
          ConsoleInfo = ?,
          ConsoleWarning = ?,
          ConsoleError = ?,
          LogDebug = ?,
          LogInfo = ?,
          LogWarning = ?,
          LogError = ?
      WHERE ConfID = ?
    `).run(
      configData.PlaneName || 'C909',
      configData.ConfName,
      configData.OSName || 'Debian 11',
      configData.OSVersion || '5.10.0-32-rt-amd64',
      configData.RTXVersion || 'preempt-rt',
      configData.CPUAffinity || '0,1',
      configData.WorkPath,
      configData.ModelsPath || 'Models/',
      configData.ServicesPath || 'Services/',
      configData.DomainID,
      configData.ConsoleDebug !== undefined ? configData.ConsoleDebug : 1,
      configData.ConsoleInfo !== undefined ? configData.ConsoleInfo : 1,
      configData.ConsoleWarning !== undefined ? configData.ConsoleWarning : 1,
      configData.ConsoleError !== undefined ? configData.ConsoleError : 1,
      configData.LogDebug !== undefined ? configData.LogDebug : 0,
      configData.LogInfo !== undefined ? configData.LogInfo : 1,
      configData.LogWarning !== undefined ? configData.LogWarning : 1,
      configData.LogError !== undefined ? configData.LogError : 1,
      configData.ConfID
    );
    
    return {
      success: true,
      changes: result.changes,
      message: '构型更新成功'
    };
  } catch (error) {
    console.error('更新构型失败:', error);
    throw error;
  }
}

// 删除构型
function deleteConfiguration(confId) {
  try {
    const db = getDBConnection();
    
    // 1. 删除构型下的所有服务
    deleteLoadServicesByConf(confId);
    
    // 2. 删除构型下的所有模型组（这会级联删除组下的所有模型）
    deleteLoadModelGroupByConf(confId);
    
    // 3. 删除构型对应的数据接口表
    deleteDataInterfaceTable(confId);
    
    // 4. 最后删除构型本身
    const result = db.prepare('DELETE FROM Configuration WHERE ConfID = ?').run(confId);
    
    return {
      success: true,
      changes: result.changes,
      message: result.changes > 0 ? '构型删除成功' : '构型不存在或已被删除'
    };
  } catch (error) {
    console.error('删除构型失败:', error);
    throw error;
  }
}

/**
 * 获取所有模型组
 * @param {number} confId - 构型ID
 * @returns {Array} 模型组列表
 */
function getLoadModelGroups(confId) {
  try {
    if (!confId) {
      throw new Error('confId 是必填参数');
    }

    const db = getDBConnection(true);
    
    const query = `
      SELECT * FROM LoadModelGroups
      WHERE ConfID = ?
      ORDER BY GroupID ASC
    `;
    
    const groups = db.prepare(query).all(confId);
    
    return groups;
  } catch (error) {
    console.error('获取模型组列表失败:', error);
    throw error;
  }
}

/**
 * 根据ID获取模型组
 * @param {number} groupId - 模型组ID
 * @returns {Object} 模型组信息
 */
function getLoadModelGroupById(groupId) {
  try {
    const db = getDBConnection(true);
    
    const group = db.prepare(`
      SELECT * FROM LoadModelGroups
      WHERE GroupID = ?
    `).get(groupId);
    
    return group;
  } catch (error) {
    console.error(`获取模型组ID ${groupId} 失败:`, error);
    throw error;
  }
}

/**
 * 创建新模型组
 * @param {Object} groupData - 模型组数据
 * @returns {Object} 创建结果
 */
function createLoadModelGroup(groupData) {
  try {
    // 验证必填字段
    const requiredFields = ['ConfID', 'GroupName', 'Freq', 'Priority', 'CPUAff'];
    for (const field of requiredFields) {
      if (!groupData[field]) {
        throw new Error(`${field} 是必填字段`);
      }
    }

    const db = getDBConnection();
    
    const result = db.prepare(`
      INSERT INTO LoadModelGroups (
        ConfID, GroupName, Freq, Priority, CPUAff
      ) VALUES (?, ?, ?, ?, ?)
    `).run(
      groupData.ConfID,
      groupData.GroupName,
      groupData.Freq,
      groupData.Priority,
      groupData.CPUAff
    );
    
    return {
      success: true,
      groupId: result.lastInsertRowid,
      message: '模型组创建成功'
    };
  } catch (error) {
    console.error('创建模型组失败:', error);
    throw error;
  }
}

/**
 * 更新模型组
 * @param {Object} groupData - 模型组数据
 * @returns {Object} 更新结果
 */
function updateLoadModelGroup(groupData) {
  try {
    // 验证必填字段
    if (!groupData.GroupID) {
      throw new Error('GroupID 是必填字段');
    }

    const db = getDBConnection();
    
    // 检查模型组是否存在
    const existingGroup = db.prepare(`
      SELECT COUNT(*) as count FROM LoadModelGroups
      WHERE GroupID = ?
    `).get(groupData.GroupID);
    
    if (existingGroup.count === 0) {
      throw new Error('要更新的模型组不存在');
    }
    
    const result = db.prepare(`
      UPDATE LoadModelGroups
      SET ConfID = ?,
          GroupName = ?,
          Freq = ?,
          Priority = ?,
          CPUAff = ?
      WHERE GroupID = ?
    `).run(
      groupData.ConfID,
      groupData.GroupName,
      groupData.Freq,
      groupData.Priority,
      groupData.CPUAff,
      groupData.GroupID
    );
    
    return {
      success: true,
      changes: result.changes,
      message: '模型组更新成功'
    };
  } catch (error) {
    console.error('更新模型组失败:', error);
    throw error;
  }
}

/**
 * 删除模型组
 * @param {number} groupId - 模型组ID
 * @returns {Object} 删除结果
 */
function deleteLoadModelGroup(groupId) {
  try {
    const db = getDBConnection();
    
    // 1. 先删除组下的所有模型
    deleteLoadModelsByGroup(groupId);
    
    // 2. 再删除模型组本身
    const result = db.prepare('DELETE FROM LoadModelGroups WHERE GroupID = ?').run(groupId);
    
    return {
      success: true,
      changes: result.changes,
      message: result.changes > 0 ? '模型组删除成功' : '模型组不存在或已被删除'
    };
  } catch (error) {
    console.error('删除模型组失败:', error);
    throw error;
  }
}

/**
 * 获取所有模型
 * @param {number} groupId - 模型组ID
 * @returns {Array} 模型列表
 */
function getLoadModels(groupId) {
  try {
    if (!groupId) {
      throw new Error('groupId 是必填参数');
    }

    const db = getDBConnection(true);
    
    const query = `
      SELECT * FROM LoadModels
      WHERE GroupID = ?
      ORDER BY ClassName ASC
    `;
    
    const models = db.prepare(query).all(groupId);
    
    return models;
  } catch (error) {
    console.error('获取模型列表失败:', error);
    throw error;
  }
}

/**
 * 根据组ID和类名获取模型
 * @param {number} groupId - 模型组ID
 * @param {string} className - 类名
 * @returns {Object} 模型信息
 */
function getLoadModelById(groupId, className) {
  try {
    const db = getDBConnection(true);
    
    const model = db.prepare(`
      SELECT * FROM LoadModels
      WHERE GroupID = ? AND ClassName = ?
    `).get(groupId, className);
    
    return model;
  } catch (error) {
    console.error(`获取模型失败 (GroupID: ${groupId}, ClassName: ${className}):`, error);
    throw error;
  }
}

/**
 * 创建新模型
 * @param {Object} modelData - 模型数据
 * @returns {Object} 创建结果
 */
function createLoadModel(modelData) {
  try {
    // 验证必填字段
    const requiredFields = ['GroupID', 'ClassName', 'ModelVersion'];
    for (const field of requiredFields) {
      if (!modelData[field]) {
        throw new Error(`${field} 是必填字段`);
      }
    }

    const db = getDBConnection();
    
    // 检查是否已存在相同的记录
    const existingModel = db.prepare(`
      SELECT COUNT(*) as count FROM LoadModels
      WHERE GroupID = ? AND ClassName = ?
    `).get(modelData.GroupID, modelData.ClassName);
    
    if (existingModel.count > 0) {
      throw new Error('该组中已存在相同类名的模型');
    }
    
    const result = db.prepare(`
      INSERT INTO LoadModels (
        GroupID, ClassName, ModelVersion, ModelName
      ) VALUES (?, ?, ?, ?)
    `).run(
      modelData.GroupID,
      modelData.ClassName,
      modelData.ModelVersion,
      modelData.ModelName || null
    );
    
    return {
      success: true,
      message: '模型创建成功'
    };
  } catch (error) {
    console.error('创建模型失败:', error);
    throw error;
  }
}

/**
 * 更新模型
 * @param {Object} modelData - 模型数据
 * @returns {Object} 更新结果
 */
function updateLoadModel(modelData) {
  try {
    // 验证必填字段
    const requiredFields = ['GroupID', 'ClassName', 'ModelVersion'];
    for (const field of requiredFields) {
      if (!modelData[field]) {
        throw new Error(`${field} 是必填字段`);
      }
    }

    const db = getDBConnection();
    
    // 检查模型是否存在
    const existingModel = db.prepare(`
      SELECT COUNT(*) as count FROM LoadModels
      WHERE GroupID = ? AND ClassName = ?
    `).get(modelData.GroupID, modelData.ClassName);
    
    if (existingModel.count === 0) {
      throw new Error('要更新的模型不存在');
    }
    
    const result = db.prepare(`
      UPDATE LoadModels
      SET ModelVersion = ?,
          ModelName = ?
      WHERE GroupID = ? AND ClassName = ?
    `).run(
      modelData.ModelVersion,
      modelData.ModelName || null,
      modelData.GroupID,
      modelData.ClassName
    );
    
    return {
      success: true,
      changes: result.changes,
      message: '模型更新成功'
    };
  } catch (error) {
    console.error('更新模型失败:', error);
    throw error;
  }
}

/**
 * 删除模型
 * @param {number} groupId - 模型组ID
 * @param {string} className - 类名
 * @returns {Object} 删除结果
 */
function deleteLoadModel(groupId, className) {
  try {
    const db = getDBConnection();
    
    const result = db.prepare(`
      DELETE FROM LoadModels 
      WHERE GroupID = ? AND ClassName = ?
    `).run(groupId, className);
    
    return {
      success: true,
      changes: result.changes,
      message: result.changes > 0 ? '模型删除成功' : '模型不存在或已被删除'
    };
  } catch (error) {
    console.error('删除模型失败:', error);
    throw error;
  }
}

/**
 * 删除组下的所有模型
 * @param {number} groupId - 模型组ID
 * @returns {Object} 删除结果
 */
function deleteLoadModelsByGroup(groupId) {
  try {
    const db = getDBConnection();
    
    const result = db.prepare(`
      DELETE FROM LoadModels 
      WHERE GroupID = ?
    `).run(groupId);
    
    return {
      success: true,
      changes: result.changes,
      message: result.changes > 0 ? '组内所有模型删除成功' : '组内没有模型或已被删除'
    };
  } catch (error) {
    console.error('删除组内模型失败:', error);
    throw error;
  }
}

/**
 * 获取所有服务
 * @param {number} confId - 构型ID
 * @returns {Array} 服务列表
 */
function getLoadServices(confId) {
  try {
    if (!confId) {
      throw new Error('confId 是必填参数');
    }

    const db = getDBConnection(true);
    
    const query = `
      SELECT * FROM LoadServices
      WHERE ConfID = ?
      ORDER BY ClassName ASC
    `;
    
    const services = db.prepare(query).all(confId);
    
    return services;
  } catch (error) {
    console.error('获取服务列表失败:', error);
    throw error;
  }
}

/**
 * 根据构型ID和类名获取服务
 * @param {number} confId - 构型ID
 * @param {string} className - 类名
 * @returns {Object} 服务信息
 */
function getLoadServiceById(confId, className) {
  try {
    const db = getDBConnection(true);
    
    const service = db.prepare(`
      SELECT * FROM LoadServices
      WHERE ConfID = ? AND ClassName = ?
    `).get(confId, className);
    
    return service;
  } catch (error) {
    console.error(`获取服务失败 (ConfID: ${confId}, ClassName: ${className}):`, error);
    throw error;
  }
}

/**
 * 创建新服务
 * @param {Object} serviceData - 服务数据
 * @returns {Object} 创建结果
 */
function createLoadService(serviceData) {
  try {
    // 验证必填字段
    const requiredFields = ['ConfID', 'ClassName', 'ServiceVersion'];
    for (const field of requiredFields) {
      if (!serviceData[field]) {
        throw new Error(`${field} 是必填字段`);
      }
    }

    const db = getDBConnection();
    
    // 检查是否已存在相同的记录
    const existingService = db.prepare(`
      SELECT COUNT(*) as count FROM LoadServices
      WHERE ConfID = ? AND ClassName = ?
    `).get(serviceData.ConfID, serviceData.ClassName);
    
    if (existingService.count > 0) {
      throw new Error('该构型中已存在相同类名的服务');
    }
    
    const result = db.prepare(`
      INSERT INTO LoadServices (
        ConfID, ClassName, ServiceVersion, ServiceName
      ) VALUES (?, ?, ?, ?)
    `).run(
      serviceData.ConfID,
      serviceData.ClassName,
      serviceData.ServiceVersion,
      serviceData.ServiceName || null
    );
    
    return {
      success: true,
      message: '服务创建成功'
    };
  } catch (error) {
    console.error('创建服务失败:', error);
    throw error;
  }
}

/**
 * 更新服务
 * @param {Object} serviceData - 服务数据
 * @returns {Object} 更新结果
 */
function updateLoadService(serviceData) {
  try {
    // 验证必填字段
    const requiredFields = ['ConfID', 'ClassName', 'ServiceVersion'];
    for (const field of requiredFields) {
      if (!serviceData[field]) {
        throw new Error(`${field} 是必填字段`);
      }
    }

    const db = getDBConnection();
    
    // 检查服务是否存在
    const existingService = db.prepare(`
      SELECT COUNT(*) as count FROM LoadServices
      WHERE ConfID = ? AND ClassName = ?
    `).get(serviceData.ConfID, serviceData.ClassName);
    
    if (existingService.count === 0) {
      throw new Error('要更新的服务不存在');
    }
    
    const result = db.prepare(`
      UPDATE LoadServices
      SET ServiceVersion = ?,
          ServiceName = ?
      WHERE ConfID = ? AND ClassName = ?
    `).run(
      serviceData.ServiceVersion,
      serviceData.ServiceName || null,
      serviceData.ConfID,
      serviceData.ClassName
    );
    
    return {
      success: true,
      changes: result.changes,
      message: '服务更新成功'
    };
  } catch (error) {
    console.error('更新服务失败:', error);
    throw error;
  }
}

/**
 * 删除服务
 * @param {number} confId - 构型ID
 * @param {string} className - 类名
 * @returns {Object} 删除结果
 */
function deleteLoadService(confId, className) {
  try {
    const db = getDBConnection();
    
    const result = db.prepare(`
      DELETE FROM LoadServices 
      WHERE ConfID = ? AND ClassName = ?
    `).run(confId, className);
    
    return {
      success: true,
      changes: result.changes,
      message: result.changes > 0 ? '服务删除成功' : '服务不存在或已被删除'
    };
  } catch (error) {
    console.error('删除服务失败:', error);
    throw error;
  }
}

/**
 * 删除构型下的所有服务
 * @param {number} confId - 构型ID
 * @returns {Object} 删除结果
 */
function deleteLoadServicesByConf(confId) {
  try {
    const db = getDBConnection();
    
    const result = db.prepare(`
      DELETE FROM LoadServices 
      WHERE ConfID = ?
    `).run(confId);
    
    return {
      success: true,
      changes: result.changes,
      message: result.changes > 0 ? '构型下所有服务删除成功' : '构型下没有服务或已被删除'
    };
  } catch (error) {
    console.error('删除构型下服务失败:', error);
    throw error;
  }
}

/**
 * 删除构型下的所有模型组
 * @param {number} confId - 构型ID
 * @returns {Object} 删除结果
 */
function deleteLoadModelGroupByConf(confId) {
    try {
        const db = getDBConnection();
        
        // 1. 获取该构型下的所有模型组ID
        const groups = db.prepare(`
            SELECT GroupID FROM LoadModelGroups
            WHERE ConfID = ?
        `).all(confId);
        
        // 2. 删除每个模型组下的所有模型
        for (const group of groups) {
            db.prepare(`
                DELETE FROM LoadModels 
                WHERE GroupID = ?
            `).run(group.GroupID);
        }
        
        // 3. 删除所有模型组
        const result = db.prepare(`
            DELETE FROM LoadModelGroups 
            WHERE ConfID = ?
        `).run(confId);
        
        return {
            success: true,
            changes: result.changes,
            message: result.changes > 0 ? '构型下所有模型组删除成功' : '构型下没有模型组或已被删除'
        };
    } catch (error) {
        console.error('删除构型下模型组失败:', error);
        throw error;
    }
}

module.exports = {
  getConfigurations,
  getConfigurationById,
  createConfiguration,
  updateConfiguration,
  deleteConfiguration,
  getLoadModelGroups,
  getLoadModelGroupById,
  createLoadModelGroup,
  updateLoadModelGroup,
  deleteLoadModelGroup,
  deleteLoadModelGroupByConf,
  getLoadModels,
  getLoadModelById,
  createLoadModel,
  updateLoadModel,
  deleteLoadModel,
  deleteLoadModelsByGroup,
  getLoadServices,
  getLoadServiceById,
  createLoadService,
  updateLoadService,
  deleteLoadService,
  deleteLoadServicesByConf
};