ERP-node/backend/src/main/java/com/pms/controller/MultiLangController.java

package com.pms.controller;

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

import jakarta.servlet.http.HttpServletRequest;

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.pms.service.MultiLangService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@RestController
@RequestMapping("/multilang")
@RequiredArgsConstructor
public class MultiLangController {

    private final MultiLangService multiLangService;

    // 성공 응답 생성
    private Map<String, Object> createSuccessResponse(Object data) {
        Map<String, Object> response = new HashMap<>();
        response.put("success", true);
        response.put("data", data);
        return response;
    }

    // 오류 응답 생성
    private Map<String, Object> createErrorResponse(String message, String detail) {
        Map<String, Object> response = new HashMap<>();
        response.put("success", false);
        response.put("message", message);
        response.put("detail", detail);
        return response;
    }

    // 회사 목록 조회
    @GetMapping("/companies")
    public ResponseEntity<Map<String, Object>> getCompanies() {
        try {
            List<Map<String, Object>> companies = multiLangService.getCompanies();
            return ResponseEntity.ok(createSuccessResponse(companies));
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(createErrorResponse("회사 목록 조회 실패", e.getMessage()));
        }
    }

    // 언어 마스터 조회
    @GetMapping("/languages")
    public ResponseEntity<Map<String, Object>> getLanguages() {
        try {
            List<Map<String, Object>> languages = multiLangService.getLanguages();
            return ResponseEntity.ok(createSuccessResponse(languages));
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(createErrorResponse("언어 목록 조회 실패", e.getMessage()));
        }
    }

    // 언어 추가
    @PostMapping("/languages")
    public ResponseEntity<Map<String, Object>> createLanguage(@RequestBody Map<String, Object> languageData) {
        try {
            String langCode = multiLangService.createLanguage(languageData);
            return ResponseEntity.ok(createSuccessResponse(langCode));
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(createErrorResponse("언어 추가 실패", e.getMessage()));
        }
    }

    // 언어 수정
    @PutMapping("/languages/{langId}")
    public ResponseEntity<Map<String, Object>> updateLanguage(
            @PathVariable Integer langId, 
            @RequestBody Map<String, Object> languageData) {
        try {
            languageData.put("langId", langId);
            multiLangService.updateLanguage(languageData);
            return ResponseEntity.ok(createSuccessResponse("언어 수정 완료"));
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(createErrorResponse("언어 수정 실패", e.getMessage()));
        }
    }

    // 언어 삭제
    @DeleteMapping("/languages/{langCode}")
    public ResponseEntity<Map<String, Object>> deleteLanguage(@PathVariable String langCode) {
        try {
            multiLangService.deleteLanguage(langCode);
            return ResponseEntity.ok(createSuccessResponse("언어 삭제 완료"));
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(createErrorResponse("언어 삭제 실패", e.getMessage()));
        }
    }

    // 언어 활성/비활성 토글
    @PutMapping("/languages/{langCode}/toggle")
    public ResponseEntity<Map<String, Object>> toggleLanguage(@PathVariable String langCode) {
        try {
            String result = multiLangService.toggleLanguage(langCode);
            return ResponseEntity.ok(createSuccessResponse(result));
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(createErrorResponse("언어 상태 변경 실패", e.getMessage()));
        }
    }

    // 회사별 다국어 키 목록 조회
    @GetMapping("/keys")
    public ResponseEntity<Map<String, Object>> getLangKeys(
            @RequestParam(required = false) String companyCode,
            @RequestParam(required = false) String menuCode,
            @RequestParam(required = false) String keyType,
            @RequestParam(required = false) String searchText) {
        try {
            Map<String, Object> params = new HashMap<>();
            params.put("companyCode", companyCode);
            params.put("menuCode", menuCode);
            params.put("keyType", keyType);
            params.put("searchText", searchText);
            
            log.info("다국어 키 조회 파라미터: companyCode={}, menuCode={}, keyType={}, searchText={}", 
                    companyCode, menuCode, keyType, searchText);
            
            List<Map<String, Object>> keys = multiLangService.getLangKeys(params);
            return ResponseEntity.ok(createSuccessResponse(keys));
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(createErrorResponse("다국어 키 목록 조회 실패", e.getMessage()));
        }
    }

    // 특정 키의 다국어 텍스트 조회
    @GetMapping("/keys/{keyId}/texts")
    public ResponseEntity<Map<String, Object>> getLangTexts(@PathVariable Integer keyId) {
        try {
            List<Map<String, Object>> texts = multiLangService.getLangTexts(keyId);
            return ResponseEntity.ok(createSuccessResponse(texts));
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(createErrorResponse("다국어 텍스트 조회 실패", e.getMessage()));
        }
    }

    // 사용자별 다국어 텍스트 조회 (프론트엔드용)
    @GetMapping("/user-text/{companyCode}/{menuCode}/{langKey}")
    public ResponseEntity<Map<String, Object>> getUserText(
            @PathVariable String companyCode,
            @PathVariable String menuCode,
            @PathVariable String langKey,
            @RequestParam String userLang) {
        
        System.out.println("🌐 다국어 API 호출: " + companyCode + "/" + menuCode + "/" + langKey + " (lang: " + userLang + ")");
        
        try {
            String text = multiLangService.getUserText(companyCode, menuCode, langKey, userLang);
            System.out.println("🌐 다국어 API 응답: " + text);
            return ResponseEntity.ok(createSuccessResponse(text));
        } catch (Exception e) {
            System.err.println("❌ 다국어 API 오류: " + e.getMessage());
            e.printStackTrace();
            return ResponseEntity.badRequest().body(createErrorResponse("사용자 텍스트 조회 실패", e.getMessage()));
        }
    }

    // 다국어 키 생성
    @PostMapping("/keys")
    public ResponseEntity<Map<String, Object>> createLangKey(@RequestBody Map<String, Object> keyData) {
        try {
            Integer keyId = multiLangService.createLangKey(keyData);
            return ResponseEntity.ok(createSuccessResponse(keyId));
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(createErrorResponse("중복된 키 입니다.", e.getMessage()));
        }
    }

    // 다국어 키 수정
    @PutMapping("/keys/{keyId}")
    public ResponseEntity<Map<String, Object>> updateLangKey(
            @PathVariable Integer keyId, 
            @RequestBody Map<String, Object> keyData) {
        try {
            keyData.put("keyId", keyId);
            multiLangService.updateLangKey(keyData);
            return ResponseEntity.ok(createSuccessResponse("수정 완료"));
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(createErrorResponse("다국어 키 수정 실패", e.getMessage()));
        }
    }

    // 다국어 키 삭제
    @DeleteMapping("/keys/{keyId}")
    public ResponseEntity<Map<String, Object>> deleteLangKey(@PathVariable Integer keyId) {
        try {
            multiLangService.deleteLangKey(keyId);
            return ResponseEntity.ok(createSuccessResponse("삭제 완료"));
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(createErrorResponse("다국어 키 삭제 실패", e.getMessage()));
        }
    }

    // 다국어 키 활성/비활성 토글
    @PutMapping("/keys/{keyId}/toggle")
    public ResponseEntity<Map<String, Object>> toggleLangKey(@PathVariable Integer keyId) {
        try {
            String result = multiLangService.toggleLangKey(keyId);
            return ResponseEntity.ok(createSuccessResponse(result));
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(createErrorResponse("다국어 키 상태 변경 실패", e.getMessage()));
        }
    }

    // 다국어 텍스트 저장/수정
    @PostMapping("/keys/{keyId}/texts")
    public ResponseEntity<Map<String, Object>> saveLangTexts(
            @PathVariable Integer keyId, 
            @RequestBody List<Map<String, Object>> textData) {
        try {
            multiLangService.saveLangTexts(keyId, textData);
            return ResponseEntity.ok(createSuccessResponse("저장 완료"));
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(createErrorResponse("다국어 텍스트 저장 실패", e.getMessage()));
        }
    }

    // 특정 키의 다국어 텍스트 조회 (회사, 키, 언어별)
    @GetMapping("/text/{companyCode}/{langKey}/{langCode}")
    public ResponseEntity<Map<String, Object>> getLangText(
            @PathVariable String companyCode,
            @PathVariable String langKey,
            @PathVariable String langCode) {
        try {
            String text = multiLangService.getLangText(companyCode, langKey, langCode);
            return ResponseEntity.ok(createSuccessResponse(text));
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(createErrorResponse("다국어 텍스트 조회 실패", e.getMessage()));
        }
    }

    // 사용자 언어별 다국어 텍스트 조회
    @GetMapping("/user-text/{companyCode}/{langKey}")
    public ResponseEntity<Map<String, Object>> getUserLangText(
            @PathVariable String companyCode,
            @PathVariable String langKey,
            @RequestParam(defaultValue = "ko") String userLang) {
        try {
            String text = multiLangService.getLangText(companyCode, langKey, userLang);
            return ResponseEntity.ok(createSuccessResponse(text));
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(createErrorResponse("사용자 다국어 텍스트 조회 실패", e.getMessage()));
        }
    }

    // 테스트 엔드포인트
    @GetMapping("/test")
    public ResponseEntity<Map<String, Object>> test() {
        return ResponseEntity.ok(createSuccessResponse("MultiLangController is working!"));
    }

    // 데이터베이스 연결 테스트
    @GetMapping("/test-db")
    public ResponseEntity<Map<String, Object>> testDb() {
        try {
            String result = multiLangService.testConnection();
            return ResponseEntity.ok(createSuccessResponse("DB 연결 성공: " + result));
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(createErrorResponse("DB 연결 실패", e.getMessage()));
        }
    }

}