// 引入Express框架的核心模块，用于创建Web应用、定义路由以及处理HTTP请求等相关操作
var express = require('express');
// 创建一个Express路由器实例，方便以模块化的方式来定义一组相关的路由，便于在整个应用中进行有条理的路由管理
var router = express.Router();
// 引入Node.js的path模块，主要用于处理文件路径相关的操作，例如拼接、解析文件路径等，以便准确地引入其他模块
var path = require("path");

// 获取自定义的验证模块，通过path.join方法将当前工作目录（process.cwd()）与相对路径（"/modules/authorization"）拼接起来，准确地引入该验证模块
// 这个验证模块通常用于验证用户的权限等情况，确保后续操作符合相应的安全和业务规则
var authorization = require(path.join(process.cwd(), "/modules/authorization"));

// 通过验证模块获取名为"ManagerService"的用户管理服务对象，该模块应该封装了与用户相关的各种业务操作方法，例如用户的增删改查、角色分配以及状态更新等功能
var mgrServ = authorization.getService("ManagerService");

// 定义处理查询用户列表的GET请求的路由，路径为根路径 "/"
router.get("/",
    // 第一个中间件函数，用于对请求中的查询参数进行验证，确保传入的参数符合业务要求，保证后续业务逻辑能正确执行
    function (req, res, next) {
        // 验证pagenum参数是否存在且大于0，如果该参数不存在或者小于等于0，则返回错误响应，状态码400表示请求参数有误，并附带相应的错误提示信息"pagenum 参数错误"
        if (!req.query.pagenum || req.query.pagenum <= 0) return res.sendResult(null, 400, "pagenum 参数错误");
        // 验证pagesize参数是否存在且大于0，如果该参数不存在或者小于等于0，则返回错误响应，状态码400表示请求参数有误，并附带相应的错误提示信息"pagesize 参数错误"
        if (!req.query.pagesize || req.query.pagesize <= 0) return res.sendResult(null, 400, "pagesize 参数错误");
        // 参数验证通过后，调用next()函数将控制权传递给下一个中间件或者路由处理函数，以便继续执行后续的业务逻辑
        next();
    },
    // 第二个中间件函数，用于处理查询用户列表的实际业务逻辑，依赖于前面验证通过的参数进行相应操作
    function (req, res, next) {
        // 调用mgrServ用户管理服务对象的getAllManagers方法，传入一个包含查询条件的对象，其中包括模糊查询的内容（query）以及分页相关的参数（pagenum和pagesize），用于获取符合条件的用户列表数据。
        // 这个方法执行的是异步操作，在操作过程中如果出现错误（err不为null），就通过res.sendResult返回包含错误信息的响应，状态码设置为400，表示请求处理出现错误。
        // 如果获取用户列表操作成功，就使用res.sendResult返回包含用户列表数据（result）的响应，状态码为200，表示请求成功，同时附带提示信息"获取管理员列表成功"，告知客户端操作顺利完成
        mgrServ.getAllManagers(
            {
                "query": req.query.query,
                "pagenum": req.query.pagenum,
                "pagesize": req.query.pagesize
            },
            function (err, result) {
                if (err) return res.sendResult(null, 400, err);
                res.sendResult(result, 200, "获取管理员列表成功");
            }
        )(req, res, next);

    }
);

// 定义处理获取用户信息的GET请求的路由，路径中包含用户ID参数，格式为 "/:id"
router.get("/:id",
    // 第一个中间件函数，主要用于对路由参数进行验证，确保传入的用户ID参数符合业务要求，保证后续业务逻辑能正确执行
    function (req, res, next) {
        // 检查请求参数中的用户ID（req.params.id）是否存在，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"用户ID不能为空"
        if (!req.params.id) {
            return res.sendResult(null, 400, "用户ID不能为空");
        }
        // 进一步验证用户ID是否可以转换为数字类型，如果不能转换成功（即不是有效的数字），则返回错误响应，状态码同样为400，并附带提示信息"用户ID必须是数字"
        if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "用户ID必须是数字");
        // 如果参数验证通过，就调用next()函数，将控制权传递给下一个中间件或者路由处理函数，以便继续执行后续的业务逻辑
        next();
    },
    // 第二个中间件函数，用于处理获取指定用户信息的实际业务逻辑，依赖于前面验证通过的用户ID参数进行相应操作
    function (req, res, next) {
        // 调用mgrServ用户管理服务对象的getManager方法，传入经过验证的用户ID（req.params.id），用于获取该用户的详细信息。
        // 这个方法执行的是异步操作，在操作过程中如果出现错误（err不为null），就通过res.sendResult返回包含错误信息的响应，状态码设置为400，表示请求处理出现错误。
        // 如果获取用户信息操作成功，就使用res.sendResult返回包含用户详细信息（manager）的响应，状态码为200，表示请求成功，同时附带提示信息"获取成功"，告知客户端操作顺利完成
        mgrServ.getManager(req.params.id, function (err, manager) {
            if (err) return res.sendResult(null, 400, err);
            res.sendResult(manager, 200, "获取成功");
        })(req, res, next);
    }
);

// 定义处理创建用户的POST请求的路由，路径为 "/"
router.post("/",
    // 第一个中间件函数，用于对创建用户时请求体中的必要参数进行验证，确保传入的参数符合业务要求，保证后续业务逻辑能正确执行
    function (req, res, next) {
        // 检查请求体中是否包含username字段，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"用户名不能为空"
        if (!req.body.username) {
            return res.sendResult(null, 400, "用户名不能为空");
        }
        // 检查请求体中是否包含password字段，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"密码不能为空"
        if (!req.body.password) {
            return res.sendResult(null, 400, "密码不能为空");
        }
        // 检查请求体中是否包含rid字段，如果不存在则将其默认设置为 -1，此处原代码有部分注释掉的返回错误逻辑，可能根据实际情况调整过，目前是默认赋值
        if (!req.body.rid) {
            req.body.rid = -1;
            // return res.sendResult(null, 200, "角色ID不能为空");
        }
        // 进一步验证rid字段是否可以转换为数字类型，如果不能转换成功（即不是有效的数字），则将其默认设置为 -1，此处原代码也有部分注释掉的返回错误逻辑，目前是默认赋值处理
        if (isNaN(parseInt(req.body.rid))) req.body.rid = -1; // return res.sendResult(null, 200, "角色ID必须是数字");
        // 参数验证通过后，调用next()函数将控制权传递给下一个中间件或者路由处理函数，以便继续执行后续的业务逻辑
        next();
    },
    // 第二个中间件函数，用于处理创建用户的实际业务逻辑，依赖于前面验证通过的请求体参数进行相应操作
    function (req, res, next) {
        // 构建一个包含创建用户所需信息的对象，从请求体中获取相应的值，如用户名（username）、密码（password）、手机号（mobile）、邮箱（email）以及角色ID（rid）等信息
        params = {
            "username": req.body.username,
            "password": req.body.password,
            "mobile": req.body.mobile,
            "email": req.body.email,
            "rid": req.body.rid
        }
        // 调用mgrServ用户管理服务对象的createManager方法，传入构建好的用户信息对象，用于创建新的用户。
        // 这个方法执行的是异步操作，在操作过程中如果出现错误（err不为null），就通过res.sendResult返回包含错误信息的响应，状态码设置为400，表示请求处理出现错误。
        // 如果创建用户操作成功，就使用res.sendResult返回包含新创建用户信息（manager）的响应，状态码为201，表示资源创建成功，同时附带提示信息"创建成功"，告知客户端操作顺利完成
        mgrServ.createManager(params, function (err, manager) {
            if (err) return res.sendResult(null, 400, err);
            res.sendResult(manager, 201, "创建成功");
        })(req, res, next);
    }
);

// 定义处理修改用户信息的PUT请求的路由，路径中包含用户ID参数，格式为 "/:id"
router.put("/:id",
    // 第一个中间件函数，用于对修改用户信息时请求中的必要参数进行验证，确保传入的用户ID参数符合业务要求，保证后续业务逻辑能正确执行
    function (req, res, next) {
        // 检查请求参数中的用户ID（req.params.id）是否存在，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"用户ID不能为空"
        if (!req.params.id) {
            return res.sendResult(null, 400, "用户ID不能为空");
        }
        // 进一步验证用户ID是否可以转换为数字类型，如果不能转换成功（即不是有效的数字），则返回错误响应，状态码同样为400，并附带提示信息"用户ID必须是数字"
        if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "用户ID必须是数字");
        // 参数验证通过后，调用next()函数将控制权传递给下一个中间件或者路由处理函数，以便继续执行后续的业务逻辑
        next();
    },
    // 第二个中间件函数，用于处理修改用户信息的实际业务逻辑，依赖于前面验证通过的用户ID参数以及请求体中的其他信息进行相应操作
    function (req, res, next) {
        // 构建一个包含要修改的用户信息的对象，包括用户ID（id）以及要更新的手机号（mobile）和邮箱（email）等信息，从请求体和请求参数中获取相应的值
        mgrServ.updateManager(
            {
                "id": req.params.id,
                "mobile": req.body.mobile,
                "email": req.body.email
            },
            function (err, manager) {
                // 这个方法执行的是异步操作，在操作过程中如果出现错误（err不为null），就通过res.sendResult返回包含错误信息的响应，状态码设置为400，表示请求处理出现错误。
                // 如果修改用户信息操作成功，就使用res.sendResult返回包含修改后用户信息（manager）的响应，状态码为200，表示请求成功，同时附带提示信息"更新成功"，告知客户端操作顺利完成
                if (err) return res.sendResult(null, 400, err);
                res.sendResult(manager, 200, "更新成功");
            }
        )(req, res, next);
    }
);

// 定义处理删除用户信息的DELETE请求的路由，路径中包含用户ID参数，格式为 "/:id"
router.delete("/:id",
    // 第一个中间件函数，用于对删除用户信息时请求中的必要参数进行验证，确保传入的用户ID参数符合业务要求，保证后续业务逻辑能正确执行
    function (req, res, next) {
        // 检查请求参数中的用户ID（req.params.id）是否存在，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"用户ID不能为空"
        if (!req.params.id) return res.sendResult(null, 400, "用户ID不能为空");
        // 进一步验证用户ID是否可以转换为数字类型，如果不能转换成功（即不是有效的数字），则返回错误响应，状态码同样为400，并附带提示信息"ID必须是数字"
        if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "ID必须是数字");
        // 特别地，对于用户ID为500的情况（可能是特殊的admin账户），不允许删除，直接返回错误响应，状态码为400，并附带提示信息"不允许删除admin账户"
        if (req.params.id == 500) return res.sendResult(null, 400, "不允许删除admin账户");
        // 参数验证通过后，调用next()函数将控制权传递给下一个中间件或者路由处理函数，以便继续执行后续的业务逻辑
        next();
    },
    // 第二个中间件函数，用于处理删除用户信息的实际业务逻辑，依赖于前面验证通过的用户ID参数进行相应操作
    function (req, res, next) {
        // 调用mgrServ用户管理服务对象的deleteManager方法，传入经过验证的用户ID（req.params.id），用于删除该用户的信息。
        // 这个方法执行的是异步操作，在操作过程中如果出现错误（err不为null），就通过res.sendResult返回包含错误信息的响应，状态码设置为400，表示请求处理出现错误。
        // 如果删除用户信息操作成功，就使用res.sendResult返回一个空数据的响应（因为用户信息已被删除），状态码为200，表示请求成功，同时附带提示信息"删除成功"，告知客户端操作顺利完成
        mgrServ.deleteManager(req.params.id, function (err) {
            if (err) return res.sendResult(null, 400, err);
            return res.sendResult(null, 200, "删除成功");
        })(req, res, next);
    }
);

// 定义处理分配用户角色的PUT请求的路由，路径中包含用户ID和角色相关的路径参数，格式为 "/:id/role"
router.put("/:id/role",
    // 第一个中间件函数，用于对分配用户角色时请求中的必要参数进行验证，确保传入的参数符合业务要求，保证后续业务逻辑能正确执行
    function (req, res, next) {
        // 检查请求参数中的用户ID（req.params.id）是否存在，如果不存在则返回错误响应，状态码400表示请求参数有误，同时附带提示信息"用户ID不能为空"
        if (!req.params.id) {
            return res.sendResult(null, 400, "用户ID不能为空");
        }
        // 进一步验证用户ID是否可以转换为数字类型，如果不能转换成功（即不是有效的数字），则返回错误响应，状态码同样为400，并附带提示信息"用户ID必须是数字"
        if (isNaN(parseInt(req.params.id))) return res.sendResult(null, 400, "用户ID必须是数字");
        // 对于用户ID为500的情况（可能是特殊的admin账户），不允许修改角色，直接返回错误响应，状态码为400，并附带提示信息"不允许修改admin账户"
        if (req.params.id == 500) return res.sendResult(null, 400, "不允许修改admin账户");
        // 检查请求体中是否包含rid字段，如果不存在则返回错误响应，状态码400，表示请求参数有误，同时附带提示信息"权限ID不能为空"
        if (!req.body.rid) res.sendResult(null, 400, "权限ID不能为空");
        // 参数验证通过后，调用next()函数将控制权传递给下一个中间件或者路由处理函数，以便继续执行后续的业务逻辑
        next();
    },
    // 第二个中间件函数，用于处理分配用户角色的实际业务逻辑，依赖于前面验证通过的用户ID和请求体中的角色ID参数进行相应操作
    function (req, res, next) {
        // 调用mgrServ用户管理服务对象的setRole方法，传入经过验证的用户ID（req.params.id）和角色ID（req.body.rid），用于为用户设置相应的角色。
        // 这个方法执行的是异步操作，在操作过程中如果出现错误（err不为null），就通过res.sendResult返回包含错误信息的响应，状态码设置为400，表示请求处理出现错误。
        // 如果分配用户角色操作成功，就使用res.sendResult返回包含更新后用户信息（manager）的响应，状态码为200，表示请求成功，同时附带提示信息"设置角色成功"，告知客户端操作顺利完成
        mgrServ.setRole(req.params.id, req.body.rid, function (err, manager) {
            if (err) return res.sendResult(null, 400, err);
            res.sendResult(manager, 200, "设置角色成功");
        })(req, res, next);
    }
);

// 定义处理更新用户状态的PUT请求的路由，路径中包含用户ID和状态相关的路径参数，格式为 "/:id/state/:state"
router.put("/:id/state/:state",
    // 第一个中间件函数，用于对更新用户状态时请求中的必要参数进行验证，确保传入的参数符合业务要求，保证后续业务逻辑能正确
	// 参数验证
	function(req,res,next) {
		if(!req.params.id) {
			return res.sendResult(null,400,"用户ID不能为空");
		}
		if(isNaN(parseInt(req.params.id))) return res.sendResult(null,400,"用户ID必须是数字");

		// // // if(!req.params.state) {
		// // // 	return res.sendResult(null,400,"状态不能为空");
		// // // }
		// // if(isNaN(parseInt(req.params.state))) return res.sendResult(null,400,"状态必须是数字");
		// if(parseInt(req.params.state) != 0 && parseInt(req.params.state) != 1) return res.sendResult(null,400,"管理状态只能为0或1");

		next();
	},
	// 处理业务逻辑
	function(req,res,next) {
		state = 0
		if(req.params.state && req.params.state == "true") state = 1
		mgrServ.updateMgrState(req.params.id,state,function(err,manager){
			if(err) return res.sendResult(null,400,err);
			res.sendResult(manager,200,"设置状态成功");
		})(req,res,next);
	}
	)

module.exports = router;