package com.erp.controller;

import com.erp.dto.ApiResponse;
import com.erp.service.RoleService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

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

@RestController
@RequestMapping("/api/roles")
@RequiredArgsConstructor
@Slf4j
public class RoleController {

    private final RoleService roleService;

    // ──────────────────────────────────────────────────
    // 권한 그룹 CRUD
    // ──────────────────────────────────────────────────

    /**
     * GET /api/roles
     * 권한 그룹 목록 조회 (관리자 전용)
     */
    @GetMapping
    public ResponseEntity<ApiResponse<List<Map<String, Object>>>> getRoleGroups(
            @RequestAttribute("company_code") String companyCode,
            @RequestAttribute("role") String role,
            @RequestParam Map<String, Object> params) {

        if (!isAdmin(role)) {
            return ResponseEntity.status(403).body(ApiResponse.error("관리자 권한이 필요합니다."));
        }

        if (!isSuperAdmin(role)) {
            params.put("company_code", companyCode);
        }

        return ResponseEntity.ok(ApiResponse.success(roleService.getRoleGroups(params), "권한 그룹 목록 조회 성공"));
    }

    /**
     * GET /api/roles/{id}
     * 권한 그룹 상세 조회
     */
    @GetMapping("/{id}")
    public ResponseEntity<ApiResponse<Map<String, Object>>> getRoleGroupById(
            @PathVariable String id,
            @RequestAttribute("company_code") String companyCode,
            @RequestAttribute("role") String role) {

        if (!isAdmin(role)) {
            return ResponseEntity.status(403).body(ApiResponse.error("관리자 권한이 필요합니다."));
        }

        Map<String, Object> params = new HashMap<>();
        params.put("objid", id);

        Map<String, Object> group = roleService.getRoleGroupById(params);
        if (group == null) {
            return ResponseEntity.status(404).body(ApiResponse.error("권한 그룹을 찾을 수 없습니다."));
        }

        if (!isSuperAdmin(role) && !companyCode.equals(group.get("company_code"))) {
            return ResponseEntity.status(403).body(ApiResponse.error("권한이 없습니다."));
        }

        return ResponseEntity.ok(ApiResponse.success(group, "권한 그룹 상세 조회 성공"));
    }

    /**
     * POST /api/roles
     * 권한 그룹 생성
     */
    @PostMapping
    public ResponseEntity<ApiResponse<Map<String, Object>>> createRoleGroup(
            @RequestAttribute("company_code") String companyCode,
            @RequestAttribute("role") String role,
            @RequestAttribute("user_id") String userId,
            @RequestBody Map<String, Object> body) {

        if (!isAdmin(role)) {
            return ResponseEntity.status(403).body(ApiResponse.error("관리자 권한이 필요합니다."));
        }

        String targetCompany = (String) body.get("company_code");
        if (!isSuperAdmin(role) && !companyCode.equals(targetCompany)) {
            return ResponseEntity.status(403).body(ApiResponse.error("다른 회사의 권한 그룹을 생성할 수 없습니다."));
        }

        Map<String, Object> params = new HashMap<>(body);
        params.put("writer", userId);
        // objid는 varchar — 타임스탬프 기반 유니크 문자열
        params.put("objid", "AM" + System.currentTimeMillis());

        if (params.containsKey("role_name") && !params.containsKey("auth_name")) {
            params.put("auth_name", params.get("role_name"));
        }
        if (params.containsKey("role_code") && !params.containsKey("auth_code")) {
            params.put("auth_code", params.get("role_code"));
        }

        Map<String, Object> created = roleService.createRoleGroup(params);
        return ResponseEntity.status(201).body(ApiResponse.success(created, "권한 그룹 생성 성공"));
    }

    /**
     * PUT /api/roles/{id}
     * 권한 그룹 수정
     */
    @PutMapping("/{id}")
    public ResponseEntity<ApiResponse<Map<String, Object>>> updateRoleGroup(
            @PathVariable String id,
            @RequestAttribute("company_code") String companyCode,
            @RequestAttribute("role") String role,
            @RequestAttribute("user_id") String userId,
            @RequestBody Map<String, Object> body) {

        if (!isAdmin(role)) {
            return ResponseEntity.status(403).body(ApiResponse.error("관리자 권한이 필요합니다."));
        }

        Map<String, Object> findParams = Map.of("objid", id);
        Map<String, Object> existing = roleService.getRoleGroupById(findParams);
        if (existing == null) {
            return ResponseEntity.status(404).body(ApiResponse.error("권한 그룹을 찾을 수 없습니다."));
        }

        if (!isSuperAdmin(role) && !companyCode.equals(existing.get("company_code"))) {
            return ResponseEntity.status(403).body(ApiResponse.error("권한이 없습니다."));
        }

        Map<String, Object> params = new HashMap<>(body);
        params.put("objid", id);
        params.put("writer", userId);

        if (params.containsKey("role_name") && !params.containsKey("auth_name")) {
            params.put("auth_name", params.get("role_name"));
        }
        if (params.containsKey("role_code") && !params.containsKey("auth_code")) {
            params.put("auth_code", params.get("role_code"));
        }

        Map<String, Object> updated = roleService.updateRoleGroup(params);
        return ResponseEntity.ok(ApiResponse.success(updated, "권한 그룹 수정 성공"));
    }

    /**
     * DELETE /api/roles/{id}
     * 권한 그룹 삭제
     */
    @DeleteMapping("/{id}")
    public ResponseEntity<ApiResponse<Void>> deleteRoleGroup(
            @PathVariable String id,
            @RequestAttribute("company_code") String companyCode,
            @RequestAttribute("role") String role) {

        if (!isAdmin(role)) {
            return ResponseEntity.status(403).body(ApiResponse.error("관리자 권한이 필요합니다."));
        }

        Map<String, Object> findParams = Map.of("objid", id);
        Map<String, Object> existing = roleService.getRoleGroupById(findParams);
        if (existing == null) {
            return ResponseEntity.status(404).body(ApiResponse.error("권한 그룹을 찾을 수 없습니다."));
        }

        if (!isSuperAdmin(role) && !companyCode.equals(existing.get("company_code"))) {
            return ResponseEntity.status(403).body(ApiResponse.error("권한이 없습니다."));
        }

        Map<String, Object> params = new HashMap<>();
        params.put("objid", id);
        roleService.deleteRoleGroup(params);
        return ResponseEntity.ok(ApiResponse.success(null, "권한 그룹 삭제 성공"));
    }

    // ──────────────────────────────────────────────────
    // 통합 워크스페이스 (이미지 요구사항: 선택 시 한 번에 로드)
    // ──────────────────────────────────────────────────

    /**
     * GET /api/roles/{id}/workspace
     * 권한 그룹 선택 시 필요한 모든 정보 한 번에 반환:
     *  - group: 권한 그룹 정보
     *  - members: 권한있는 직원
     *  - nonMembers: 권한없는 직원
     *  - menus: 전체 메뉴 (트리 원천)
     *  - permissions: 현재 메뉴 CRUD 권한
     */
    @GetMapping("/{id}/workspace")
    public ResponseEntity<ApiResponse<Map<String, Object>>> getRoleWorkspace(
            @PathVariable String id,
            @RequestAttribute("company_code") String companyCode,
            @RequestAttribute("role") String role) {

        if (!isAdmin(role)) {
            return ResponseEntity.status(403).body(ApiResponse.error("관리자 권한이 필요합니다."));
        }

        Map<String, Object> workspace = roleService.getRoleWorkspace(id);
        if (workspace == null) {
            return ResponseEntity.status(404).body(ApiResponse.error("권한 그룹을 찾을 수 없습니다."));
        }

        @SuppressWarnings("unchecked")
        Map<String, Object> group = (Map<String, Object>) workspace.get("group");
        if (!isSuperAdmin(role) && !companyCode.equals(group.get("company_code"))) {
            return ResponseEntity.status(403).body(ApiResponse.error("권한이 없습니다."));
        }

        return ResponseEntity.ok(ApiResponse.success(workspace, "권한 그룹 워크스페이스 조회 성공"));
    }

    // ──────────────────────────────────────────────────
    // 멤버 관리
    // ──────────────────────────────────────────────────

    /**
     * GET /api/roles/user/my-groups
     * 현재 로그인 사용자의 권한 그룹 조회
     */
    @GetMapping("/user/my-groups")
    public ResponseEntity<ApiResponse<List<Map<String, Object>>>> getMyRoleGroups(
            @RequestAttribute("user_id") String userId,
            @RequestAttribute("company_code") String companyCode) {

        Map<String, Object> params = new HashMap<>();
        params.put("user_id", userId);
        params.put("company_code", companyCode);
        return ResponseEntity.ok(ApiResponse.success(roleService.getUserRoleGroups(params), "사용자 권한 그룹 조회 성공"));
    }

    /**
     * GET /api/roles/menus/all
     * 전체 메뉴 목록 조회 (권한 설정용, 트리 원천)
     */
    @GetMapping("/menus/all")
    public ResponseEntity<ApiResponse<List<Map<String, Object>>>> getAllMenus(
            @RequestAttribute("company_code") String companyCode,
            @RequestAttribute("role") String role,
            @RequestParam(value = "company_code", required = false) String requestedCompanyCode) {

        if (!isAdmin(role)) {
            return ResponseEntity.status(403).body(ApiResponse.error("관리자 권한이 필요합니다."));
        }

        Map<String, Object> params = new HashMap<>();
        if (isSuperAdmin(role)) {
            params.put("company_code", requestedCompanyCode);
        } else {
            params.put("company_code", companyCode);
        }

        return ResponseEntity.ok(ApiResponse.success(roleService.getAllMenus(params), "메뉴 목록 조회 성공"));
    }

    /**
     * GET /api/roles/{id}/members
     * 권한있는 직원 목록 조회
     */
    @GetMapping("/{id}/members")
    public ResponseEntity<ApiResponse<List<Map<String, Object>>>> getRoleMembers(
            @PathVariable String id,
            @RequestAttribute("company_code") String companyCode,
            @RequestAttribute("role") String role) {

        if (!isAdmin(role)) {
            return ResponseEntity.status(403).body(ApiResponse.error("관리자 권한이 필요합니다."));
        }

        Map<String, Object> group = roleService.getRoleGroupById(Map.of("objid", id));
        if (group == null) {
            return ResponseEntity.status(404).body(ApiResponse.error("권한 그룹을 찾을 수 없습니다."));
        }
        if (!isSuperAdmin(role) && !companyCode.equals(group.get("company_code"))) {
            return ResponseEntity.status(403).body(ApiResponse.error("권한이 없습니다."));
        }

        Map<String, Object> params = new HashMap<>();
        params.put("master_objid", id);
        return ResponseEntity.ok(ApiResponse.success(roleService.getRoleMembers(params), "권한있는 직원 조회 성공"));
    }

    /**
     * GET /api/roles/{id}/non-members
     * 권한없는 직원 목록 조회 (같은 회사)
     */
    @GetMapping("/{id}/non-members")
    public ResponseEntity<ApiResponse<List<Map<String, Object>>>> getRoleNonMembers(
            @PathVariable String id,
            @RequestAttribute("company_code") String companyCode,
            @RequestAttribute("role") String role) {

        if (!isAdmin(role)) {
            return ResponseEntity.status(403).body(ApiResponse.error("관리자 권한이 필요합니다."));
        }

        Map<String, Object> group = roleService.getRoleGroupById(Map.of("objid", id));
        if (group == null) {
            return ResponseEntity.status(404).body(ApiResponse.error("권한 그룹을 찾을 수 없습니다."));
        }
        if (!isSuperAdmin(role) && !companyCode.equals(group.get("company_code"))) {
            return ResponseEntity.status(403).body(ApiResponse.error("권한이 없습니다."));
        }

        Map<String, Object> params = new HashMap<>();
        params.put("master_objid", id);
        params.put("company_code", group.get("company_code"));
        params.put("status_active", true);
        return ResponseEntity.ok(ApiResponse.success(roleService.getRoleNonMembers(params), "권한없는 직원 조회 성공"));
    }

    /**
     * POST /api/roles/{id}/members
     * 권한 그룹 멤버 일괄 추가 (body: { user_ids: [...] })
     */
    @PostMapping("/{id}/members")
    public ResponseEntity<ApiResponse<Void>> addRoleMembers(
            @PathVariable String id,
            @RequestAttribute("company_code") String companyCode,
            @RequestAttribute("role") String role,
            @RequestAttribute("user_id") String currentUserId,
            @RequestBody Map<String, Object> body) {

        if (!isAdmin(role)) {
            return ResponseEntity.status(403).body(ApiResponse.error("관리자 권한이 필요합니다."));
        }

        Map<String, Object> group = roleService.getRoleGroupById(Map.of("objid", id));
        if (group == null) {
            return ResponseEntity.status(404).body(ApiResponse.error("권한 그룹을 찾을 수 없습니다."));
        }
        if (!isSuperAdmin(role) && !companyCode.equals(group.get("company_code"))) {
            return ResponseEntity.status(403).body(ApiResponse.error("권한이 없습니다."));
        }

        Map<String, Object> params = new HashMap<>(body);
        params.put("master_objid", id);
        params.put("writer", currentUserId);
        roleService.addRoleMembers(params);
        return ResponseEntity.ok(ApiResponse.success(null, "권한 그룹 멤버 추가 성공"));
    }

    /**
     * POST /api/roles/{id}/members/{userId}
     * 개별 멤버 추가 (이미지: "<--추가" 체크 즉시 반영)
     */
    @PostMapping("/{id}/members/{userId}")
    public ResponseEntity<ApiResponse<Map<String, Object>>> addSingleRoleMember(
            @PathVariable String id,
            @PathVariable String userId,
            @RequestAttribute("company_code") String companyCode,
            @RequestAttribute("role") String role,
            @RequestAttribute("user_id") String currentUserId) {

        if (!isAdmin(role)) {
            return ResponseEntity.status(403).body(ApiResponse.error("관리자 권한이 필요합니다."));
        }

        Map<String, Object> group = roleService.getRoleGroupById(Map.of("objid", id));
        if (group == null) {
            return ResponseEntity.status(404).body(ApiResponse.error("권한 그룹을 찾을 수 없습니다."));
        }
        if (!isSuperAdmin(role) && !companyCode.equals(group.get("company_code"))) {
            return ResponseEntity.status(403).body(ApiResponse.error("권한이 없습니다."));
        }

        boolean inserted = roleService.addSingleRoleMember(id, userId, currentUserId);
        Map<String, Object> result = new HashMap<>();
        result.put("inserted", inserted);
        result.put("master_objid", id);
        result.put("user_id", userId);
        return ResponseEntity.ok(ApiResponse.success(result,
                inserted ? "멤버 추가 성공" : "이미 멤버입니다."));
    }

    /**
     * PUT /api/roles/{id}/members
     * 권한 그룹 멤버 일괄 업데이트 (diff 방식)
     */
    @PutMapping("/{id}/members")
    public ResponseEntity<ApiResponse<Void>> updateRoleMembers(
            @PathVariable String id,
            @RequestAttribute("company_code") String companyCode,
            @RequestAttribute("role") String role,
            @RequestAttribute("user_id") String currentUserId,
            @RequestBody Map<String, Object> body) {

        if (!isAdmin(role)) {
            return ResponseEntity.status(403).body(ApiResponse.error("관리자 권한이 필요합니다."));
        }

        Map<String, Object> group = roleService.getRoleGroupById(Map.of("objid", id));
        if (group == null) {
            return ResponseEntity.status(404).body(ApiResponse.error("권한 그룹을 찾을 수 없습니다."));
        }
        if (!isSuperAdmin(role) && !companyCode.equals(group.get("company_code"))) {
            return ResponseEntity.status(403).body(ApiResponse.error("권한이 없습니다."));
        }

        Map<String, Object> params = new HashMap<>(body);
        params.put("master_objid", id);
        params.put("writer", currentUserId);
        roleService.updateRoleMembers(params);
        return ResponseEntity.ok(ApiResponse.success(null, "권한 그룹 멤버 업데이트 성공"));
    }

    /**
     * DELETE /api/roles/{id}/members
     * 권한 그룹 멤버 일괄 제거 (body: { user_ids: [...] })
     */
    @DeleteMapping("/{id}/members")
    public ResponseEntity<ApiResponse<Void>> removeRoleMembers(
            @PathVariable String id,
            @RequestAttribute("company_code") String companyCode,
            @RequestAttribute("role") String role,
            @RequestBody Map<String, Object> body) {

        if (!isAdmin(role)) {
            return ResponseEntity.status(403).body(ApiResponse.error("관리자 권한이 필요합니다."));
        }

        Map<String, Object> group = roleService.getRoleGroupById(Map.of("objid", id));
        if (group == null) {
            return ResponseEntity.status(404).body(ApiResponse.error("권한 그룹을 찾을 수 없습니다."));
        }
        if (!isSuperAdmin(role) && !companyCode.equals(group.get("company_code"))) {
            return ResponseEntity.status(403).body(ApiResponse.error("권한이 없습니다."));
        }

        Map<String, Object> params = new HashMap<>(body);
        params.put("master_objid", id);
        roleService.removeRoleMembers(params);
        return ResponseEntity.ok(ApiResponse.success(null, "권한 그룹 멤버 제거 성공"));
    }

    /**
     * DELETE /api/roles/{id}/members/{userId}
     * 개별 멤버 제거 (이미지: "-->삭제" 체크 즉시 반영)
     */
    @DeleteMapping("/{id}/members/{userId}")
    public ResponseEntity<ApiResponse<Map<String, Object>>> removeSingleRoleMember(
            @PathVariable String id,
            @PathVariable String userId,
            @RequestAttribute("company_code") String companyCode,
            @RequestAttribute("role") String role) {

        if (!isAdmin(role)) {
            return ResponseEntity.status(403).body(ApiResponse.error("관리자 권한이 필요합니다."));
        }

        Map<String, Object> group = roleService.getRoleGroupById(Map.of("objid", id));
        if (group == null) {
            return ResponseEntity.status(404).body(ApiResponse.error("권한 그룹을 찾을 수 없습니다."));
        }
        if (!isSuperAdmin(role) && !companyCode.equals(group.get("company_code"))) {
            return ResponseEntity.status(403).body(ApiResponse.error("권한이 없습니다."));
        }

        boolean deleted = roleService.removeSingleRoleMember(id, userId);
        Map<String, Object> result = new HashMap<>();
        result.put("deleted", deleted);
        result.put("master_objid", id);
        result.put("user_id", userId);
        return ResponseEntity.ok(ApiResponse.success(result,
                deleted ? "멤버 제거 성공" : "멤버가 존재하지 않습니다."));
    }

    // ──────────────────────────────────────────────────
    // 메뉴 권한 관리
    // ──────────────────────────────────────────────────

    /**
     * GET /api/roles/{id}/menu-permissions
     * 메뉴 권한 목록 조회
     */
    @GetMapping("/{id}/menu-permissions")
    public ResponseEntity<ApiResponse<List<Map<String, Object>>>> getMenuPermissions(
            @PathVariable String id,
            @RequestAttribute("company_code") String companyCode,
            @RequestAttribute("role") String role) {

        if (!isAdmin(role)) {
            return ResponseEntity.status(403).body(ApiResponse.error("관리자 권한이 필요합니다."));
        }

        Map<String, Object> group = roleService.getRoleGroupById(Map.of("objid", id));
        if (group == null) {
            return ResponseEntity.status(404).body(ApiResponse.error("권한 그룹을 찾을 수 없습니다."));
        }
        if (!isSuperAdmin(role) && !companyCode.equals(group.get("company_code"))) {
            return ResponseEntity.status(403).body(ApiResponse.error("권한이 없습니다."));
        }

        Map<String, Object> params = new HashMap<>();
        params.put("auth_objid", id);
        return ResponseEntity.ok(ApiResponse.success(roleService.getMenuPermissions(params), "메뉴 권한 조회 성공"));
    }

    /**
     * PUT /api/roles/{id}/menu-permissions
     * 메뉴 권한 일괄 설정 (전체 교체)
     */
    @PutMapping("/{id}/menu-permissions")
    public ResponseEntity<ApiResponse<Void>> setMenuPermissions(
            @PathVariable String id,
            @RequestAttribute("company_code") String companyCode,
            @RequestAttribute("role") String role,
            @RequestAttribute("user_id") String currentUserId,
            @RequestBody Map<String, Object> body) {

        if (!isAdmin(role)) {
            return ResponseEntity.status(403).body(ApiResponse.error("관리자 권한이 필요합니다."));
        }

        Map<String, Object> group = roleService.getRoleGroupById(Map.of("objid", id));
        if (group == null) {
            return ResponseEntity.status(404).body(ApiResponse.error("권한 그룹을 찾을 수 없습니다."));
        }
        if (!isSuperAdmin(role) && !companyCode.equals(group.get("company_code"))) {
            return ResponseEntity.status(403).body(ApiResponse.error("권한이 없습니다."));
        }

        Map<String, Object> params = new HashMap<>(body);
        params.put("auth_objid", id);
        params.put("writer", currentUserId);
        roleService.setMenuPermissions(params);
        return ResponseEntity.ok(ApiResponse.success(null, "메뉴 권한 설정 성공"));
    }

    /**
     * PATCH /api/roles/{id}/menu-permissions/{menuObjid}
     * 개별 메뉴 CRUD 권한 토글 (이미지: 체크 즉시 반영)
     * body: { create_yn?, read_yn?, update_yn?, delete_yn? } — 전달된 필드만 업데이트
     */
    @PatchMapping("/{id}/menu-permissions/{menuObjid}")
    public ResponseEntity<ApiResponse<Map<String, Object>>> toggleMenuPermission(
            @PathVariable String id,
            @PathVariable String menuObjid,
            @RequestAttribute("company_code") String companyCode,
            @RequestAttribute("role") String role,
            @RequestAttribute("user_id") String currentUserId,
            @RequestBody(required = false) Map<String, Object> body) {

        if (!isAdmin(role)) {
            return ResponseEntity.status(403).body(ApiResponse.error("관리자 권한이 필요합니다."));
        }

        Map<String, Object> group = roleService.getRoleGroupById(Map.of("objid", id));
        if (group == null) {
            return ResponseEntity.status(404).body(ApiResponse.error("권한 그룹을 찾을 수 없습니다."));
        }
        if (!isSuperAdmin(role) && !companyCode.equals(group.get("company_code"))) {
            return ResponseEntity.status(403).body(ApiResponse.error("권한이 없습니다."));
        }

        Map<String, Object> payload = body != null ? body : new HashMap<>();
        String createYn = asYn(payload.get("create_yn"));
        String readYn   = asYn(payload.get("read_yn"));
        String updateYn = asYn(payload.get("update_yn"));
        String deleteYn = asYn(payload.get("delete_yn"));

        Map<String, Object> result = roleService.toggleMenuPermission(
                id, menuObjid, createYn, readYn, updateYn, deleteYn, currentUserId);

        return ResponseEntity.ok(ApiResponse.success(result, "메뉴 권한 토글 성공"));
    }

    /**
     * GET /api/roles/user/{userId}/groups
     * 특정 사용자의 권한 그룹 조회
     */
    @GetMapping("/user/{userId}/groups")
    public ResponseEntity<ApiResponse<List<Map<String, Object>>>> getUserRoleGroups(
            @PathVariable String userId,
            @RequestAttribute("company_code") String companyCode,
            @RequestAttribute("role") String role) {

        if (!isAdmin(role)) {
            return ResponseEntity.status(403).body(ApiResponse.error("관리자 권한이 필요합니다."));
        }

        Map<String, Object> params = new HashMap<>();
        params.put("user_id", userId);
        params.put("company_code", isSuperAdmin(role) ? null : companyCode);
        return ResponseEntity.ok(ApiResponse.success(roleService.getUserRoleGroups(params), "사용자 권한 그룹 조회 성공"));
    }

    // ──────────────────────────────────────────────────
    // 내부 유틸
    // ──────────────────────────────────────────────────

    private boolean isSuperAdmin(String role) {
        return "SUPER_ADMIN".equals(role);
    }

    private boolean isAdmin(String role) {
        return "SUPER_ADMIN".equals(role) || "ADMIN".equals(role) || "COMPANY_ADMIN".equals(role);
    }

    /**
     * 다양한 입력(true/false/"Y"/"N"/null)을 "Y"/"N"/null 로 정규화
     */
    private String asYn(Object raw) {
        if (raw == null) return null;
        if (raw instanceof Boolean b) return b ? "Y" : "N";
        String s = String.valueOf(raw).trim();
        if (s.isEmpty()) return null;
        if ("Y".equalsIgnoreCase(s) || "true".equalsIgnoreCase(s) || "1".equals(s)) return "Y";
        if ("N".equalsIgnoreCase(s) || "false".equalsIgnoreCase(s) || "0".equals(s)) return "N";
        return null;
    }
}
