package com.pms.service;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpSession;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.mybatis.spring.SqlSessionTemplate;


import com.pms.common.bean.PersonBean;
import com.pms.common.utils.CommonUtils;
import com.pms.common.utils.Constants;
import com.pms.common.utils.EncryptUtil;
import com.pms.common.Message;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
@RequiredArgsConstructor
public class AdminService {

    private final SqlSessionTemplate sqlSessionTemplate;

    /**
     * 회사 데이터 테스트 조회
     * @return
     */
    public List<Map<String, Object>> getCompanyTest() {
        try {
            List<Map<String, Object>> result = sqlSessionTemplate.selectList("admin.selectCompanyTest");
            log.info("회사 데이터 테스트 조회 결과: {}개", result.size());
            if (!result.isEmpty()) {
                log.info("첫 번째 회사 데이터: {}", result.get(0));
            }
            return result;
        } catch (Exception e) {
            log.error("회사 데이터 테스트 조회 오류", e);
            return new ArrayList<>();
        }
    }

    /**
     * 관리자 메뉴 목록 조회
     * @param request
     * @param paramMap
     * @return
     */
    public List<Map<String, Object>> getAdminMenuList(HttpServletRequest request, Map<String, Object> paramMap) {
        try {
            paramMap.put("SYSTEM_NAME", Constants.SYSTEM_NAME);
            
            // userLang 파라미터가 없으면 기본값 설정
            if (!paramMap.containsKey("userLang") || paramMap.get("userLang") == null) {
                paramMap.put("userLang", "ko"); // 기본값으로 한국어 설정
            }
            
            log.info("AdminService.getAdminMenuList - 파라미터: {}", paramMap);
            
            List<Map<String, Object>> result = sqlSessionTemplate.selectList("admin.selectAdminMenuList", paramMap);
            log.info("관리자 메뉴 목록 조회 결과: {}개", result.size());
            if (!result.isEmpty()) {
                Map<String, Object> firstMenu = result.get(0);
                log.info("첫 번째 메뉴 데이터: {}", firstMenu);
                log.info("첫 번째 메뉴의 번역 정보: LANG_KEY={}, LANG_KEY_DESC={}, TRANSLATED_NAME={}, TRANSLATED_DESC={}", 
                    firstMenu.get("LANG_KEY"), firstMenu.get("LANG_KEY_DESC"), 
                    firstMenu.get("TRANSLATED_NAME"), firstMenu.get("TRANSLATED_DESC"));
                log.info("첫 번째 메뉴의 회사 정보: COMPANY_CODE={}, COMPANY_NAME={}", 
                    firstMenu.get("COMPANY_CODE"), firstMenu.get("COMPANY_NAME"));
                
                // 모든 메뉴의 번역 정보 로깅
                for (int i = 0; i < Math.min(5, result.size()); i++) {
                    Map<String, Object> menu = result.get(i);
                    log.info("메뉴 {}: MENU_NAME_KOR={}, LANG_KEY={}, TRANSLATED_NAME={}", 
                        i + 1, menu.get("MENU_NAME_KOR"), menu.get("LANG_KEY"), menu.get("TRANSLATED_NAME"));
                }
            }
            return result;
        } catch (Exception e) {
            log.error("관리자 메뉴 목록 조회 오류", e);
            return new ArrayList<>();
        }
    }

    /**
     * 사용자 메뉴 목록 조회
     * @param request
     * @param paramMap
     * @return
     */
    public List<Map<String, Object>> getUserMenuList(HttpServletRequest request, Map<String, Object> paramMap) {
        try {
            log.info("AdminService.getUserMenuList 시작 - 파라미터: {}", paramMap);
            
            paramMap.put("SYSTEM_NAME", Constants.SYSTEM_NAME);
            
            log.info("AdminService.getUserMenuList - SYSTEM_NAME 추가 후 파라미터: {}", paramMap);
            
            // 메뉴관리에서는 모든 사용자 메뉴를 보여줘야 하므로 selectUserMenuList 사용
            List<Map<String, Object>> result = sqlSessionTemplate.selectList("admin.selectUserMenuList", paramMap);
            
            log.info("AdminService.getUserMenuList - 쿼리 결과 개수: {}", result.size());
            if (!result.isEmpty()) {
                log.info("AdminService.getUserMenuList - 첫 번째 결과: {}", result.get(0));
                
                // 모든 메뉴의 회사 정보 로깅
                for (int i = 0; i < Math.min(5, result.size()); i++) {
                    Map<String, Object> menu = result.get(i);
                    log.info("AdminService.getUserMenuList - 메뉴 {}: COMPANY_CODE={}, COMPANY_NAME={}", 
                        i + 1, menu.get("COMPANY_CODE"), menu.get("COMPANY_NAME"));
                }
            }
            return result;
        } catch (Exception e) {
            log.error("AdminService.getUserMenuList 오류", e);
            return new ArrayList<>();
        }
    }

    /**
     * 사용자 View 메뉴 조회
     * @param request
     * @param paramMap
     * @return
     */
    public List<Map<String, Object>> getUserViewMenuList(HttpServletRequest request, Map<String, Object> paramMap) {
        try {
            paramMap.put("SYSTEM_NAME", Constants.SYSTEM_NAME);
            return sqlSessionTemplate.selectList("admin.selectUserViewMenuList", paramMap);
        } catch (Exception e) {
            e.printStackTrace();
            return new ArrayList<>();
        }
    }

    /**
     * 파라미터 기반 사용자 View 메뉴 조회
     * @param request
     * @param paramMap
     * @return
     */
    public List<Map<String, Object>> getParamUserViewMenuList(HttpServletRequest request, Map<String, Object> paramMap) {
        try {
            paramMap.put("SYSTEM_NAME", Constants.SYSTEM_NAME);
            
            PersonBean person = (PersonBean)request.getSession().getAttribute(Constants.PERSON_BEAN);
            String userId = CommonUtils.checkNull(person.getUserId());
            paramMap.put("userId", userId);
                
            return sqlSessionTemplate.selectList("admin.getParamUserViewMenuList", paramMap);
        } catch (Exception e) {
            e.printStackTrace();
            return new ArrayList<>();
        }
    }

    /**
     * 메뉴 조회(상위 트리로 역전개)
     * @param request
     * @param paramMap
     * @return
     */
    public List<Map<String, Object>> getMenuUp(HttpServletRequest request, Map<String, Object> paramMap) {
        try {
            paramMap.put("SYSTEM_NAME", Constants.SYSTEM_NAME);
            PersonBean person = (PersonBean)request.getSession().getAttribute(Constants.PERSON_BEAN);
            String userId = CommonUtils.checkNull(person.getUserId());
            paramMap.put("userId", userId);
            return sqlSessionTemplate.selectList("admin.getmenuUp", paramMap);
        } catch (Exception e) {
            e.printStackTrace();
            return new ArrayList<>();
        }
    }

    /**
     * 메뉴 등록
     * @param request
     * @param paramMap
     * @return
     */
    public Map<String, Object> insertMenu(HttpServletRequest request, Map<String, Object> paramMap) {
        Map<String, Object> resultMap = new HashMap<>();
        try {
            // OBJID 생성 (현재 시간 기반으로 고유 ID 생성)
            long currentTime = System.currentTimeMillis();
            java.math.BigDecimal objid = new java.math.BigDecimal(currentTime);
            
            // 프론트엔드에서 오는 키를 백엔드에서 기대하는 키로 변환
            Map<String, Object> convertedParams = new HashMap<>();
            convertedParams.put("OBJID", objid.toString());
            convertedParams.put("SYSTEM_NAME", "PLM");
            convertedParams.put("STATUS", paramMap.get("status") != null ? paramMap.get("status").toString().toLowerCase() : "active");
            convertedParams.put("REGDATE", new java.util.Date());
            
            // 메뉴 타입 변환 (문자열로 처리)
            String menuType = (String) paramMap.get("menuType");
            if ("0".equals(menuType) || "admin".equals(menuType)) {
                convertedParams.put("MENU_TYPE", "0");
            } else {
                convertedParams.put("MENU_TYPE", "1");
            }
            
            // 필수 필드 검증 및 변환
            if (paramMap.get("menuNameKor") == null || paramMap.get("menuNameKor").toString().trim().isEmpty()) {
                throw new IllegalArgumentException("메뉴명은 필수입니다.");
            }
            
            convertedParams.put("MENU_NAME_KOR", paramMap.get("menuNameKor"));
            convertedParams.put("MENU_NAME_ENG", paramMap.get("menuNameEng") != null ? paramMap.get("menuNameEng") : "");
            convertedParams.put("MENU_URL", paramMap.get("menuUrl") != null ? paramMap.get("menuUrl") : "");
            convertedParams.put("MENU_DESC", paramMap.get("menuDesc") != null ? paramMap.get("menuDesc") : "");
            
            // 다국어 키 처리
            Object langKeyObj = paramMap.get("langKey");
            if (langKeyObj != null && !langKeyObj.toString().trim().isEmpty()) {
                convertedParams.put("LANG_KEY", langKeyObj.toString().trim());
            } else {
                convertedParams.put("LANG_KEY", null);
            }
            
            // 회사 코드 처리 (빈 문자열이면 null로 설정, "none"이면 "*"로 설정)
            Object companyCodeObj = paramMap.get("companyCode");
            if (companyCodeObj == null || companyCodeObj.toString().trim().isEmpty()) {
                convertedParams.put("COMPANY_CODE", null);
            } else if ("none".equals(companyCodeObj.toString())) {
                convertedParams.put("COMPANY_CODE", "*");
            } else {
                convertedParams.put("COMPANY_CODE", companyCodeObj.toString());
            }
            
            // SEQ 값 설정 (null이면 1로 기본값 설정)
            Object seqValue = paramMap.get("seq");
            if (seqValue == null) {
                convertedParams.put("SEQ", "1");
            } else {
                try {
                    java.math.BigDecimal seq = new java.math.BigDecimal(seqValue.toString());
                    convertedParams.put("SEQ", seq.toString());
                } catch (NumberFormatException e) {
                    convertedParams.put("SEQ", "1");
                }
            }
            
            // PARENT_OBJ_ID 설정 (문자열로 변환)
            Object parentObjIdValue = paramMap.get("parentObjId");
            if (parentObjIdValue == null || parentObjIdValue.toString().trim().isEmpty()) {
                convertedParams.put("PARENT_OBJ_ID", "0");
            } else {
                try {
                    java.math.BigDecimal parentObjId = new java.math.BigDecimal(parentObjIdValue.toString());
                    convertedParams.put("PARENT_OBJ_ID", parentObjId.toString());
                } catch (NumberFormatException e) {
                    convertedParams.put("PARENT_OBJ_ID", "0");
                }
            }
            convertedParams.put("WRITER", "admin"); // 기본 작성자
            
            log.info("메뉴 등록 파라미터: {}", convertedParams);
            
            // 메뉴 등록
            int result = sqlSessionTemplate.insert("admin.insertMenu", convertedParams);
            resultMap.put("success", result > 0);
            resultMap.put("message", result > 0 ? "메뉴가 등록되었습니다." : "메뉴 등록에 실패했습니다.");
            resultMap.put("objid", objid);
        } catch (Exception e) {
            log.error("메뉴 등록 중 오류 발생", e);
            resultMap.put("success", false);
            resultMap.put("message", "메뉴 등록 중 오류가 발생했습니다: " + e.getMessage());
        }
        return resultMap;
    }

    /**
     * 메뉴 정보 조회
     * @param request
     * @param paramMap
     * @return
     */
    public Map<String, Object> getMenuInfo(HttpServletRequest request, Map<String, Object> paramMap) {
        try {
            log.info("getMenuInfo 호출 - 파라미터: {}", paramMap);
            Map<String, Object> result = sqlSessionTemplate.selectOne("admin.selectMenuInfo", paramMap);
            log.info("getMenuInfo 결과: {}", result);
            return result;
        } catch (Exception e) {
            log.error("getMenuInfo 오류", e);
            return new HashMap<>();
        }
    }

    /**
     * 메뉴 활성/비활성 토글
     * @param menuId
     * @return
     */
    @Transactional
    public String toggleMenuStatus(String menuId) {
        try {
            log.info("메뉴 상태 토글 시작: menuId = {}", menuId);
            
            // 현재 상태 조회
            Map<String, Object> params = new HashMap<>();
            // OBJID를 문자열로 변환
            try {
                java.math.BigDecimal objid = new java.math.BigDecimal(menuId);
                params.put("OBJID", objid.toString());
            } catch (NumberFormatException e) {
                throw new IllegalArgumentException("메뉴 ID는 숫자여야 합니다.");
            }
            Map<String, Object> currentMenu = sqlSessionTemplate.selectOne("admin.selectMenuInfo", params);
            
            if (currentMenu == null) {
                throw new RuntimeException("메뉴를 찾을 수 없습니다: " + menuId);
            }
            
            String currentStatus = (String) currentMenu.get("STATUS");
            String newStatus = "active".equals(currentStatus) ? "inactive" : "active";
            
            // 상태 업데이트
            params.put("status", newStatus);
            // objid를 문자열로 변환
            try {
                java.math.BigDecimal objid = new java.math.BigDecimal(menuId);
                params.put("objid", objid.toString());
            } catch (NumberFormatException e) {
                throw new IllegalArgumentException("메뉴 ID는 숫자여야 합니다.");
            }
            sqlSessionTemplate.update("admin.updateMenuStatus", params);
            
            String result = "active".equals(newStatus) ? "활성화" : "비활성화";
            log.info("메뉴 상태 토글 완료: menuId = {}, 상태 = {}", menuId, result);
            return result;
        } catch (Exception e) {
            log.error("메뉴 상태 토글 중 오류 발생", e);
            throw e;
        }
    }



    /**
     * 메뉴 수정
     * @param request
     * @param paramMap
     * @return
     */
    public Map<String, Object> updateMenu(HttpServletRequest request, Map<String, Object> paramMap) {
        log.info("updateMenu 호출 - 원본 파라미터: {}", paramMap);
        Map<String, Object> resultMap = new HashMap<>();
        try {
            // 프론트엔드에서 오는 키를 백엔드에서 기대하는 키로 변환
            Map<String, Object> convertedParams = new HashMap<>();
            
            // OBJID는 수정 시 필수
            Object objidObj = paramMap.get("objid");
            log.info("objid 원본 값: {} (타입: {})", objidObj, objidObj != null ? objidObj.getClass().getSimpleName() : "null");
            
            if (objidObj == null) {
                throw new IllegalArgumentException("메뉴 ID는 필수입니다.");
            }
            // OBJID를 문자열로 변환 (PostgreSQL ::numeric 캐스팅용)
            try {
                java.math.BigDecimal objid = new java.math.BigDecimal(objidObj.toString());
                convertedParams.put("OBJID", objid.toString());
                log.info("objid 변환 완료: {}", objid);
            } catch (NumberFormatException e) {
                log.error("objid 숫자 변환 실패: {}", objidObj, e);
                throw new IllegalArgumentException("메뉴 ID는 숫자여야 합니다.");
            }
            
            // 필수 필드 검증 및 변환
            if (paramMap.get("menuNameKor") == null || paramMap.get("menuNameKor").toString().trim().isEmpty()) {
                throw new IllegalArgumentException("메뉴명은 필수입니다.");
            }
            
            convertedParams.put("MENU_NAME_KOR", paramMap.get("menuNameKor"));
            convertedParams.put("MENU_NAME_ENG", paramMap.get("menuNameEng") != null ? paramMap.get("menuNameEng") : "");
            convertedParams.put("MENU_URL", paramMap.get("menuUrl") != null ? paramMap.get("menuUrl") : "");
            convertedParams.put("MENU_DESC", paramMap.get("menuDesc") != null ? paramMap.get("menuDesc") : "");
            
            // 다국어 키 처리
            Object langKeyObj = paramMap.get("langKey");
            if (langKeyObj != null && !langKeyObj.toString().trim().isEmpty()) {
                convertedParams.put("LANG_KEY", langKeyObj.toString().trim());
            } else {
                convertedParams.put("LANG_KEY", null);
            }
            
            // 회사 코드 처리 (빈 문자열이면 null로 설정, "none"이면 "*"로 설정)
            Object companyCodeObj = paramMap.get("companyCode");
            if (companyCodeObj == null || companyCodeObj.toString().trim().isEmpty()) {
                convertedParams.put("COMPANY_CODE", null);
            } else if ("none".equals(companyCodeObj.toString())) {
                convertedParams.put("COMPANY_CODE", "*");
            } else {
                convertedParams.put("COMPANY_CODE", companyCodeObj.toString());
            }
            
            // PARENT_OBJ_ID 설정 (문자열로 변환)
            Object parentObjIdValue = paramMap.get("parentObjId");
            if (parentObjIdValue == null || parentObjIdValue.toString().trim().isEmpty()) {
                convertedParams.put("PARENT_OBJ_ID", "0");
            } else {
                try {
                    java.math.BigDecimal parentObjId = new java.math.BigDecimal(parentObjIdValue.toString());
                    convertedParams.put("PARENT_OBJ_ID", parentObjId.toString());
                } catch (NumberFormatException e) {
                    convertedParams.put("PARENT_OBJ_ID", "0");
                }
            }
            
            // SEQ 값 설정 (null이면 1로 기본값 설정)
            Object seqValue = paramMap.get("seq");
            if (seqValue == null) {
                convertedParams.put("SEQ", "1");
            } else {
                try {
                    java.math.BigDecimal seq = new java.math.BigDecimal(seqValue.toString());
                    convertedParams.put("SEQ", seq.toString());
                } catch (NumberFormatException e) {
                    convertedParams.put("SEQ", "1");
                }
            }
            
            // STATUS 값 정규화 (inActive -> inactive, active -> active)
            String statusValue = paramMap.get("status") != null ? paramMap.get("status").toString().toLowerCase() : "active";
            if ("inactive".equals(statusValue) || "inactive".equals(statusValue)) {
                statusValue = "inactive";
            } else {
                statusValue = "active";
            }
            convertedParams.put("STATUS", statusValue);
            
            log.info("메뉴 수정 파라미터: {}", convertedParams);
            
            int result = sqlSessionTemplate.update("admin.updateMenu", convertedParams);
            resultMap.put("success", result > 0);
            resultMap.put("message", result > 0 ? "메뉴가 수정되었습니다." : "메뉴 수정에 실패했습니다.");
        } catch (Exception e) {
            log.error("메뉴 수정 중 오류 발생", e);
            resultMap.put("success", false);
            resultMap.put("message", "메뉴 수정 중 오류가 발생했습니다: " + e.getMessage());
        }
        return resultMap;
    }

    /**
     * 메뉴 삭제 (계층 구조 고려)
     * @param request
     * @param paramMap
     * @return
     */
    public Map<String, Object> deleteMenu(HttpServletRequest request, Map<String, Object> paramMap) {
        Map<String, Object> resultMap = new HashMap<>();
        try {
            // OBJID 파라미터 변환
            Map<String, Object> convertedParams = new HashMap<>();
            // OBJID를 문자열로 변환
            try {
                java.math.BigDecimal objid = new java.math.BigDecimal(paramMap.get("objid").toString());
                convertedParams.put("OBJID", objid.toString());
            } catch (NumberFormatException e) {
                throw new IllegalArgumentException("메뉴 ID는 숫자여야 합니다.");
            }
            
            log.info("메뉴 삭제 파라미터: {}", convertedParams);
            
            // 계층 구조를 고려한 삭제 (메뉴와 하위 메뉴들 모두 삭제)
            int result = sqlSessionTemplate.delete("admin.deleteMenuWithChildren", convertedParams);
            resultMap.put("success", result > 0);
            resultMap.put("message", result > 0 ? "메뉴와 하위 메뉴들이 삭제되었습니다." : "메뉴 삭제에 실패했습니다.");
            resultMap.put("deletedCount", result);
        } catch (Exception e) {
            log.error("메뉴 삭제 중 오류 발생", e);
            resultMap.put("success", false);
            resultMap.put("message", "메뉴 삭제 중 오류가 발생했습니다: " + e.getMessage());
        }
        return resultMap;
    }

    /**
     * 메뉴 일괄 삭제
     * @param request
     * @param menuIds
     * @return
     */
    @Transactional
    public Map<String, Object> deleteMenusBatch(HttpServletRequest request, List<String> menuIds) {
        Map<String, Object> resultMap = new HashMap<>();
        int deletedCount = 0;
        int failedCount = 0;
        List<String> failedMenuIds = new ArrayList<>();
        
        try {
            log.info("메뉴 일괄 삭제 시작: {}개의 메뉴", menuIds.size());
            
            for (String menuId : menuIds) {
                try {
                    // OBJID 파라미터 변환
                    Map<String, Object> convertedParams = new HashMap<>();
                    try {
                        java.math.BigDecimal objid = new java.math.BigDecimal(menuId);
                        convertedParams.put("OBJID", objid.toString());
                    } catch (NumberFormatException e) {
                        log.warn("잘못된 메뉴 ID 형식: {}", menuId);
                        failedCount++;
                        failedMenuIds.add(menuId);
                        continue;
                    }
                    
                    log.info("메뉴 삭제 시도: {}", menuId);
                    
                    // 계층 구조를 고려한 삭제 (메뉴와 하위 메뉴들 모두 삭제)
                    int result = sqlSessionTemplate.delete("admin.deleteMenuWithChildren", convertedParams);
                    if (result > 0) {
                        deletedCount++;
                        log.info("메뉴 및 하위 메뉴 삭제 성공: {} (총 {}개 삭제)", menuId, result);
                    } else {
                        failedCount++;
                        failedMenuIds.add(menuId);
                        log.warn("메뉴 삭제 실패 (존재하지 않음): {}", menuId);
                    }
                    
                } catch (Exception e) {
                    failedCount++;
                    failedMenuIds.add(menuId);
                    log.error("메뉴 삭제 중 오류 발생: menuId = {}, error = {}", menuId, e.getMessage());
                }
            }
            
            // 결과 설정 - 하나라도 성공하면 success로 처리
            boolean hasSuccess = deletedCount > 0;
            resultMap.put("success", hasSuccess);
            resultMap.put("deletedCount", deletedCount);
            resultMap.put("failedCount", failedCount);
            resultMap.put("failedMenuIds", failedMenuIds);
            
            if (failedCount == 0) {
                resultMap.put("message", String.format("%d개의 메뉴가 성공적으로 삭제되었습니다.", deletedCount));
            } else if (deletedCount > 0) {
                resultMap.put("message", String.format("%d개 삭제 성공, %d개 삭제 실패", deletedCount, failedCount));
            } else {
                resultMap.put("message", "모든 메뉴 삭제에 실패했습니다.");
            }
            
            log.info("메뉴 일괄 삭제 완료: 성공 {}개, 실패 {}개", deletedCount, failedCount);
            
        } catch (Exception e) {
            log.error("메뉴 일괄 삭제 중 전체 오류 발생", e);
            resultMap.put("success", false);
            resultMap.put("message", "메뉴 일괄 삭제 중 오류가 발생했습니다: " + e.getMessage());
            resultMap.put("deletedCount", deletedCount);
            resultMap.put("failedCount", failedCount);
            resultMap.put("failedMenuIds", failedMenuIds);
        }
        
        return resultMap;
    }

    /**
     * 메뉴 권한 그룹 목록 조회
     * @param request
     * @param paramMap
     * @return
     */
    public List<Map<String, Object>> getMenuAuthGroupList(HttpServletRequest request, Map<String, Object> paramMap) {
        try {
            return sqlSessionTemplate.selectList("admin.selectMenuAuthGroupList", paramMap);
        } catch (Exception e) {
            e.printStackTrace();
            return new ArrayList<>();
        }
    }

    /**
     * 사용자 메뉴 권한 체크
     * @param request
     * @param paramMap
     * @return
     */
    public Map<String, Object> checkUserMenuAuth(HttpServletRequest request, Map<String, Object> paramMap) {
        try {
            HttpSession session = request.getSession();
            PersonBean person = (PersonBean)session.getAttribute(Constants.PERSON_BEAN);
            String accessUser = CommonUtils.checkNull(person.getUserId());
            
            paramMap.put("USER_ID", accessUser);
            return sqlSessionTemplate.selectOne("admin.checkUserMenuAuth", paramMap);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 권한 관리 목록 조회
     * @param request
     * @param paramMap
     * @return
     */
    public List<Map<String, Object>> getAuthMngList(HttpServletRequest request, Map<String, Object> paramMap) {
        try {
            return sqlSessionTemplate.selectList("admin.selectAuthMngList", paramMap);
        } catch (Exception e) {
            e.printStackTrace();
            return new ArrayList<>();
        }
    }

    /**
     * 권한 그룹 정보 조회
     * @param request
     * @param paramMap
     * @return
     */
    public Map<String, Object> getAuthGroupInfo(HttpServletRequest request, Map<String, Object> paramMap) {
        try {
            return sqlSessionTemplate.selectOne("admin.selectAuthGroupInfo", paramMap);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 권한 그룹 멤버 목록 조회
     * @param request
     * @param paramMap
     * @return
     */
    public List<Map<String, Object>> getAuthGroupMemberList(HttpServletRequest request, Map<String, Object> paramMap) {
        try {
            return sqlSessionTemplate.selectList("admin.selectAuthGroupMemberList", paramMap);
        } catch (Exception e) {
            e.printStackTrace();
            return new ArrayList<>();
        }
    }

    /**
     * 메뉴 권한 목록 조회
     * @param request
     * @param paramMap
     * @return
     */
    public List<Map<String, Object>> getMenuAuthList(HttpServletRequest request, Map<String, Object> paramMap) {
        try {
            return sqlSessionTemplate.selectList("admin.selectMenuAuthList", paramMap);
        } catch (Exception e) {
            e.printStackTrace();
            return new ArrayList<>();
        }
    }

    /**
     * 사용자 정보 조회
     * @param request
     * @param paramMap
     * @return
     */
    public Map<String, Object> getUserInfo(HttpServletRequest request, Map<String, Object> paramMap) {
        try {
            return sqlSessionTemplate.selectOne("admin.selectUserInfo", paramMap);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
    /**
     * 사용자 정보 저장 (기존 시스템 호환)
     * @param request
     * @param paramMap
     * @return
     */
    @SuppressWarnings({"rawtypes", "unchecked"})
    public Map saveEtcUserInfo(HttpServletRequest request, Map paramMap) {
        Map resultMap = new HashMap();
        
        try {
            HttpSession session = request.getSession();
            PersonBean person = (PersonBean) session.getAttribute(Constants.PERSON_BEAN);
            String writer = CommonUtils.checkNull(person.getUserId());
            String userId = CommonUtils.checkNull(paramMap.get("userId"));
            
            // 현재 로그인한 사용자 ID와 저장하려는 사용자 ID가 같은지 확인 (프로필 수정인지 판단)
            boolean isProfileUpdate = userId.equals(writer);
            
            int cnt = 0;
            
            if (isProfileUpdate) {
                // 프로필 수정의 경우 - 기존 사용자 정보 업데이트
                log.info("프로필 수정 요청 - 사용자 ID: {}", userId);
                
                // 패스워드가 포함된 경우에만 암호화
                String password = CommonUtils.checkNull(paramMap.get("password"));
                if (password != null && !password.isEmpty()) {
                    password = new EncryptUtil().encrypt(password);
                    paramMap.put("password", password);
                }
                
                // 사용자 정보 업데이트
                cnt = sqlSessionTemplate.update("admin.saveEtcUserInfo", paramMap);
                
                // 히스토리 저장을 위한 파라미터 설정
                paramMap.put("history_type", "사용자 정보 수정");
                
            } else {
                // 신규 사용자 등록의 경우 - 중복 검사 후 생성
                log.info("신규 사용자 등록 요청 - 사용자 ID: {}", userId);
                
                // 해당 ID가 이미 존재하는지 체크
                Map<String, Object> duplicateCheckMap = new HashMap<>();
                duplicateCheckMap.put("userId", userId);
                
                Map<String, Object> duplicateResult = sqlSessionTemplate.selectOne("admin.checkDuplicateEtcUserId", duplicateCheckMap);
                if (duplicateResult != null) {
                    Object cntObj = duplicateResult.get("cnt");
                    if (cntObj == null) {
                        cntObj = duplicateResult.get("CNT");
                    }
                    int existingCnt = Integer.parseInt(CommonUtils.checkNull(cntObj, "0"));
                    
                    if (existingCnt > 0) {
                        log.warn("사용자 생성 거부 - 이미 존재하는 ID: {}", userId);
                        resultMap.put("result", false);
                        resultMap.put("msg", "이미 존재하는 사용자 ID입니다. 다른 ID를 사용해주세요.");
                        return resultMap;
                    }
                }
                
                // 패스워드 암호화 (신규 등록시 필수)
                String password = CommonUtils.checkNull(paramMap.get("password"));
                if (password != null && !password.isEmpty()) {
                    password = new EncryptUtil().encrypt(password);
                    paramMap.put("password", password);
                }
                
                // 신규 사용자 정보 생성
                cnt = sqlSessionTemplate.insert("admin.insertEtcUserInfo", paramMap);
                
                // 히스토리 저장을 위한 파라미터 설정
                paramMap.put("history_type", "사용자 정보 생성");
            }
            
            paramMap.put("writer", writer);
            
            // 사용자 정보 변경 히스토리 저장
            sqlSessionTemplate.update("admin.InsertUserInfoHistory", paramMap);
            
            if (cnt > 0) {
                // 저장 성공 시 프로필 수정인 경우 세션의 사용자 정보도 업데이트
                if (isProfileUpdate) {
                    updateSessionUserInfo(request, paramMap);
                }
                
                resultMap.put("result", true);
                resultMap.put("msg", Message.SAVE_SUCCESS);
            } else {
                resultMap.put("result", false);
                resultMap.put("msg", Message.SAVE_FAILED);
            }
            
        } catch (Exception e) {
            resultMap.put("result", false);
            if (e.getMessage() != null && (e.getMessage().contains("duplicate key") || e.getMessage().contains("중복"))) {
                resultMap.put("msg", "이미 존재하는 사용자 ID입니다.");
                log.warn("사용자 처리 실패 - 중복 ID: {}", paramMap.get("userId"));
            } else {
                resultMap.put("msg", Message.SYSTEM_ERROR);
            }
            log.error("saveEtcUserInfo 처리 중 오류 발생: " + e.getMessage(), e);
        }
        
        return resultMap;
    }
    
    // ========== 사용자 관리 CRUD 메서드들 시작 ==========
    
    /**
     * 기타사용자목록 조회 (페이징 포함)
     * @param request
     * @param paramMap
     * @return
     */
    public List<Map<String, Object>> getEtcUserList(HttpServletRequest request, Map<String, Object> paramMap) {
        try {
            // 페이징 처리를 위한 기본 파라미터 설정
            String page = CommonUtils.checkNull(String.valueOf(paramMap.get("page")), "1");
            String countPerPage = CommonUtils.checkNull(String.valueOf(paramMap.get("countPerPage")), String.valueOf(Constants.ADMIN_COUNT_PER_PAGE));
            
            paramMap.put("COUNT_PER_PAGE", Integer.parseInt(countPerPage));
            paramMap.put("page", page);
            
            // 총 개수 조회 (원본 패턴 따라서)
            Map<String, Object> pageMap = sqlSessionTemplate.selectOne("admin.getEtcUserListCnt", paramMap);
            if (pageMap == null) {
                pageMap = new HashMap<>();
                pageMap.put("TOTAL_CNT", 0);
            }
            
            // 원본처럼 파라미터 병합 후 페이징 정보 계산
            pageMap.putAll(paramMap);
            @SuppressWarnings("unchecked")
            Map<String, Object> paging = (Map<String, Object>) CommonUtils.setPagingInfo(request, pageMap);
            pageMap = paging;
            
            paramMap.put("PAGE_START", CommonUtils.checkNull(pageMap.get("PAGE_START")));
            paramMap.put("PAGE_END", CommonUtils.checkNull(pageMap.get("PAGE_END")));
            
            // 사용자 목록 조회
            List<Map<String, Object>> resultList = sqlSessionTemplate.selectList("admin.getEtcUserList", paramMap);
            
            // 소문자 키로 프론트엔드 친화적으로 반환
            return resultList != null ? resultList : new ArrayList<>();
            
        } catch (Exception e) {
            log.error("사용자 목록 조회 중 오류 발생", e);
            return new ArrayList<>();
        }
    }
    
    /**
     * 기타사용자 상세 조회
     * @param paramMap
     * @return
     */
    public Map<String, Object> getEtcUserInfo(Map<String, Object> paramMap) {
        try {
            Map<String, Object> userInfo = sqlSessionTemplate.selectOne("admin.getEtcUserInfo", paramMap);
            return userInfo != null ? userInfo : new HashMap<>();
        } catch (Exception e) {
            log.error("사용자 상세 조회 중 오류 발생", e);
            return new HashMap<>();
        }
    }
    

    
    /**
     * 기타사용자ID 중복 체크 (Spring Boot + MyBatis 방식)
     * @param paramMap
     * @return
     */
    public Map<String, Object> checkDuplicateEtcUserId(Map<String, Object> paramMap) {
        Map<String, Object> resultMap = new HashMap<>();
        
        try {
            // Spring Boot 환경에서는 SqlSessionTemplate 사용 (자동 세션 관리)
            Map<String, Object> queryResult = sqlSessionTemplate.selectOne("admin.checkDuplicateEtcUserId", paramMap);
            
            if (queryResult != null) {
                // PostgreSQL은 대문자로 컬럼명을 반환하므로 CNT와 cnt 둘 다 확인
                Object cntObj = queryResult.get("cnt");
                if (cntObj == null) {
                    cntObj = queryResult.get("CNT");
                }
                
                int cnt = Integer.parseInt(CommonUtils.checkNull(cntObj, "0"));
                
                if (cnt > 0) {
                    resultMap.put("result", false);
                    resultMap.put("msg", "이미 등록된 ID입니다.");
                } else {
                    resultMap.put("result", true);
                    resultMap.put("msg", "사용 가능한 ID입니다.");
                }
            } else {
                // 쿼리 결과가 null인 경우 (사용 가능)
                resultMap.put("result", true);
                resultMap.put("msg", "사용 가능한 ID입니다.");
            }
        } catch (Exception e) {
            resultMap.put("result", false);
            resultMap.put("msg", "시스템 오류가 발생했습니다."); // Message.SYSTEM_ERROR
            log.error("사용자 ID 중복 체크 중 오류 발생", e);
        }
        
        return resultMap;
    }
    
    /**
     * 부서 목록 조회
     * @param request
     * @param paramMap
     * @return
     */
    public List<Map<String, Object>> getDepartmentList(HttpServletRequest request, Map<String, Object> paramMap) {
        try {
            // admin.xml에 새로 추가한 부서 조회 쿼리 사용
            List<Map<String, Object>> departmentList = sqlSessionTemplate.selectList("admin.getDepartmentList", paramMap);
            return departmentList != null ? departmentList : new ArrayList<>();
        } catch (Exception e) {
            log.error("부서 목록 조회 중 오류 발생", e);
            return new ArrayList<>();
        }
    }
    
    /**
     * 사용자 상태 변경
     * @param paramMap
     * @return
     */
    public Map<String, Object> changeUserStatus(Map<String, Object> paramMap) {
        Map<String, Object> resultMap = new HashMap<>();
        
        try {
            int cnt = sqlSessionTemplate.update("admin.changeUserStatus", paramMap);
            // sqlSessionTemplate.insert("admin.saveUserHistoryInfo", paramMap);
            
            if (cnt > 0) {
                resultMap.put("result", true);
                resultMap.put("msg", "상태가 변경되었습니다.");
            } else {
                resultMap.put("result", false);
                resultMap.put("msg", "상태 변경에 실패했습니다.");
            }
            
        } catch (Exception e) {
            log.error("사용자 상태 변경 중 오류 발생", e);
            resultMap.put("result", false);
            resultMap.put("msg", "시스템 오류가 발생했습니다: " + e.getMessage());
        }
        
        return resultMap;
    }
    
    /**
     * 사용자 목록 총 개수 조회
     * @param paramMap 검색 조건
     * @return 총 개수
     */
    public int getEtcUserListCnt(Map<String, Object> paramMap) {
        try {
            log.info("사용자 총 개수 조회 시작 - 파라미터: {}", paramMap);
            
            // 단순 카운트 쿼리 사용
            Integer count = sqlSessionTemplate.selectOne("admin.getEtcUserListCount", paramMap);
            
            log.info("사용자 총 개수 조회 결과: {}", count);
            
            return count != null ? count : 0;
        } catch (Exception e) {
            log.error("사용자 목록 총 개수 조회 중 오류 발생", e);
            return 0;
        }
    }

    // ========== 사용자 관리 CRUD 메서드들 끝 ==========
    
    // ========== 회사 관리 CRUD 메서드들 시작 ==========
    
    /**
     * 회사 등록
     * @param request
     * @param paramMap
     * @return
     */
    public Map<String, Object> insertCompany(HttpServletRequest request, Map<String, Object> paramMap) {
        Map<String, Object> resultMap = new HashMap<>();
        
        try {
            // 현재 로그인 사용자 정보 가져오기
            HttpSession session = request.getSession();
            PersonBean person = (PersonBean) session.getAttribute(Constants.PERSON_BEAN);
            
            if (person == null) {
                resultMap.put("success", false);
                resultMap.put("message", "로그인이 필요합니다.");
                return resultMap;
            }
            
            // 필수 입력값 검증
            String companyName = CommonUtils.checkNull(paramMap.get("company_name"));
            if (companyName.isEmpty()) {
                resultMap.put("success", false);
                resultMap.put("message", "회사명을 입력해주세요.");
                return resultMap;
            }
            
            // 회사명 중복 체크 (시퀀스 생성 전에 먼저 체크!)
            Map<String, Object> duplicateCheckParam = new HashMap<>();
            duplicateCheckParam.put("COMPANY_NAME", companyName);
            int duplicateCount = sqlSessionTemplate.selectOne("admin.checkCompanyNameDuplicate", duplicateCheckParam);
            
            if (duplicateCount > 0) {
                resultMap.put("success", false);
                resultMap.put("message", "이미 등록된 회사명입니다.");
                return resultMap;
            }
            
            // 모든 유효성 검증 통과 후 회사 코드 생성 (COMPANY_1, COMPANY_2, ...)
            String companyCode = generateSequentialCompanyCode();
            
            // 회사 정보 저장용 파라미터 설정
            Map<String, Object> insertParam = new HashMap<>();
            insertParam.put("COMPANY_CODE", companyCode);
            insertParam.put("COMPANY_NAME", companyName);
            insertParam.put("WRITER", person.getUserName() + "(" + person.getUserId() + ")");
            insertParam.put("STATUS", "active"); // 기본 상태: 활성

            
            // 데이터베이스에 회사 정보 저장
            int insertResult = sqlSessionTemplate.insert("admin.insertCompany", insertParam);
            
            if (insertResult > 0) {
                resultMap.put("success", true);
                resultMap.put("message", "회사가 성공적으로 등록되었습니다.");
                resultMap.put("data", insertParam);
            } else {
                resultMap.put("success", false);
                resultMap.put("message", "회사 등록에 실패했습니다.");
            }
            
        } catch (Exception e) {
            log.error("회사 등록 중 오류 발생", e);
            resultMap.put("success", false);
            resultMap.put("message", "회사 등록 중 오류가 발생했습니다: " + e.getMessage());
        }
        
        return resultMap;
    }
    
    /**
     * 회사 목록 조회
     * @param request
     * @param paramMap
     * @return
     */
    public List<Map<String, Object>> getCompanyList(HttpServletRequest request, Map<String, Object> paramMap) {
        try {
            // 현재 사용자 정보 조회
            PersonBean person = (PersonBean) request.getSession().getAttribute(Constants.PERSON_BEAN);
            if (person == null) {
                log.warn("로그인되지 않은 사용자의 회사 목록 조회 시도");
                return new ArrayList<>();
            }
            
            // 검색 조건 설정
            Map<String, Object> searchParam = new HashMap<>();
            
            
            // 회사명 검색
            String companyName = CommonUtils.checkNull(paramMap.get("company_name"));
            if (!companyName.isEmpty()) {
                searchParam.put("COMPANY_NAME", companyName);
            }
            
            // 상태 필터
            String status = CommonUtils.checkNull(paramMap.get("status"));
            if (!status.isEmpty() && !"all".equals(status)) {
                searchParam.put("STATUS", status);
            }
            
            // 회사 목록 조회 (현재 유저의 locale과 일치하는 회사만)
            return sqlSessionTemplate.selectList("admin.selectCompanyList", searchParam);
            
        } catch (Exception e) {
            log.error("회사 목록 조회 중 오류 발생", e);
            return new ArrayList<>();
        }
    }
    
    /**
     * 회사 정보 단건 조회
     * @param request
     * @param paramMap
     * @return
     */
    public Map<String, Object> getCompanyInfo(HttpServletRequest request, Map<String, Object> paramMap) {
        try {
            String companyCode = CommonUtils.checkNull(paramMap.get("company_code"));
            if (companyCode.isEmpty()) {
                Map<String, Object> errorMap = new HashMap<>();
                errorMap.put("success", false);
                errorMap.put("message", "회사 코드가 필요합니다.");
                return errorMap;
            }
            
            
            Map<String, Object> queryParam = new HashMap<>();
            queryParam.put("COMPANY_CODE", companyCode);
            
            Map<String, Object> companyInfo = sqlSessionTemplate.selectOne("admin.selectCompanyInfo", queryParam);
            
            Map<String, Object> resultMap = new HashMap<>();
            if (companyInfo != null) {
                resultMap.put("success", true);
                resultMap.put("data", companyInfo);
            } else {
                resultMap.put("success", false);
                resultMap.put("message", "회사 정보를 찾을 수 없습니다.");
            }
            
            return resultMap;
            
        } catch (Exception e) {
            log.error("회사 정보 조회 중 오류 발생", e);
            Map<String, Object> errorMap = new HashMap<>();
            errorMap.put("success", false);
            errorMap.put("message", "회사 정보 조회 중 오류가 발생했습니다: " + e.getMessage());
            return errorMap;
        }
    }
    
    /**
     * 회사 정보 수정
     * @param request
     * @param paramMap
     * @return
     */
    public Map<String, Object> updateCompany(HttpServletRequest request, Map<String, Object> paramMap) {
        Map<String, Object> resultMap = new HashMap<>();
        
        try {
            // 필수 입력값 검증
            String companyCode = CommonUtils.checkNull(paramMap.get("company_code"));
            String companyName = CommonUtils.checkNull(paramMap.get("company_name"));
            
            if (companyCode.isEmpty()) {
                resultMap.put("success", false);
                resultMap.put("message", "회사 코드가 필요합니다.");
                return resultMap;
            }
            
            if (companyName.isEmpty()) {
                resultMap.put("success", false);
                resultMap.put("message", "회사명을 입력해주세요.");
                return resultMap;
            }
            
            // 회사명 중복 체크 (자기 자신 제외)
            Map<String, Object> duplicateCheckParam = new HashMap<>();
            duplicateCheckParam.put("COMPANY_NAME", companyName);
            duplicateCheckParam.put("EXCLUDE_COMPANY_CODE", companyCode);
            int duplicateCount = sqlSessionTemplate.selectOne("admin.checkCompanyNameDuplicate", duplicateCheckParam);
            
            if (duplicateCount > 0) {
                resultMap.put("success", false);
                resultMap.put("message", "이미 등록된 회사명입니다.");
                return resultMap;
            }
            
            // 회사 정보 수정용 파라미터 설정
            Map<String, Object> updateParam = new HashMap<>();
            updateParam.put("COMPANY_CODE", companyCode);
            updateParam.put("COMPANY_NAME", companyName);
            updateParam.put("STATUS", CommonUtils.checkNull(paramMap.get("status"), "active"));
            
            // 데이터베이스에서 회사 정보 수정
            int updateResult = sqlSessionTemplate.update("admin.updateCompany", updateParam);
            
            if (updateResult > 0) {
                resultMap.put("success", true);
                resultMap.put("message", "회사 정보가 성공적으로 수정되었습니다.");
                resultMap.put("data", updateParam);
            } else {
                resultMap.put("success", false);
                resultMap.put("message", "회사 정보 수정에 실패했습니다.");
            }
            
        } catch (Exception e) {
            log.error("회사 정보 수정 중 오류 발생", e);
            resultMap.put("success", false);
            resultMap.put("message", "회사 정보 수정 중 오류가 발생했습니다: " + e.getMessage());
        }
        
        return resultMap;
    }
    
    /**
     * 회사 삭제
     * @param request
     * @param paramMap
     * @return
     */
    public Map<String, Object> deleteCompany(HttpServletRequest request, Map<String, Object> paramMap) {
        Map<String, Object> resultMap = new HashMap<>();
        
        try {
            String companyCode = CommonUtils.checkNull(paramMap.get("company_code"));
            
            if (companyCode.isEmpty()) {
                resultMap.put("success", false);
                resultMap.put("message", "회사 코드가 필요합니다.");
                return resultMap;
            }
            
            
            // 회사 정보 존재 여부 확인
            Map<String, Object> queryParam = new HashMap<>();
            queryParam.put("COMPANY_CODE", companyCode);
            Map<String, Object> companyInfo = sqlSessionTemplate.selectOne("admin.selectCompanyInfo", queryParam);
            
            if (companyInfo == null) {
                resultMap.put("success", false);
                resultMap.put("message", "삭제할 회사 정보를 찾을 수 없습니다.");
                return resultMap;
            }
            
            // 데이터베이스에서 회사 정보 삭제
            int deleteResult = sqlSessionTemplate.delete("admin.deleteCompany", queryParam);
            
            if (deleteResult > 0) {
                resultMap.put("success", true);
                resultMap.put("message", "회사가 성공적으로 삭제되었습니다.");
            } else {
                resultMap.put("success", false);
                resultMap.put("message", "회사 삭제에 실패했습니다.");
            }
            
        } catch (Exception e) {
            log.error("회사 삭제 중 오류 발생", e);
            resultMap.put("success", false);
            resultMap.put("message", "회사 삭제 중 오류가 발생했습니다: " + e.getMessage());
        }
        
        return resultMap;
    }
    
    /**
     * 순차적인 회사 코드 자동 생성 (COMPANY_1, COMPANY_2, ...)
     * 삭제된 번호는 재사용하지 않고 계속 증가
     * @return 생성된 회사 코드
     */
    private String generateSequentialCompanyCode() {
        try {
            // 시퀀스 테이블이 없으면 생성 및 기존 데이터 기반 초기화
            initializeCompanyCodeSequence();
            
            // 시퀀스 테이블에서 다음 번호 조회 (자동 증가)
            Integer nextSequence = sqlSessionTemplate.selectOne("admin.getNextCompanyCodeSequence");
            
            return "COMPANY_" + nextSequence;
            
        } catch (Exception e) {
            log.warn("회사 코드 생성 중 오류 발생, 기본값 사용", e);
            // 오류 발생 시 현재 시간을 이용한 기본값
            return "COMPANY_" + System.currentTimeMillis() % 10000;
        }
    }
    
    /**
     * 회사 코드 시퀀스 테이블 초기화
     * 기존 데이터를 고려하여 시퀀스 값 설정
     */
    private void initializeCompanyCodeSequence() {
        try {
            // 1. 시퀀스 테이블 생성 (IF NOT EXISTS로 안전)
            sqlSessionTemplate.update("admin.createCompanyCodeSequenceTable");
            
            // 2. 기존 데이터 기반으로 시퀀스 초기화 (이미 존재하면 스킵)
            sqlSessionTemplate.selectOne("admin.initializeCompanyCodeSequence");
            
        } catch (Exception e) {
            log.warn("시퀀스 테이블 초기화 중 오류 발생", e);
        }
    }
    

    
    // ========== 회사 관리 CRUD 메서드들 종료 ==========
    
    /**
     * 세션의 사용자 정보 업데이트
     * @param request
     * @param paramMap
     */
    private void updateSessionUserInfo(HttpServletRequest request, Map<String, Object> paramMap) {
        try {
            HttpSession session = request.getSession();
            PersonBean currentUser = (PersonBean) session.getAttribute(Constants.PERSON_BEAN);
            
            if (currentUser != null) {
                String userId = CommonUtils.checkNull(paramMap.get("userId"));
                
                // 현재 로그인한 사용자의 정보를 업데이트하는 경우에만 세션 갱신
                if (userId.equals(currentUser.getUserId())) {
                    // 데이터베이스에서 최신 사용자 정보 조회
                    Map<String, Object> userQueryParam = new HashMap<>();
                    userQueryParam.put("userId", userId);
                    
                    Map<String, Object> updatedUserInfo = sqlSessionTemplate.selectOne("user.getUserInfo", userQueryParam);
                    
                    if (updatedUserInfo != null) {
                        // PersonBean 업데이트
                        currentUser.setUserName((String) updatedUserInfo.get("USER_NAME"));
                        currentUser.setEmail((String) updatedUserInfo.get("EMAIL"));
                        currentUser.setDeptCode((String) updatedUserInfo.get("DEPT_CODE"));
                        currentUser.setDeptName((String) updatedUserInfo.get("DEPT_NAME"));
                        currentUser.setPositionCode((String) updatedUserInfo.get("POSITION_CODE"));
                        currentUser.setPositionName((String) updatedUserInfo.get("POSITION_NAME"));
                        currentUser.setLocale((String) updatedUserInfo.get("LOCALE"));
                        
                        // photo 데이터 업데이트 (중요!)
                        Object photoObj = updatedUserInfo.get("PHOTO");
                        if (photoObj != null && photoObj instanceof byte[]) {
                            currentUser.setPhoto((byte[]) photoObj);
                        }
                        
                        // 업데이트된 PersonBean을 세션에 저장
                        session.setAttribute(Constants.PERSON_BEAN, currentUser);
                    }
                }
            }
        } catch (Exception e) {
            // 세션 업데이트 실패는 로그만 남기고 계속 진행
            e.printStackTrace();
        }
    }
    
    /**
     * 회사 데이터 디버깅용 메서드
     */
    public void debugCompanyData() {
        try {
            log.info("=== 회사 데이터 디버깅 시작 ===");
            
            // COMPANY_MNG 테이블의 모든 데이터 조회
            List<Map<String, Object>> companyList = sqlSessionTemplate.selectList("admin.selectCompanyList", new HashMap<>());
            log.info("COMPANY_MNG 테이블 데이터 개수: {}", companyList.size());
            
            for (Map<String, Object> company : companyList) {
                log.info("회사 데이터: COMPANY_CODE={}, COMPANY_NAME={}", 
                    company.get("COMPANY_CODE"), company.get("COMPANY_NAME"));
            }
            
            // MENU_INFO 테이블의 회사 코드 분포 확인
            List<Map<String, Object>> menuCompanyStats = sqlSessionTemplate.selectList("admin.selectMenuCompanyStats");
            log.info("메뉴별 회사 코드 분포:");
            for (Map<String, Object> stat : menuCompanyStats) {
                log.info("  COMPANY_CODE={}, COUNT={}", 
                    stat.get("COMPANY_CODE"), stat.get("COUNT"));
            }
            
            log.info("=== 회사 데이터 디버깅 완료 ===");
            
        } catch (Exception e) {
            log.error("회사 데이터 디버깅 중 오류 발생", e);
        }
    }

    /**
     * 사용자 변경이력 목록 조회 (원본 JSP 로직 기반)
     */
    public List<Map<String, Object>> getUserHistoryList(HttpServletRequest request, Map<String, Object> paramMap) {
        List<Map<String, Object>> resultList = new ArrayList<>();
        
        try {
            // 컨트롤러에서 전달받은 파라미터 사용
            String page = paramMap.get("page") != null ? paramMap.get("page").toString() : "1";
            String countPerPage = paramMap.get("countPerPage") != null ? paramMap.get("countPerPage").toString() : "10";
            
            paramMap.put("COUNT_PER_PAGE", Integer.parseInt(countPerPage));
            
            // 페이징 정보 계산 (원본 방식)
            Map<String, Object> pageMap = sqlSessionTemplate.selectOne("admin.getUserHistoryListCnt", paramMap);
            
            if (pageMap != null) {
                // setPagingInfo 로직을 여기서 직접 구현
                int totalCnt = 0;
                if (pageMap.get("TOTAL_CNT") != null) {
                    totalCnt = ((Number) pageMap.get("TOTAL_CNT")).intValue();
                }
                
                int currentPage = Integer.parseInt(page);
                int pageSize = Integer.parseInt(countPerPage);
                int pageStart = (currentPage - 1) * pageSize + 1;
                int pageEnd = currentPage * pageSize;
                
                paramMap.put("PAGE_START", String.valueOf(pageStart));
                paramMap.put("PAGE_END", String.valueOf(pageEnd));
                
                // JSP에서 사용하는 추가 정보들도 request에 설정
                request.setAttribute("TOTAL_COUNT", totalCnt);
                request.setAttribute("MAX_PAGE_SIZE", pageMap.get("MAX_PAGE_SIZE"));
                
                log.info("사용자 변경이력 페이징 정보 - 총건수: {}, 현재페이지: {}, PAGE_START: {}, PAGE_END: {}, maxPageSize: {}", 
                    totalCnt, currentPage, pageStart, pageEnd, pageMap.get("MAX_PAGE_SIZE"));
                log.info("전달할 paramMap: {}", paramMap);
            }
            
            // 데이터 조회
            resultList = sqlSessionTemplate.selectList("admin.getUserHistoryList", paramMap);
            
            log.info("사용자 변경이력 조회 결과: {} 건", resultList.size());
            
        } catch (Exception e) {
            log.error("사용자 변경이력 목록 조회 중 오류 발생", e);
            e.printStackTrace();
        }
        
        return resultList;
    }

    /**
     * 사용자 변경이력 총 개수 조회 (원본 로직 기반)
     */
    public int getUserHistoryListCnt(HttpServletRequest request, Map<String, Object> paramMap) {
        try {
            Map<String, Object> result = sqlSessionTemplate.selectOne("admin.getUserHistoryListCnt", paramMap);
            if (result != null && result.get("TOTAL_CNT") != null) {
                Object totalCntObj = result.get("TOTAL_CNT");
                if (totalCntObj instanceof Number) {
                    return ((Number) totalCntObj).intValue();
                } else {
                    return Integer.parseInt(totalCntObj.toString());
                }
            }
            return 0;
        } catch (Exception e) {
            log.error("사용자 변경이력 총 개수 조회 중 오류 발생", e);
            return 0;
        }
    }

    /**
     * 사용자 비밀번호 초기화 (원본 JSP 로직 기반)
     * @param request
     * @param paramMap
     * @return
     */
    public Map<String, Object> resetUserPassword(HttpServletRequest request, Map<String, Object> paramMap) {
        Map<String, Object> resultMap = new HashMap<>();
        
        try {
            String userId = String.valueOf(paramMap.get("USER_ID"));
            String newPassword = String.valueOf(paramMap.get("NEW_PASSWORD"));
            
            log.info("비밀번호 초기화 처리 시작 - userId: {}", userId);
            
            // 입력값 검증
            if (userId == null || userId.trim().isEmpty()) {
                resultMap.put("result", "false");
                resultMap.put("msg", "사용자 ID가 필요합니다.");
                return resultMap;
            }
            
            if (newPassword == null || newPassword.trim().isEmpty()) {
                resultMap.put("result", "false");
                resultMap.put("msg", "새 비밀번호가 필요합니다.");
                return resultMap;
            }
            
            // 비밀번호 암호화 (원본 로직과 동일)
            EncryptUtil encryptUtil = new EncryptUtil();
            String encryptedPassword;
            try {
                encryptedPassword = encryptUtil.encrypt(newPassword);
            } catch (Exception e) {
                log.error("비밀번호 암호화 중 오류 발생", e);
                resultMap.put("result", "false");
                resultMap.put("msg", "비밀번호 암호화 중 오류가 발생했습니다.");
                return resultMap;
            }
            
            // 업데이트용 파라미터 설정
            Map<String, Object> updateParam = new HashMap<>();
            updateParam.put("USER_ID", userId);
            updateParam.put("USER_PWD", encryptedPassword);
            
            // 비밀번호 업데이트 실행
            int updateCount = sqlSessionTemplate.update("admin.updateUserPassword", updateParam);
            
            if (updateCount > 0) {
                // 성공 시 이력 저장
                HttpSession session = request.getSession();
                PersonBean person = (PersonBean) session.getAttribute(Constants.PERSON_BEAN);
                String writer = person != null ? person.getUserId() : "system";
                
                Map<String, Object> historyParam = new HashMap<>();
                historyParam.put("user_id", userId);
                historyParam.put("history_type", "비밀번호 초기화");
                historyParam.put("writer", writer);
                historyParam.put("reg_date", new java.util.Date());
                
                try {
                    sqlSessionTemplate.insert("admin.InsertUserInfoHistory", historyParam);
                } catch (Exception e) {
                    log.warn("비밀번호 초기화 이력 저장 실패", e);
                    // 이력 저장 실패해도 비밀번호 초기화는 성공으로 처리
                }
                
                resultMap.put("result", "true");
                resultMap.put("msg", "비밀번호가 성공적으로 초기화되었습니다.");
                log.info("비밀번호 초기화 성공 - userId: {}", userId);
            } else {
                resultMap.put("result", "false");
                resultMap.put("msg", "사용자 정보를 찾을 수 없거나 비밀번호 변경에 실패했습니다.");
                log.warn("비밀번호 초기화 실패 - 업데이트된 행 없음. userId: {}", userId);
            }
            
        } catch (Exception e) {
            log.error("비밀번호 초기화 중 오류 발생", e);
            resultMap.put("result", "false");
            resultMap.put("msg", "비밀번호 초기화 중 시스템 오류가 발생했습니다.");
        }
        
        return resultMap;
    }

    /**
     * 회사 목록 조회 (하드코딩 방식 - 기존 시스템 구조 반영)
     * @param request
     * @return
     */
    public List<Map<String, Object>> getCompanyList(HttpServletRequest request) {
        List<Map<String, Object>> companyList = new ArrayList<>();
        
        log.info("회사 목록 생성 시작");
        
        // 기존 시스템에서 사용하는 회사 코드들을 반영
        companyList.add(createCompanyMap("ILSHIN", "일신자동차부품"));
        companyList.add(createCompanyMap("HUTECH", "휴테크"));
        companyList.add(createCompanyMap("DAIN", "다인"));
        companyList.add(createCompanyMap("KUMHO", "금호"));
        
        log.info("회사 목록 생성 완료 - 총 {}개", companyList.size());
        
        return companyList;
    }
    
    /**
     * 회사 정보 Map 생성 헬퍼 메서드
     * @param code
     * @param name
     * @return
     */
    private Map<String, Object> createCompanyMap(String code, String name) {
        Map<String, Object> company = new HashMap<>();
        company.put("code", code);
        company.put("name", name);
        company.put("value", code); // 셀렉트박스 value용
        company.put("label", name); // 셀렉트박스 label용
        return company;
    }

}