package com.eactive.eai.rms.common.dbconsole.service;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

//import com.eactive.ext.kjb.safedb.KjbSafedbWrapper;

/**
 * DB Console 복호화 서비스
 * - SafeDB 암호화 데이터 복호화 기능 제공
 */
@Service
public class DbConsoleDecryptService {

    private static final Logger log = LoggerFactory.getLogger(DbConsoleDecryptService.class);

    /**
     * SafeDB 암호화 패턴 (16진수 문자열, 최소 32자 이상)
     * - 암호화된 데이터는 대체로 긴 16진수 문자열 형태
     */
    private static final Pattern ENCRYPTED_PATTERN = Pattern.compile("^[0-9A-Fa-f]{32,}$");

    /**
     * 단일 값 복호화
     */
    public String decryptValue(String encryptedValue) {
    	return encryptedValue;
//        if (encryptedValue == null || encryptedValue.isEmpty()) {
//            return encryptedValue;
//        }
//
//        try {
//            KjbSafedbWrapper safedb = KjbSafedbWrapper.getInstance();
//            String decrypted = safedb.decryptNotRnno(encryptedValue);
//            log.debug("복호화 성공: {} -> {}",
//                encryptedValue.length() > 20 ? encryptedValue.substring(0, 20) + "..." : encryptedValue,
//                decrypted);
//            return decrypted;
//        } catch (Exception e) {
//            log.warn("복호화 실패: {}", e.getMessage());
//            return "[복호화 실패: " + e.getMessage() + "]";
//        }
    }

    /**
     * 여러 값 일괄 복호화
     */
    public Map<String, String> decryptValues(List<String> encryptedValues) {
        Map<String, String> result = new HashMap<>();

        if (encryptedValues == null || encryptedValues.isEmpty()) {
            return result;
        }

        for (String encrypted : encryptedValues) {
            if (encrypted != null && !encrypted.isEmpty()) {
                result.put(encrypted, decryptValue(encrypted));
            }
        }

        return result;
    }

    /**
     * 행 데이터에서 암호화 컬럼 복호화
     * @param rows 원본 행 데이터
     * @param columns 복호화할 컬럼명 목록
     * @return 복호화된 행 데이터
     */
    public List<Map<String, Object>> decryptRows(List<Map<String, Object>> rows, List<String> columns) {
        if (rows == null || rows.isEmpty() || columns == null || columns.isEmpty()) {
            return rows;
        }

        List<Map<String, Object>> decryptedRows = new ArrayList<>();

        for (Map<String, Object> row : rows) {
            Map<String, Object> decryptedRow = new HashMap<>(row);

            for (String column : columns) {
                Object value = row.get(column);
                if (value != null && value instanceof String) {
                    String strValue = (String) value;
                    if (isEncrypted(strValue)) {
                        decryptedRow.put(column, decryptValue(strValue));
                    }
                }
            }

            decryptedRows.add(decryptedRow);
        }

        return decryptedRows;
    }

    /**
     * 값이 암호화된 것인지 확인 (휴리스틱)
     * - 16진수 문자열 패턴 (32자 이상)
     */
    public boolean isEncrypted(String value) {
        if (value == null || value.length() < 32) {
            return false;
        }
        return ENCRYPTED_PATTERN.matcher(value).matches();
    }

    /**
     * 컬럼별로 암호화 여부 자동 감지
     * @param rows 조회 결과 행
     * @return 암호화된 것으로 추정되는 컬럼명 목록
     */
    public List<String> detectEncryptedColumns(List<Map<String, Object>> rows) {
        List<String> encryptedColumns = new ArrayList<>();

        if (rows == null || rows.isEmpty()) {
            return encryptedColumns;
        }

        // 첫 번째 행 기준으로 검사 (모든 행을 검사하면 비용이 높음)
        Map<String, Object> firstRow = rows.get(0);

        for (Map.Entry<String, Object> entry : firstRow.entrySet()) {
            Object value = entry.getValue();
            if (value != null && value instanceof String) {
                if (isEncrypted((String) value)) {
                    encryptedColumns.add(entry.getKey());
                }
            }
        }

        return encryptedColumns;
    }
}
