var path = require("path");
// 引入自定义的 DAO 模块，可能包含了对数据库操作的封装
daoModule = require("./DAO");
// 引入位于 modules/database 目录下的数据库模块，使用 path.join 拼接当前工作目录和相对路径
databaseModule = require(path.join(process.cwd(), "modules/database"));

/**
 * 创建管理员
 * 
 * @param {[type]} obj 管理员信息，包含创建管理员所需的信息，如用户名、密码等，具体结构取决于数据库表的设计
 * @param {Function} cb 回调函数，用于处理创建操作的结果
 * 当创建操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null
 */
module.exports.create = function (obj, cb) {
    // 调用 daoModule 的 create 方法，创建 ManagerModel 类型的对象，传入管理员信息和回调函数
    daoModule.create("ManagerModel", obj, cb);
}

/**
 * 获取管理员列表
 * 
 * @param {[type]} conditions 查询条件，用于筛选管理员列表，具体内容根据业务需求而定
 * @param {Function} cb 回调函数，用于处理查询结果
 * 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为查询到的管理员列表
 */
module.exports.list = function (conditions, cb) {
    // 调用 daoModule 的 list 方法，查询 ManagerModel 类型的对象，传入查询条件和自定义的回调函数
    daoModule.list("ManagerModel", conditions, function (err, models) {
        if (err) return cb(err, null);
        cb(null, models);
    });
}

/**
 * 通过查询条件获取管理员对象
 * 
 * @param {[type]} conditions 条件，用于筛选单个管理员，具体内容根据业务需求而定
 * @param {Function} cb 回调函数，用于处理查询结果
 * 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为查询到的管理员对象
 */
module.exports.findOne = function (conditions, cb) {
    // 调用 daoModule 的 findOne 方法，根据条件查询 ManagerModel 类型的对象，传入条件和回调函数
    daoModule.findOne("ManagerModel", conditions, cb);
}

/**
 * 通过关键词查询用户
 * 
 * @param {[type]} key 关键词，用于筛选用户，可能是用户名的一部分等
 * @param {[type]} offset 分页偏移量，用于分页查询，从第几行开始查询
 * @param {[type]} limit 分页限制，每页显示的数量
 * @param {Function} cb 回调函数，用于处理查询结果
 * 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为查询到的管理员列表
 */
module.exports.findByKey = function (key, offset, limit, cb) {
    // 从数据库模块中获取数据库对象
    db = databaseModule.getDatabase();
    // 定义基本的 SQL 查询语句，使用 LEFT JOIN 连接 sp_manager 和 sp_role 表
    sql = "SELECT * FROM sp_manager as mgr LEFT JOIN sp_role as role ON mgr.role_id = role.role_id";
    // 根据是否有关键词进行不同的 SQL 拼接和查询操作
    if (key) {
        // 拼接 LIKE 子句，进行模糊查询，并添加 LIMIT 子句进行分页
        sql += " WHERE mg_name LIKE? LIMIT?,?";
        database.driver.execQuery(
            sql
         , ["%" + key + "%", offset, limit], function (err, managers) {
                if (err) return cb("查询执行出错");
                cb(null, managers);
            });
    } else {
        // 仅添加 LIMIT 子句进行分页
        sql += " LIMIT?,? ";
        database.driver.execQuery(sql, [offset, limit], function (err, managers) {
            if (err) return cb("查询执行出错");
            cb(null, managers);
        });
    }
}

/**
 * 判断是否存在管理员
 * 
 * @param {[type]} username 用户名，用于判断该用户名对应的管理员是否存在
 * @param {Function} cb 回调函数，用于处理查询结果
 * 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为布尔值表示是否存在
 */
module.exports.exists = function (username, cb) {
    // 从数据库模块中获取数据库对象
    var db = databaseModule.getDatabase();
    // 获取 ManagerModel 模型
    var Model = db.models.ManagerModel;
    // 调用 Model 的 exists 方法，传入用户名作为条件，查询是否存在
    Model.exists({"mg_name": username}, function (err, isExists) {
        if (err) return cb("查询失败");
        cb(null, isExists);
    });
}

/**
 * 模糊查询用户数量
 * 
 * @param {[type]} key 关键词，用于模糊查询用户数量，可能是用户名的一部分等
 * @param {Function} cb 回调函数，用于处理查询结果
 * 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为查询到的用户数量
 */
module.exports.countByKey = function (key, cb) {
    // 从数据库模块中获取数据库对象
    db = databaseModule.getDatabase();
    // 定义基本的 SQL 查询语句，统计 sp_manager 表中的记录数
    sql = "SELECT count(*) as count FROM sp_manager";
    // 根据是否有关键词进行不同的 SQL 拼接和查询操作
    if (key) {
        // 拼接 LIKE 子句，进行模糊查询
        sql += " WHERE mg_name LIKE?";
        database.driver.execQuery(
            sql
         , ["%" + key + "%"], function (err, result) {
                if (err) return cb("查询执行出错");
                // 从查询结果中获取数量
                cb(null, result[0]["count"]);
            });
    } else {
        database.driver.execQuery(sql, function (err, result) {
            if (err) return cb("查询执行出错");
            // 从查询结果中获取数量
            cb(null, result[0]["count"]);
        });
    }
}

/**
 * 通过 ID 获取管理员对象数据
 * 
 * @param {[type]} id 管理员主键 ID，用于唯一标识管理员
 * @param {Function} cb 回调函数，用于处理查询结果
 * 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为查询到的管理员对象
 */
module.exports.show = function (id, cb) {
    // 调用 daoModule 的 show 方法，根据 ID 查询 ManagerModel 类型的对象，传入 ID 和回调函数
    daoModule.show("ManagerModel", id, cb);
}

/**
 * 更新管理员信息
 * 
 * @param {[type]} obj 管理员对象，包含更新后的管理员信息，具体结构取决于数据库表的设计
 * @param {Function} cb 回调函数，用于处理更新操作的结果
 * 当更新操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null
 */
module.exports.update = function (obj, cb) {
    // 调用 daoModule 的 update 方法，更新 ManagerModel 类型的对象，传入对象的 mg_id 作为主键和对象信息及回调函数
    daoModule.update("ManagerModel", obj.mg_id, obj, cb);
}

/**
 * 删除管理员对象数据
 * 
 * @param {[type]} id 主键 ID，用于唯一标识要删除的管理员
 * @param {Function} cb 回调函数，用于处理删除操作的结果
 * 当删除操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null
 */
module.exports.destroy = function (id, cb) {
    // 调用 daoModule 的 destroy 方法，根据 ID 删除 ManagerModel 类型的对象，传入 ID 和自定义的回调函数
    daoModule.destroy("ManagerModel", id, function (err) {
        if (err) return cb(err);
        return cb(null);
    });
}

/**
 * 保存管理员信息
 * 
 * @param {[type]} obj 管理员对象，包含管理员信息，具体结构取决于数据库表的设计
 * @param {Function} cb 回调函数，用于处理保存操作的结果
 * 当保存操作完成时调用此函数，根据管理员对象是否有 mg_id 决定是创建新的管理员还是更新现有管理员
 */
module.exports.save = function (obj, cb) {
    // 调用 daoModule 的 show 方法，根据管理员对象的 mg_id 进行查询
    daoModule.show(obj.mg_id, function (err, oldObj) {
        if (err) {
            // 若查询出错，可能是不存在该管理员，调用 create 方法创建新的管理员
            daoModule.create("ManagerModel", obj, cb);
        } else {
            // 若查询成功，调用 update 方法更新现有管理员
            daoModule.update("ManagerModel", obj.mg_id, obj, cb);
        }
    })
}

/**
 * 获取管理员数量
 * 
 * @param {Function} cb 回调函数，用于处理查询结果
 * 当查询操作完成时调用此函数，若出现错误，第一个参数将包含错误信息，若成功，第一个参数为 null，第二个参数为管理员数量
 */
module.exports.count = function (cb) {
    // 调用 daoModule 进行查询，传入 ManagerModel 类型和回调函数，但这里可能存在错误，因为调用方式不完整，应该是调用 daoModule 的某个方法
    daoModule("ManagerModel", cb);
}