// Empty

@RequiredArgsConstructor
@Component
@Slf4j
public class EciesUtil {

    private static final String KEY_ALGORITHM = "ECDH"; // KeyAgreement algorithm
    private static final String KEY_FACTORY_ALG = "EC"; // KeyFactory algorithm (important!)
    private static final String CURVE_NAME = "secp256r1";
    private static final String HKDF_HASH = "HmacSHA256";
    private static final int AES_KEY_LEN_BYTES = 32; // 256-bit
    private static final SecureRandom secureRandom = new SecureRandom();

    private final AesUtil aesUtil; // AES 암복호화 유틸 (추정)

    public KeyPair generateECKeyPair() throws GeneralSecurityException {
        KeyPairGenerator kpg = KeyPairGenerator.getInstance(KEY_FACTORY_ALG);
        ECGenParameterSpec ecGenParameterSpec = new ECGenParameterSpec(CURVE_NAME);
        kpg.initialize(ecGenParameterSpec, secureRandom);
        return kpg.generateKeyPair();
    }

    /**
     * Sender: recipientPublicKey로부터 ephemeral 키 생성 후 shared secret -> HKDF -> aesKey 생성
     * 반환값에 ephemeralPublicKey, aesKey, iv 포함 (iv는 랜덤 생성)
     */
    public EciesSecret generateSecret(PublicKey recipientPublicKey) throws GeneralSecurityException {
        // 1) ephemeral keypair 생성
        KeyPair ephemeral = generateECKeyPair();

        // 2) shared secret (ephemeralPriv, recipientPub)
        byte[] sharedSecret = deriveSharedSecret(ephemeral.getPrivate(), recipientPublicKey);

        // 3) HKDF로 AES 키 파생 (AES-256)
        byte[] aesKeyBytes = hkdfExpand(sharedSecret, null, "ECIES-AES-256".getBytes(), AES_KEY_LEN_BYTES);

        SecretKey aesKey = new SecretKeySpec(aesKeyBytes, "AES");

        // 4) IV 생성 (전송 필요)
        byte[] ivBytes = new byte[16];
        secureRandom.nextBytes(ivBytes);
        IvParameterSpec iv = new IvParameterSpec(ivBytes);

        return EciesSecret.builder()
                .ephemeralPublicKey(ephemeral.getPublic())
                .aesKey(aesKey)
                .iv(iv)
                .build();
    }

    /**
     * Receiver: base64로 넘어온 ephemeralPublicKey와 자신의 privateKey로 shared secret 생성 후 동일한 HKDF로 aesKey 도출
     */
    public EciesSecret generateSecret(PrivateKey recipientPrivateKey, String base64EphemeralPublicKey, String base64Iv)
            throws GeneralSecurityException {
        byte[] ephemeralBytes = Base64.getDecoder().decode(base64EphemeralPublicKey);
        KeyFactory kf = KeyFactory.getInstance(KEY_FACTORY_ALG);
        PublicKey ephemeralPub = kf.generatePublic(new X509EncodedKeySpec(ephemeralBytes));

        byte[] ivBytes = Base64.getDecoder().decode(base64Iv);
        IvParameterSpec iv = new IvParameterSpec(ivBytes);

        byte[] sharedSecret = deriveSharedSecret(recipientPrivateKey, ephemeralPub);

        byte[] aesKeyBytes = hkdfExpand(sharedSecret, null, "ECIES-AES-256".getBytes(), AES_KEY_LEN_BYTES);
        SecretKey aesKey = new SecretKeySpec(aesKeyBytes, "AES");

        return EciesSecret.builder()
                .ephemeralPublicKey(ephemeralPub)
                .aesKey(aesKey)
                .iv(iv)
                .build();
    }

    private byte[] deriveSharedSecret(PrivateKey priv, PublicKey pub) throws GeneralSecurityException {
        KeyAgreement keyAgreement = KeyAgreement.getInstance(KEY_ALGORITHM);
        keyAgreement.init(priv);
        keyAgreement.doPhase(pub, true);
        return keyAgreement.generateSecret();
    }

    // HKDF (RFC 5869) - simple extract/expand using HmacSHA256
    private byte[] hkdfExpand(byte[] prkOrIkm, byte[] salt, byte[] info, int len) throws GeneralSecurityException {
        // For simplicity: do HKDF-Extract then HKDF-Expand
        byte[] prk = hkdfExtract(salt, prkOrIkm);
        return hkdfExpandFromPrk(prk, info, len);
    }

    private byte[] hkdfExtract(byte[] salt, byte[] ikm) throws GeneralSecurityException {
        Mac mac = Mac.getInstance(HKDF_HASH);
        if (salt == null) {
            salt = new byte[mac.getMacLength()];
        }
        SecretKeySpec keySpec = new SecretKeySpec(salt, HKDF_HASH);
        mac.init(keySpec);
        return mac.doFinal(ikm);
    }

    private byte[] hkdfExpandFromPrk(byte[] prk, byte[] info, int length) throws GeneralSecurityException {
        Mac mac = Mac.getInstance(HKDF_HASH);
        SecretKeySpec keySpec = new SecretKeySpec(prk, HKDF_HASH);
        mac.init(keySpec);

        int hashLen = mac.getMacLength();
        int n = (int) Math.ceil((double) length / hashLen);
        if (n > 255) throw new GeneralSecurityException("Cannot expand to more than 255 * HashLen bytes with HKDF");

        byte[] result = new byte[length];
        byte[] t = new byte[0];
        int copied = 0;
        for (int i = 1; i <= n; i++) {
            mac.update(t);
            if (info != null) mac.update(info);
            mac.update((byte) i);
            t = mac.doFinal();
            int toCopy = Math.min(t.length, length - copied);
            System.arraycopy(t, 0, result, copied, toCopy);
            copied += toCopy;
        }
        return result;
    }

    // AES 암복호 호출은 기존의 aesUtil 사용
    public String encrypt(String data, EciesSecret secret) throws Exception {
        return aesUtil.encrypt(data, secret.getAesKey(), secret.getIv());
    }

    public String decrypt(String encryptedData, EciesSecret secret) throws Exception {
        return aesUtil.decrypt(encryptedData, secret.getAesKey(), secret.getIv());
    }

    // PostConstruct는 데모용으로만 사용; 운영 환경에선 제거 권장
    @PostConstruct
    void demo() {
        try {
            KeyPair kp = generateECKeyPair();
            log.info("publicKey (base64) = {}", Base64.getEncoder().encodeToString(kp.getPublic().getEncoded()));
        } catch (Exception e) {
            log.error("EciesUtil demo error", e);
        }
    }
}