package com.jeesite.modules.mes.web;

import com.jeesite.common.config.Global;
import com.jeesite.common.collect.ListUtils;
import com.jeesite.common.entity.Page;
import com.jeesite.common.lang.DateUtils;
import com.jeesite.common.lang.StringUtils;
import com.jeesite.common.mybatis.mapper.query.QueryType;
import com.jeesite.common.service.ServiceException;
import com.jeesite.common.utils.excel.ExcelExport;
import com.jeesite.common.utils.excel.ExcelImport;
import com.jeesite.common.utils.excel.annotation.ExcelField.Type;
import com.jeesite.common.web.BaseController;
import com.jeesite.modules.mes.entity.excel.ExcelEmpUserEmployee;
import com.jeesite.modules.mes.entity.MesEmployee;
import com.jeesite.modules.mes.service.MesEmployeeService;
import com.jeesite.modules.sys.entity.EmpUser;
import com.jeesite.modules.sys.entity.*;
import com.jeesite.modules.sys.service.EmployeeService;
import com.jeesite.modules.sys.service.EmpUserService;
import com.jeesite.modules.sys.service.UserService;
import com.jeesite.modules.sys.utils.UserUtils;
import com.jeesite.modules.sys.web.user.EmpUserController;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.List;

@Controller
@RequestMapping(value = "${adminPath}/mes/empUserCustom")
public class EmpUserCustomController extends BaseController {

    @Autowired
    private EmpUserController empUserController;

    @Autowired
    private EmpUserService empUserService;

    @Autowired
    private UserService userService;

    @Autowired
    private MesEmployeeService mesEmployeeService;

    @Autowired
    private EmployeeService employeeService;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @ModelAttribute
    public EmpUser get(String userCode, boolean isNewRecord) {
        return empUserService.get(userCode, isNewRecord);
    }

    @RequestMapping(value = "form")
    public String form(EmpUser empUser, String op, Model model) {
        if ("copy".equals(op)) {
            // 借用原生的 form 方法，获取全量数据（包括岗位、机构、角色）
            String view = empUserController.form(empUser, "edit", model);

            EmpUser fullUser = (EmpUser) model.asMap().get("empUser");
            if (fullUser != null) {
                // 将原记录转化为新记录
                fullUser.setIsNewRecord(true);
                fullUser.setUserCode(null);

                // 转换员工及附属机构的主键
                if (fullUser.getEmployee() != null) {
                    fullUser.getEmployee().setIsNewRecord(true);
                    fullUser.getEmployee().setEmpCode(null);

                    List<EmployeeOffice> officeList = fullUser.getEmployee().getEmployeeOfficeList();
                    if (officeList != null && !officeList.isEmpty()) {
                        for (EmployeeOffice eo : officeList) {
                            eo.setIsNewRecord(true);
                            eo.setId(null);
                        }
                    }
                }

                // 处理角色回显
                List<Role> roleList = fullUser.getRoleList();
                if (roleList != null && !roleList.isEmpty()) {
                    List<String> roleCodes = new ArrayList<>();
                    for (Role role : roleList) {
                        roleCodes.add(role.getRoleCode());
                    }
                    fullUser.setUserRoleString(StringUtils.join(roleCodes, ","));
                }

                // 覆盖 Model 中的对象并注入角色列表和操作标识
                model.addAttribute("empUser", fullUser);
                model.addAttribute("roleList", roleList);
                model.addAttribute("op", "add");
            }

            // 注入自定义保存脚本，修改表单 action 为我们自己的 save
            String customSaveScript = "<script>" +
                    "$(function(){" +
                    "  var overrideAction = function() {" +
                    "      var form = $('#inputForm');" +
                    "      if(form.length > 0 && form.attr('action').indexOf('/mes/empUserCustom/save') === -1) {" +
                    "          form.attr('action', '" + Global.getAdminPath() + "/mes/empUserCustom/save');" +
                    "      }" +
                    "  };" +
                    "  overrideAction();" +
                    "  setInterval(overrideAction, 500);" +
                    "});" +
                    "</script>";
            model.addAttribute("customSaveScript", customSaveScript);

            // 为了防止 customSaveScript 没有被模板渲染，我们利用 extend 字段进行 XSS 注入（JeeSite 中扩展字段常用于透传）
            // 或者更安全的做法，只需 model 传参。这里保留之前的做法。

            return view;
        }

        String view = empUserController.form(empUser, op, model);
        applyEmployeePostName(model);
        return view;
    }

    @RequestMapping(value = "save")
    @ResponseBody
    public String save(EmpUser empUser, String oldLoginCode, HttpServletRequest request) {
        String loginCode = StringUtils.trim(empUser.getLoginCode());
        empUser.setLoginCode(loginCode);
        if (StringUtils.isBlank(loginCode)) {
            return renderResult(Global.FALSE, "保存用户失败，登录账号不能为空。");
        }
        if (loginCode.length() < 2) {
            return renderResult(Global.FALSE, "保存用户失败，登录账号至少输入 2 个字符。");
        }
        if (empUser.getEmployee() == null || StringUtils.isBlank(empUser.getEmployee().getEmpNo())) {
            return renderResult(Global.FALSE, "保存用户失败，员工工号不能为空。");
        }
        if (empUser.getEmployee() == null || StringUtils.isBlank(empUser.getEmployee().getEmpName())) {
            return renderResult(Global.FALSE, "保存用户失败，员工姓名不能为空。");
        }

        // 新增时若登录账号残留软删记录：先硬删残留，再按新增保存（不再做恢复）
        if (empUser.getIsNewRecord() || StringUtils.isBlank(empUser.getUserCode())) {
            User existByLogin = findUserByLoginCodeIncludeDeleted(loginCode);
            if (existByLogin != null) {
                if (User.STATUS_DELETE.equals(existByLogin.getStatus())) {
                    phyDeleteUserByCode(existByLogin.getUserCode());
                } else if (!StringUtils.equals(existByLogin.getUserCode(), empUser.getUserCode())) {
                    return renderResult(Global.FALSE, "保存用户失败，登录账号已存在，请修改登录账号！");
                }
            }
        }

        EmpUser existUser = new EmpUser();
        existUser.setLoginCode(loginCode);
        List<EmpUser> uList = empUserService.findList(existUser);
        if (hasOtherUser(uList, empUser.getUserCode())) {
            return renderResult(Global.FALSE, "保存用户失败，登录账号已存在（不能与原账号相同），请修改登录账号！");
        }

        if (StringUtils.isNotBlank(empUser.getUserName())) {
            EmpUser where = new EmpUser();
            where.setUserName(empUser.getUserName());
            List<EmpUser> list = empUserService.findList(where);
            if (hasOtherUser(list, empUser.getUserCode())) {
                return renderResult(Global.FALSE, "保存用户失败，用户昵称已存在（不能与原昵称相同），请修改用户昵称！");
            }
        }

        if (StringUtils.isBlank(empUser.getUserType())) {
            empUser.setUserType("employee");
        }
        MesEmployee selectedEmployee = findSelectedEmployee(empUser);
        String selectedEmployeeError = checkSelectedEmployee(empUser, selectedEmployee);
        if (StringUtils.isNotBlank(selectedEmployeeError)) {
            return renderResult(Global.FALSE, selectedEmployeeError);
        }
        if (selectedEmployee != null) {
            User boundUser = findBoundUser(selectedEmployee);
            if (boundUser != null
                    && (StringUtils.isBlank(empUser.getUserCode())
                    || !StringUtils.equals(boundUser.getUserCode(), empUser.getUserCode()))) {
                // 若绑定的是软删残留账号，硬删后允许重新开户
                if (User.STATUS_DELETE.equals(boundUser.getStatus())) {
                    phyDeleteUserByCode(boundUser.getUserCode());
                } else {
                    return renderResult(Global.FALSE, "保存用户失败，该员工已创建账号：" + boundUser.getLoginCode());
                }
            }
            bindSelectedEmployeeUser(empUser, selectedEmployee);
            userService.save(empUser);
            if (shouldSaveAuth(request)) {
                userService.saveAuth(empUser);
            }
            return renderResult(Global.TRUE, "保存用户 '" + empUser.getLoginCode() + "' 成功");
        }
        String result = empUserController.save(empUser, oldLoginCode, request);
        saveRolesOnEdit(empUser, request, result);
        return result;
    }

    /**
     * 删除用户：物理删除账号、授权，并同步硬删员工档案
     */
    @RequestMapping(value = "delete")
    @ResponseBody
    public String delete(EmpUser empUser) {
        if (empUser == null || StringUtils.isBlank(empUser.getUserCode())) {
            return renderResult(Global.FALSE, text("删除用户失败，用户编码不能为空！"));
        }
        EmpUser dbUser = empUserService.get(empUser.getUserCode());
        if (dbUser == null) {
            // 可能已被软删，按编码直接硬删残留
            phyDeleteUserAndEmployee(empUser.getUserCode(), null);
            return renderResult(Global.TRUE, text("删除用户成功"));
        }
        String loginCode = dbUser.getLoginCode();
        String empCode = StringUtils.defaultIfBlank(dbUser.getRefCode(),
                dbUser.getEmployee() != null ? dbUser.getEmployee().getEmpCode() : null);
        phyDeleteUserAndEmployee(dbUser.getUserCode(), empCode);
        UserUtils.clearCache(dbUser);
        return renderResult(Global.TRUE, text("删除用户''{0}''成功", loginCode));
    }

    /**
     * 登录账号远程校验
     */
    @RequestMapping(value = "checkLoginCode")
    @ResponseBody
    public String checkLoginCode(String oldLoginCode, String loginCode) {
        loginCode = StringUtils.trim(loginCode);
        if (StringUtils.isBlank(loginCode)) {
            return "true";
        }
        if (StringUtils.isNotBlank(oldLoginCode) && StringUtils.equals(oldLoginCode, loginCode)) {
            return "true";
        }
        User exists = findUserByLoginCodeIncludeDeleted(loginCode);
        if (exists == null) {
            return "true";
        }
        // 软删残留视为可用（保存时会硬删残留后新建）
        if (User.STATUS_DELETE.equals(exists.getStatus())) {
            return "true";
        }
        return "false";
    }

    @RequestMapping(value = "listData")
    @ResponseBody
    public Page<EmpUser> listData(EmpUser empUser, Boolean isAll, String ctrlPermi, String ctrlPermiFilter,
                                  HttpServletRequest request, HttpServletResponse response) {
        applyOfficeTreeFilter(empUser, Boolean.TRUE.equals(isAll));
        empUser.setPage(new Page<>(request, response));
        return empUserService.findPage(empUser);
    }

    private void applyOfficeTreeFilter(EmpUser empUser, boolean isAll) {
        if (isAll) {
            return;
        }
        User currentUser = UserUtils.getUser();
        if (currentUser == null || currentUser.isSuperAdmin()) {
            return;
        }
        if (empUser.getEmployee() != null && empUser.getEmployee().getCompany() != null) {
            empUser.getEmployee().getCompany().setIsQueryChildren(true);
        }
        Office office = empUser.getEmployee() == null ? null : empUser.getEmployee().getOffice();
        String officeCode = office == null ? null : office.getOfficeCode();
        if (office != null) {
            office.setIsQueryChildren(true);
        }

        if (StringUtils.isNotBlank(officeCode) && !isTopOffice(officeCode)) {
            List<String> officeCodes = findPermittedOfficeCodes(currentUser.getUserCode(), officeCode);
            if (officeCodes.isEmpty()) {
                officeCodes.add("__NO_AUTH_OFFICE__");
            }
            empUser.getSqlMap().getWhere().and("o.office_code", QueryType.IN, officeCodes.toArray(new String[0]));
            return;
        }

        List<String> officeCodes = findPermittedOfficeCodes(currentUser.getUserCode(), officeCode);
        if (officeCodes.isEmpty()) {
            officeCodes.add("__NO_AUTH_OFFICE__");
        }
        empUser.getSqlMap().getWhere().and("o.office_code", QueryType.IN, officeCodes.toArray(new String[0]));
        if (office != null) {
            office.setOfficeCode(null);
        }
    }

    private boolean isTopOffice(String officeCode) {
        try {
            String parentCode = jdbcTemplate.queryForObject(
                    "select parent_code from js_sys_office where office_code = ?",
                    String.class, officeCode);
            return StringUtils.isBlank(parentCode) || "0".equals(parentCode);
        } catch (EmptyResultDataAccessException ex) {
            return false;
        }
    }

    private List<String> findPermittedOfficeCodes(String userCode, String rootOfficeCode) {
        if (StringUtils.isBlank(userCode)) {
            return ListUtils.newArrayList();
        }
        boolean selectedTopOffice = StringUtils.isNotBlank(rootOfficeCode) && isTopOffice(rootOfficeCode);
        if (StringUtils.isBlank(rootOfficeCode) || selectedTopOffice) {
            List<String> officeCodes = queryPermittedOfficeCodes(userCode, rootOfficeCode, true);
            if (!officeCodes.isEmpty()) {
                return officeCodes;
            }
        } else if (!queryPermittedOfficeCodes(userCode, null, true).isEmpty()) {
            return queryPermittedOfficeCodes(userCode, rootOfficeCode, true);
        }
        return queryPermittedOfficeCodes(userCode, rootOfficeCode, false);
    }

    private List<String> queryPermittedOfficeCodes(String userCode, String rootOfficeCode, boolean onlySpecificScopes) {
        List<Object> params = ListUtils.newArrayList();
        StringBuilder sql = new StringBuilder();
        sql.append("select distinct o.office_code ");
        sql.append("from js_sys_office o ");
        sql.append("where 1 = 1 ");
        if (StringUtils.isNotBlank(rootOfficeCode)) {
            sql.append("and (o.office_code = ? or o.parent_codes like concat('%,', ?, ',%')) ");
            params.add(rootOfficeCode);
            params.add(rootOfficeCode);
        }
        sql.append("and exists (");
        sql.append("  select 1 from (");
        sql.append("    select rds.ctrl_data from js_sys_role_data_scope rds ");
        sql.append("    join js_sys_user_role ur on ur.role_code = rds.role_code ");
        sql.append("    where ur.user_code = ? and rds.ctrl_type = 'Office' and rds.ctrl_permi = '1' ");
        sql.append("    union ");
        sql.append("    select uds.ctrl_data from js_sys_user_data_scope uds ");
        sql.append("    where uds.user_code = ? and uds.ctrl_type = 'Office' and uds.ctrl_permi = '1' ");
        sql.append("  ) ds ");
        sql.append("  join js_sys_office so on so.office_code = ds.ctrl_data ");
        sql.append("  where (o.office_code = ds.ctrl_data or o.parent_codes like concat('%,', ds.ctrl_data, ',%')) ");
        params.add(userCode);
        params.add(userCode);
        if (onlySpecificScopes) {
            if (StringUtils.isBlank(rootOfficeCode)) {
                sql.append("  and so.parent_code is not null and so.parent_code <> '0' ");
            } else if (!isTopOffice(rootOfficeCode)) {
                sql.append("  and so.parent_code is not null and so.parent_code <> '0' ");
            } else {
                sql.append("  and ds.ctrl_data <> ? and so.parent_codes like concat('%,', ?, ',%') ");
                params.add(rootOfficeCode);
                params.add(rootOfficeCode);
            }
        } else if (StringUtils.isNotBlank(rootOfficeCode)) {
            sql.append("  and exists (");
            sql.append("    select 1 from js_sys_office selected ");
            sql.append("    where selected.office_code = ? ");
            sql.append("    and (so.office_code = selected.office_code ");
            sql.append("      or so.parent_codes like concat('%,', selected.office_code, ',%') ");
            sql.append("      or selected.parent_codes like concat('%,', so.office_code, ',%'))");
            sql.append("  ) ");
            params.add(rootOfficeCode);
        }
        sql.append(")");
        return jdbcTemplate.queryForList(sql.toString(), String.class, params.toArray());
    }

    private boolean shouldSaveAuth(HttpServletRequest request) {
        return "auth".equals(request.getParameter("op")) || request.getParameterMap().containsKey("userRoleString");
    }

    /**
     * 编辑用户时原生保存不会写角色，这里在保存成功后补写。
     */
    private void saveRolesOnEdit(EmpUser empUser, HttpServletRequest request, String result) {
        if (!"edit".equals(request.getParameter("op"))) {
            return;
        }
        if (!shouldSaveAuth(request) || !isSuccessResult(result)) {
            return;
        }
        if (UserUtils.getSubject() == null || !UserUtils.getSubject().isPermitted("sys:empUser:authRole")) {
            return;
        }
        userService.saveAuth(empUser);
    }

    private boolean isSuccessResult(String result) {
        if (StringUtils.isBlank(result)) {
            return false;
        }
        return StringUtils.contains(result, "\"result\":\"" + Global.TRUE + "\"")
                || StringUtils.contains(result, "'result':'" + Global.TRUE + "'");
    }

    @RequestMapping(value = "exportData")
    public void exportData(EmpUser empUser, String ctrlPermi, String ctrlPermiFilter, HttpServletResponse response) {
        applyOfficeTreeFilter(empUser, false);
        List<ExcelEmpUserEmployee> list = ListUtils.newArrayList();
        for (EmpUser user : empUserService.findList(empUser)) {
            list.add(toExcel(user));
        }
        String fileName = "\u7528\u6237\u5458\u5de5\u6570\u636e" + DateUtils.getDate("yyyyMMddHHmmss") + ".xlsx";
        try (ExcelExport ee = new ExcelExport("\u7528\u6237\u5458\u5de5\u6570\u636e", ExcelEmpUserEmployee.class)) {
            ee.setDataList(list).write(response, fileName);
        }
    }

    @RequestMapping(value = "importTemplate")
    public void importTemplate(HttpServletResponse response) {
        List<ExcelEmpUserEmployee> list = ListUtils.newArrayList(new ExcelEmpUserEmployee());
        String fileName = "\u7528\u6237\u5458\u5de5\u6570\u636e\u6a21\u677f.xlsx";
        try (ExcelExport ee = new ExcelExport("\u7528\u6237\u5458\u5de5\u6570\u636e", ExcelEmpUserEmployee.class, Type.IMPORT)) {
            ee.setDataList(list).write(response, fileName);
        }
    }

    @PostMapping(value = "importData")
    @ResponseBody
    public String importData(MultipartFile file, String updateSupport) {
        try {
            String message = importUserEmployeeData(file, "1".equals(updateSupport));
            return renderResult(Global.TRUE, "posfull:" + message);
        } catch (Exception ex) {
            return renderResult(Global.FALSE, "posfull:" + ex.getMessage());
        }
    }

    private String importUserEmployeeData(MultipartFile file, boolean updateSupport) {
        if (file == null) {
            throw new ServiceException("\u8bf7\u9009\u62e9\u5bfc\u5165\u7684\u6570\u636e\u6587\u4ef6\uff01");
        }
        int successNum = 0;
        int failureNum = 0;
        StringBuilder successMsg = new StringBuilder();
        StringBuilder failureMsg = new StringBuilder();
        try (ExcelImport ei = new ExcelImport(file, 2, 0)) {
            List<ExcelEmpUserEmployee> list = ei.getDataList(ExcelEmpUserEmployee.class);
            for (ExcelEmpUserEmployee item : list) {
                try {
                    EmpUser empUser = buildImportUser(item, updateSupport);
                    userService.save(empUser);
                    if (StringUtils.isNotBlank(item.getUserRoleString())) {
                        userService.saveAuth(empUser);
                    }
                    successNum++;
                    successMsg.append("<br/>").append(successNum).append("\u3001\u8d26\u53f7 ")
                            .append(item.getLoginCode()).append(" \u5bfc\u5165\u6210\u529f");
                } catch (Exception e) {
                    failureNum++;
                    String msg = "<br/>" + failureNum + "\u3001\u8d26\u53f7 "
                            + StringUtils.defaultString(item.getLoginCode(), item.getEmpName())
                            + " \u5bfc\u5165\u5931\u8d25\uff1a" + e.getMessage();
                    failureMsg.append(msg);
                    logger.error(msg, e);
                }
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            throw new ServiceException(e.getMessage());
        }
        if (failureNum > 0) {
            failureMsg.insert(0, "\u5f88\u62b1\u6b49\uff0c\u5bfc\u5165\u5931\u8d25\uff01\u5171 " + failureNum + " \u6761\u6570\u636e\u683c\u5f0f\u4e0d\u6b63\u786e\uff0c\u9519\u8bef\u5982\u4e0b\uff1a");
            throw new ServiceException(failureMsg.toString());
        }
        successMsg.insert(0, "\u606d\u559c\u60a8\uff0c\u6570\u636e\u5df2\u5168\u90e8\u5bfc\u5165\u6210\u529f\uff01\u5171 " + successNum + " \u6761\uff0c\u6570\u636e\u5982\u4e0b\uff1a");
        return successMsg.toString();
    }

    private EmpUser buildImportUser(ExcelEmpUserEmployee item, boolean updateSupport) {
        item.setLoginCode(StringUtils.trim(item.getLoginCode()));
        item.setEmpCode(StringUtils.trim(item.getEmpCode()));
        item.setEmpNo(StringUtils.trim(item.getEmpNo()));
        item.setEmpName(StringUtils.trim(item.getEmpName()));
        if (StringUtils.isBlank(item.getLoginCode())) {
            throw new ServiceException("\u767b\u5f55\u8d26\u53f7\u4e0d\u80fd\u4e3a\u7a7a");
        }
        if (StringUtils.isBlank(item.getEmpName())) {
            throw new ServiceException("\u5458\u5de5\u59d3\u540d\u4e0d\u80fd\u4e3a\u7a7a");
        }
        if (StringUtils.isBlank(item.getEmpNo())) {
            item.setEmpNo(item.getLoginCode());
        }
        MesEmployee employee = findOrCreateEmployee(item);
        User query = new User();
        query.setLoginCode(item.getLoginCode());
        User exists = userService.getByLoginCode(query);
        if (exists != null && !updateSupport) {
            throw new ServiceException("\u767b\u5f55\u8d26\u53f7\u5df2\u5b58\u5728");
        }
        if (exists != null && StringUtils.isNotBlank(exists.getRefCode())
                && !StringUtils.equals(exists.getRefCode(), employee.getEmpCode())) {
            User boundQuery = new User();
            boundQuery.setUserType("employee");
            boundQuery.setRefCode(employee.getEmpCode());
            User boundUser = userService.getByUserTypeAndRefCode(boundQuery);
            if (boundUser != null && !StringUtils.equals(boundUser.getUserCode(), exists.getUserCode())) {
                throw new ServiceException("\u5458\u5de5\u5df2\u5173\u8054\u5176\u4ed6\u8d26\u53f7\uff1a" + boundUser.getLoginCode());
            }
        }
        EmpUser empUser = new EmpUser(exists == null ? null : exists.getUserCode());
        if (exists != null) {
            empUser = empUserService.get(exists.getUserCode(), false);
        }
        empUser.setLoginCode(item.getLoginCode());
        empUser.setUserName(StringUtils.defaultIfBlank(item.getUserName(), item.getEmpName()));
        empUser.setEmail(item.getEmail());
        empUser.setMobile(item.getMobile());
        empUser.setPhone(item.getPhone());
        empUser.setStatus(StringUtils.defaultIfBlank(item.getStatus(), User.STATUS_NORMAL));
        empUser.setUserType("employee");
        empUser.setMgrType(StringUtils.defaultIfBlank(empUser.getMgrType(), "0"));
        empUser.setRefCode(employee.getEmpCode());
        empUser.setRefName(employee.getEmpName());
        empUser.setUserRoleString(item.getUserRoleString());
        empUser.setEmployee(null);
        return empUser;
    }

    private MesEmployee findOrCreateEmployee(ExcelEmpUserEmployee item) {
        MesEmployee employee = null;
        if (StringUtils.isNotBlank(item.getEmpCode())) {
            employee = mesEmployeeService.get(new MesEmployee(item.getEmpCode()));
        }
        if (employee == null && StringUtils.isNotBlank(item.getEmpNo())) {
            MesEmployee where = new MesEmployee();
            where.setEmpNo(item.getEmpNo());
            List<MesEmployee> list = mesEmployeeService.findList(where);
            if (list != null && !list.isEmpty()) {
                employee = list.get(0);
            }
        }
        if (employee == null) {
            employee = new MesEmployee();
            employee.setEmpCode(item.getEmpCode());
        }
        employee.setEmpName(item.getEmpName());
        employee.setEmpNameEn(item.getEmpNameEn());
        employee.setEmpNo(item.getEmpNo());
        employee.setOfficeCode(item.getOfficeCode());
        employee.setOfficeName(item.getOfficeName());
        employee.setCompanyCode(item.getCompanyCode());
        employee.setCompanyName(item.getCompanyName());
        employee.setPostCode(item.getPostCode());
        employee.setPostName(item.getPostName());
        employee.setRemarks(item.getRemarks());
        employee.setStatus(MesEmployee.STATUS_NORMAL);
        mesEmployeeService.save(employee);
        saveEmployeePostList(employee, item.getPostCode());
        syncUserEmployeePost(employee, item.getPostCode(), item.getPostName());
        return employee;
    }

    private void saveEmployeePostList(MesEmployee employee, String postCodes) {
        if (employee == null || StringUtils.isBlank(employee.getEmpCode()) || StringUtils.isBlank(postCodes)) {
            return;
        }
        Employee sysEmployee = employeeService.get(new Employee(employee.getEmpCode()));
        if (sysEmployee == null) {
            return;
        }
        sysEmployee.setPostCode(StringUtils.trim(postCodes));
        sysEmployee.setEmployeePostList(buildEmployeePostList(postCodes));
        sysEmployee.setIsNewRecord(false);
        employeeService.save(sysEmployee);
    }

    private void syncUserEmployeePost(MesEmployee employee, String postCode, String postName) {
        if (employee == null) {
            return;
        }
        User query = new User();
        query.setUserType("employee");
        query.setRefCode(employee.getEmpCode());
        User boundUser = userService.getByUserTypeAndRefCode(query);
        if (boundUser == null) {
            return;
        }
        Employee sysEmployee = employeeService.get(new Employee(boundUser.getUserCode()));
        if (sysEmployee == null) {
            return;
        }
        if (StringUtils.isNotBlank(postCode)) {
            sysEmployee.setPostCode(StringUtils.trim(postCode));
        }
        employeeService.save(sysEmployee);
    }

    private List<EmployeePost> buildEmployeePostList(String postCodes) {
        List<EmployeePost> employeePostList = ListUtils.newArrayList();
        for (String postCode : StringUtils.split(StringUtils.trim(postCodes), ",")) {
            if (StringUtils.isNotBlank(postCode)) {
                employeePostList.add(new EmployeePost(null, StringUtils.trim(postCode)));
            }
        }
        return employeePostList;
    }

    private ExcelEmpUserEmployee toExcel(EmpUser user) {
        ExcelEmpUserEmployee excel = new ExcelEmpUserEmployee();
        excel.setLoginCode(user.getLoginCode());
        excel.setUserName(user.getUserName());
        excel.setEmail(user.getEmail());
        excel.setMobile(user.getMobile());
        excel.setPhone(user.getPhone());
        excel.setStatus(user.getStatus());
        MesEmployee employee = null;
        if (StringUtils.isNotBlank(user.getRefCode())) {
            employee = mesEmployeeService.get(new MesEmployee(user.getRefCode()));
        }
        if (employee == null) {
            employee = new MesEmployee();
            if (user.getEmployee() != null) {
                employee.setEmpCode(user.getEmployee().getEmpCode());
                employee.setEmpNo(user.getEmployee().getEmpNo());
                employee.setEmpName(user.getEmployee().getEmpName());
                employee.setEmpNameEn(user.getEmployee().getEmpNameEn());
                if (user.getEmployee().getOffice() != null) {
                    employee.setOfficeCode(user.getEmployee().getOffice().getOfficeCode());
                    employee.setOfficeName(user.getEmployee().getOffice().getOfficeName());
                }
                if (user.getEmployee().getCompany() != null) {
                    employee.setCompanyCode(user.getEmployee().getCompany().getCompanyCode());
                    employee.setCompanyName(user.getEmployee().getCompany().getCompanyName());
                }
                employee.setPostCode(user.getEmployee().getPostCode());
            }
        }
        excel.setEmpCode(employee.getEmpCode());
        excel.setEmpNo(employee.getEmpNo());
        excel.setEmpName(StringUtils.defaultIfBlank(employee.getEmpName(), user.getRefName()));
        excel.setEmpNameEn(employee.getEmpNameEn());
        excel.setOfficeCode(employee.getOfficeCode());
        excel.setOfficeName(employee.getOfficeName());
        excel.setCompanyCode(employee.getCompanyCode());
        excel.setCompanyName(employee.getCompanyName());
        excel.setPostCode(employee.getPostCode());
        excel.setPostName(employee.getPostName());
        excel.setRemarks(employee.getRemarks());
        return excel;
    }

    private MesEmployee findSelectedEmployee(EmpUser empUser) {
        if (empUser.getEmployee() == null) {
            if (StringUtils.isNotBlank(empUser.getRefCode())) {
                return mesEmployeeService.get(new MesEmployee(StringUtils.trim(empUser.getRefCode())));
            }
            return null;
        }
        if (StringUtils.isNotBlank(empUser.getEmployee().getEmpCode())) {
            MesEmployee employee = mesEmployeeService.get(new MesEmployee(empUser.getEmployee().getEmpCode()));
            if (employee != null) {
                return employee;
            }
        }
        if (StringUtils.isNotBlank(empUser.getEmployee().getEmpNo())) {
            MesEmployee where = new MesEmployee();
            where.setEmpNo(StringUtils.trim(empUser.getEmployee().getEmpNo()));
            List<MesEmployee> employees = mesEmployeeService.findList(where);
            if (employees != null && !employees.isEmpty()) {
                return employees.get(0);
            }
        }
        return null;
    }

    private void applyEmployeePostName(Model model) {
        EmpUser empUser = (EmpUser) model.asMap().get("empUser");
        MesEmployee employee = findSelectedEmployee(empUser);
        if (employee == null) {
            return;
        }
        if (empUser != null) {
            if (empUser.getEmployee() == null) {
                empUser.setEmployee(new Employee(employee.getEmpCode()));
            }
            if (StringUtils.isBlank(empUser.getEmployee().getEmpCode())) {
                empUser.getEmployee().setEmpCode(employee.getEmpCode());
            }
            if (StringUtils.isBlank(empUser.getEmployee().getEmpNo())) {
                empUser.getEmployee().setEmpNo(employee.getEmpNo());
            }
            if (StringUtils.isBlank(empUser.getEmployee().getEmpName())) {
                empUser.getEmployee().setEmpName(employee.getEmpName());
            }
            if (StringUtils.isBlank(empUser.getEmployee().getEmpNameEn())) {
                empUser.getEmployee().setEmpNameEn(employee.getEmpNameEn());
            }
            if (StringUtils.isBlank(empUser.getEmployee().getPostCode())) {
                empUser.getEmployee().setPostCode(employee.getPostCode());
            }
        }
        model.addAttribute("employeePostName", employee.getPostName());
        model.addAttribute("empUser", empUser);
    }

    private String checkSelectedEmployee(EmpUser empUser, MesEmployee employee) {
        if (employee == null || StringUtils.isBlank(employee.getUserCode())) {
            return null;
        }
        if (StringUtils.isNotBlank(empUser.getUserCode())
                && StringUtils.equals(employee.getUserCode(), empUser.getUserCode())) {
            return null;
        }
        // 员工关联账号若为软删残留，硬删后允许重新开户
        User linked = findUserByLoginCodeIncludeDeleted(employee.getLoginCode());
        if (linked == null) {
            try {
                linked = userService.get(new User(employee.getUserCode()));
            } catch (Exception ignored) {
                linked = null;
            }
        }
        if (linked != null && User.STATUS_DELETE.equals(linked.getStatus())) {
            phyDeleteUserByCode(linked.getUserCode());
            return null;
        }
        if (linked != null) {
            return "保存用户失败，该员工已创建账号："
                    + StringUtils.defaultIfBlank(linked.getLoginCode(), linked.getUserCode());
        }
        return "保存用户失败，该员工已创建账号："
                + StringUtils.defaultIfBlank(employee.getLoginCode(), employee.getUserCode());
    }

    private User findBoundUser(MesEmployee employee) {
        if (employee == null || StringUtils.isBlank(employee.getEmpCode())) {
            return null;
        }
        User query = new User();
        query.setUserType("employee");
        query.setRefCode(employee.getEmpCode());
        return userService.getByUserTypeAndRefCode(query);
    }

    private void bindSelectedEmployeeUser(EmpUser empUser, MesEmployee employee) {
        empUser.setUserType("employee");
        if (StringUtils.isBlank(empUser.getMgrType())) {
            empUser.setMgrType("0");
        }
        empUser.setRefCode(employee.getEmpCode());
        empUser.setRefName(employee.getEmpName());
        empUser.setEmployee(null);
    }

    /**
     * 按登录账号查询用户（含已删除，用于清理软删残留）
     */
    private User findUserByLoginCodeIncludeDeleted(String loginCode) {
        if (StringUtils.isBlank(loginCode)) {
            return null;
        }
        User query = new User();
        query.setLoginCode(loginCode);
        User user = userService.getByLoginCode(query);
        if (user != null) {
            return user;
        }
        try {
            return jdbcTemplate.query(
                    "SELECT user_code, login_code, user_type, status FROM js_sys_user WHERE login_code = ? LIMIT 1",
                    rs -> {
                        if (!rs.next()) {
                            return null;
                        }
                        User u = new User(rs.getString("user_code"));
                        u.setLoginCode(rs.getString("login_code"));
                        u.setUserType(rs.getString("user_type"));
                        u.setStatus(rs.getString("status"));
                        return u;
                    }, loginCode);
        } catch (EmptyResultDataAccessException e) {
            return null;
        }
    }

    /**
     * 物理删除用户及角色/数据权限关联，并同步硬删员工档案
     * @param userCode 用户编码
     * @param empCode 员工编码（可空，空时尝试用 userCode / ref 兜底）
     */
    private void phyDeleteUserAndEmployee(String userCode, String empCode) {
        if (StringUtils.isBlank(userCode) && StringUtils.isBlank(empCode)) {
            return;
        }
        String resolvedEmpCode = empCode;
        if (StringUtils.isBlank(resolvedEmpCode) && StringUtils.isNotBlank(userCode)) {
            try {
                resolvedEmpCode = jdbcTemplate.query(
                        "SELECT ref_code FROM js_sys_user WHERE user_code = ? LIMIT 1",
                        rs -> rs.next() ? rs.getString("ref_code") : null,
                        userCode);
            } catch (EmptyResultDataAccessException ignored) {
                resolvedEmpCode = null;
            }
            if (StringUtils.isBlank(resolvedEmpCode)) {
                resolvedEmpCode = userCode;
            }
        }
        if (StringUtils.isNotBlank(userCode)) {
            phyDeleteUserByCode(userCode);
        }
        if (StringUtils.isNotBlank(resolvedEmpCode)) {
            phyDeleteEmployeeByCode(resolvedEmpCode);
        }
    }

    /**
     * 物理删除用户及角色/数据权限关联
     */
    private void phyDeleteUserByCode(String userCode) {
        if (StringUtils.isBlank(userCode)) {
            return;
        }
        jdbcTemplate.update("DELETE FROM js_sys_user_role WHERE user_code = ?", userCode);
        jdbcTemplate.update("DELETE FROM js_sys_user_data_scope WHERE user_code = ?", userCode);
        jdbcTemplate.update("DELETE FROM js_sys_user WHERE user_code = ?", userCode);
    }

    /**
     * 物理删除员工及附属机构/岗位关联
     */
    private void phyDeleteEmployeeByCode(String empCode) {
        if (StringUtils.isBlank(empCode)) {
            return;
        }
        jdbcTemplate.update("DELETE FROM js_sys_employee_office WHERE emp_code = ?", empCode);
        jdbcTemplate.update("DELETE FROM js_sys_employee_post WHERE emp_code = ?", empCode);
        jdbcTemplate.update("DELETE FROM js_sys_employee WHERE emp_code = ?", empCode);
    }

    private boolean hasOtherUser(List<EmpUser> userList, String userCode) {
        if (userList == null || userList.isEmpty()) {
            return false;
        }
        for (EmpUser user : userList) {
            if (StringUtils.isBlank(userCode) || !StringUtils.equals(userCode, user.getUserCode())) {
                return true;
            }
        }
        return false;
    }
}