package com.pms.service;

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

import org.apache.ibatis.session.SqlSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.pms.common.SqlMapConfig;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class MultiLangService {

    @Autowired
    private SqlSession sqlSession;

    // 회사 목록 조회
    public List<Map<String, Object>> getCompanies() {
        try {
            log.info("회사 목록 조회 시작");
            List<Map<String, Object>> result = sqlSession.selectList("multilang.selectCompanies");
            log.info("회사 목록 조회 완료: {}개", result != null ? result.size() : 0);
            return result;
        } catch (Exception e) {
            log.error("회사 목록 조회 중 오류 발생", e);
            throw e;
        }
    }

    // 언어 마스터 조회
    public List<Map<String, Object>> getLanguages() {
        try {
            log.info("다국어 언어 목록 조회 시작");
            List<Map<String, Object>> result = sqlSession.selectList("multilang.selectLanguages");
            log.info("다국어 언어 목록 조회 완료: {}개", result != null ? result.size() : 0);
            return result;
        } catch (Exception e) {
            log.error("다국어 언어 목록 조회 중 오류 발생", e);
            throw e;
        }
    }

    // 언어 추가
    @Transactional
    public String createLanguage(Map<String, Object> languageData) {
        try {
            log.info("언어 추가 시작: {}", languageData);
            sqlSession.insert("multilang.insertLanguage", languageData);
            String langCode = (String) languageData.get("langCode");
            log.info("언어 추가 완료: langCode = {}", langCode);
            return langCode;
        } catch (Exception e) {
            log.error("언어 추가 중 오류 발생", e);
            throw e;
        }
    }

    // 언어 수정
    @Transactional
    public void updateLanguage(Map<String, Object> languageData) {
        try {
            log.info("언어 수정 시작: {}", languageData);
            sqlSession.update("multilang.updateLanguage", languageData);
            log.info("언어 수정 완료");
        } catch (Exception e) {
            log.error("언어 수정 중 오류 발생", e);
            throw e;
        }
    }

    // 언어 삭제
    @Transactional
    public void deleteLanguage(String langCode) {
        try {
            log.info("언어 삭제 시작: langCode = {}", langCode);
            Map<String, Object> params = new HashMap<>();
            params.put("langCode", langCode);
            sqlSession.delete("multilang.deleteLanguage", params);
            log.info("언어 삭제 완료");
        } catch (Exception e) {
            log.error("언어 삭제 중 오류 발생", e);
            throw e;
        }
    }

    // 언어 활성/비활성 토글
    @Transactional
    public String toggleLanguage(String langCode) {
        try {
            log.info("언어 상태 토글 시작: langCode = {}", langCode);
            
            // 현재 상태 조회
            Map<String, Object> params = new HashMap<>();
            params.put("langCode", langCode);
            Map<String, Object> currentLanguage = sqlSession.selectOne("multilang.selectLanguageByCode", params);
            
            if (currentLanguage == null) {
                throw new RuntimeException("언어를 찾을 수 없습니다: " + langCode);
            }
            
            String currentStatus = (String) currentLanguage.get("isActive");
            String newStatus = "Y".equals(currentStatus) ? "N" : "Y";
            
            // 상태 업데이트
            params.put("isActive", newStatus);
            sqlSession.update("multilang.updateLanguageStatus", params);
            
            String result = "Y".equals(newStatus) ? "활성화" : "비활성화";
            log.info("언어 상태 토글 완료: langCode = {}, 상태 = {}", langCode, result);
            return result;
        } catch (Exception e) {
            log.error("언어 상태 토글 중 오류 발생", e);
            throw e;
        }
    }

    // 회사별 다국어 키 목록 조회
    public List<Map<String, Object>> getLangKeys(Map<String, Object> params) {
        return sqlSession.selectList("multilang.selectLangKeys", params);
    }

    // 특정 키의 다국어 텍스트 조회
    public List<Map<String, Object>> getLangTexts(Integer keyId) {
        Map<String, Object> params = new HashMap<>();
        params.put("keyId", keyId);
        return sqlSession.selectList("multilang.selectLangTexts", params);
    }

    // 다국어 키 생성
    @Transactional
    public Integer createLangKey(Map<String, Object> keyData) {
        try {
            // 중복 체크
            Map<String, Object> existingKey = sqlSession.selectOne("multilang.selectLangKeyByCompanyAndKey", keyData);
            if (existingKey != null) {
                throw new RuntimeException("동일한 회사에 이미 존재하는 언어키입니다: " + keyData.get("langKey"));
            }
            
            sqlSession.insert("multilang.insertLangKey", keyData);
            return (Integer) keyData.get("keyId");
        } catch (Exception e) {
            log.error("다국어 키 생성 중 오류 발생", e);
            throw e;
        }
    }

    // 다국어 키 수정
    @Transactional
    public void updateLangKey(Map<String, Object> keyData) {
        try {
            // 중복 체크 (자신을 제외하고)
            Map<String, Object> existingKey = sqlSession.selectOne("multilang.selectLangKeyByCompanyAndKeyExcludeSelf", keyData);
            if (existingKey != null) {
                throw new RuntimeException("동일한 회사에 이미 존재하는 언어키입니다: " + keyData.get("langKey"));
            }
            
            sqlSession.update("multilang.updateLangKey", keyData);
        } catch (Exception e) {
            log.error("다국어 키 수정 중 오류 발생", e);
            throw e;
        }
    }

    // 다국어 키 삭제
    @Transactional
    public void deleteLangKey(Integer keyId) {
        Map<String, Object> params = new HashMap<>();
        params.put("keyId", keyId);
        sqlSession.delete("multilang.deleteLangKey", params);
    }

    // 다국어 키 활성/비활성 토글
    @Transactional
    public String toggleLangKey(Integer keyId) {
        try {
            log.info("다국어 키 상태 토글 시작: keyId = {}", keyId);
            
            // 현재 상태 조회
            Map<String, Object> params = new HashMap<>();
            params.put("keyId", keyId);
            Map<String, Object> currentKey = sqlSession.selectOne("multilang.selectLangKeyById", params);
            
            if (currentKey == null) {
                throw new RuntimeException("키를 찾을 수 없습니다: " + keyId);
            }
            
            String currentStatus = (String) currentKey.get("isActive");
            String newStatus = "Y".equals(currentStatus) ? "N" : "Y";
            
            // 상태 업데이트
            params.put("isActive", newStatus);
            sqlSession.update("multilang.updateLangKeyStatus", params);
            
            String result = "Y".equals(newStatus) ? "활성화" : "비활성화";
            log.info("다국어 키 상태 토글 완료: keyId = {}, 상태 = {}", keyId, result);
            return result;
        } catch (Exception e) {
            log.error("다국어 키 상태 토글 중 오류 발생", e);
            throw e;
        }
    }

    // 다국어 텍스트 저장/수정
    @Transactional
    public void saveLangTexts(Integer keyId, List<Map<String, Object>> textData) {
        // 기존 텍스트 삭제
        Map<String, Object> deleteParams = new HashMap<>();
        deleteParams.put("keyId", keyId);
        sqlSession.delete("multilang.deleteLangTexts", deleteParams);
        
        // 새로운 텍스트 삽입
        for (Map<String, Object> text : textData) {
            text.put("keyId", keyId);
            sqlSession.insert("multilang.insertLangText", text);
        }
    }



    // 특정 키의 다국어 텍스트 조회
    public String getLangText(String companyCode, String langKey, String langCode) {
        Map<String, Object> params = new HashMap<>();
        params.put("companyCode", companyCode);
        params.put("langKey", langKey);
        params.put("langCode", langCode);
        
        Map<String, Object> result = sqlSession.selectOne("multilang.selectLangText", params);
        return result != null ? (String) result.get("langText") : langKey; // 기본값으로 키 반환
    }

    // 사용자별 다국어 텍스트 조회
    public String getUserText(String companyCode, String menuCode, String langKey, String userLang) {
        try {
            log.info("🔍 사용자 텍스트 조회: companyCode={}, menuCode={}, langKey={}, userLang={}", 
                    companyCode, menuCode, langKey, userLang);
            
            Map<String, Object> params = new HashMap<>();
            params.put("companyCode", companyCode);
            params.put("menuCode", menuCode);
            params.put("langKey", langKey);
            params.put("userLang", userLang);
            
            System.out.println("🔍 SQL 파라미터: " + params);
            
            Map<String, Object> result = sqlSession.selectOne("multilang.selectUserText", params);
            System.out.println("🔍 SQL 결과: " + result);
            
            if (result != null && result.get("langText") != null) {
                String text = (String) result.get("langText");
                log.info("✅ 사용자 텍스트 조회 성공: {}", text);
                System.out.println("✅ 사용자 텍스트 조회 성공: " + text);
                return text;
            } else {
                log.warn("⚠️ 사용자 텍스트를 찾을 수 없음, 키 반환: {}", langKey);
                System.out.println("⚠️ 사용자 텍스트를 찾을 수 없음, 키 반환: " + langKey);
                return langKey; // 기본값으로 키 반환
            }
        } catch (Exception e) {
            log.error("❌ 사용자 텍스트 조회 중 오류 발생", e);
            System.err.println("❌ 사용자 텍스트 조회 중 오류 발생: " + e.getMessage());
            e.printStackTrace();
            return langKey; // 오류 시 키 반환
        }
    }

    // 간단한 테스트 메서드
    public String testConnection() {
        try {
            log.info("데이터베이스 연결 테스트 시작");
            // 간단한 쿼리 실행
            String result = sqlSession.selectOne("SELECT 'OK' as test");
            log.info("데이터베이스 연결 테스트 성공: {}", result);
            return result;
        } catch (Exception e) {
            log.error("데이터베이스 연결 테스트 실패", e);
            throw e;
        }
    }
}