import ru.CryptoPro.CAdES.CAdESSignature
import ru.CryptoPro.CAdES.*
import java.security.KeyStore
import java.security.Security
import java.security.PrivateKey
import java.security.cert.Certificate
import java.util.Base64
import java.util.Arrays
import java.util.ArrayList
import ru.CryptoPro.JCP.JCP
import ru.CryptoPro.reprov.RevCheck

try {
    System.setProperty("com.sun.security.enableCRLDP", "true")
    System.setProperty("com.ibm.security.enableCRLDP", "true")
    System.setProperty("ocsp.enable", "true")

    log.info("Начало выполнения скрипта: Создание CAdES-BES подписи")

    // Регистрация провайдера
    log.info("Регистрация провайдера JCSP")
    Security.addProvider(new ru.CryptoPro.JCSP.JCSP())
    log.info("Провайдер JCSP добавлен: ${Security.getProvider('JCSP')}")
    Security.addProvider(new RevCheck())
    // Путь к PFX-файлу, пароль и псевдоним
    def pfxPath = 'd://share//root_tester_new_low.pfx'
    def password = '123456'.toCharArray()
    def alias = 'root_tester_new'

    log.info("Путь к PFX: $pfxPath")
    log.info("Псевдоним: $alias")

    // Получение данных для подписи
    def dataToSign = vars.get("dataForSign") ?: "default_data_for_sign"
    byte[] dataBytes = dataToSign.getBytes("UTF-8")
    log.info("Данные для подписи: $dataToSign")
    log.info("Длина данных: ${dataBytes.length} байт")

    // Загрузка хранилища
    log.info("Загрузка хранилища KeyStore")
    KeyStore keyStore = KeyStore.getInstance("PFXSTORE", "JCSP")
    keyStore.load(new File(pfxPath).newInputStream(), password)
    log.info("Хранилище успешно загружено")

    // Вывод всех доступных алиасов
    log.info("Список всех алиасов в хранилище:")
    Enumeration<String> allAliases = keyStore.aliases()
    while (allAliases.hasMoreElements()) {
        String currentAlias = allAliases.nextElement()
        boolean isKeyEntry = keyStore.isKeyEntry(currentAlias)
        boolean isCertEntry = keyStore.isCertificateEntry(currentAlias)
        log.info(" - $currentAlias (Тип: ${isKeyEntry ? 'Ключ' : (isCertEntry ? 'Сертификат' : 'Неизвестный')})")
    }

    // Проверка наличия псевдонима
    log.info("Проверка наличия псевдонима: $alias")
    if (!keyStore.containsAlias(alias)) {
        throw new Exception("Псевдоним '$alias' не найден в хранилище")
    }
    log.info("Псевдоним '$alias' найден")

    // Получение приватного ключа
    log.info("Получение приватного ключа")
    PrivateKey privateKey = (PrivateKey) keyStore.getKey(alias, password)
    log.info("Приватный ключ успешно получен")

    // Получение цепочки сертификатов
    log.info("Формирование цепочки сертификатов")
    List<Certificate> chain = new ArrayList<>()

    // Получение цепочки из приватного ключа
    Certificate[] certChain = keyStore.getCertificateChain(alias)

    if (certChain == null || certChain.length == 0) {
        log.warn("Цепочка сертификатов из getCertificateChain пуста. Попытка загрузить все сертификаты из PFX...")

        // Резервный метод: загрузка всех сертификатов из PFX
        Enumeration<String> aliases = keyStore.aliases()
        while (aliases.hasMoreElements()) {
            String currentAlias = aliases.nextElement()
            if (keyStore.isCertificateEntry(currentAlias)) {
                Certificate cert = keyStore.getCertificate(currentAlias)
                chain.add(cert)
                log.info("Добавлен сертификат: ${cert.subjectDN}")
                log.info("  Издатель: ${cert.issuerDN}")
                log.info("  Действителен с: ${cert.notBefore} по: ${cert.notAfter}")
                log.info("  Серийный номер: ${cert.serialNumber}")
                log.info("  Тип: ${cert.type}")
            }
        }
    } else {
        chain.addAll(Arrays.asList(certChain))
        log.info("Цепочка сертификатов загружена из getCertificateChain")
        log.info("Цепочка содержит ${chain.size()} сертификат(ов)")

        // Детальное логирование цепочки
        log.info("Детали цепочки сертификатов:")
        chain.eachWithIndex { cert, idx ->
            def isRoot = cert.subjectDN == cert.issuerDN
            log.info("Сертификат #${idx + 1}:")
            log.info("  Subject: ${cert.subjectDN}")
            log.info("  Issuer: ${cert.issuerDN}")
            log.info("  Является корневым: ${isRoot ? 'Да' : 'Нет'}")
            if (idx > 0) {
                def previousCert = chain[idx - 1]
                log.info("  Проверка связи с предыдущим сертификатом:")
                log.info("    Предыдущий Issuer: ${previousCert.issuerDN}")
                log.info("    Текущий Subject: ${cert.subjectDN}")
            }
        }
    }

    if (chain.isEmpty()) {
        throw new Exception("Цепочка сертификатов пуста. Убедитесь, что PFX содержит сертификаты.")
    }

    // Проверка наличия корневого сертификата
    boolean hasRoot = chain.find { cert -> cert.subjectDN == cert.issuerDN }
    if (!hasRoot && chain.size() >= 1) {
        log.warn("Внимание: В цепочке отсутствует корневой сертификат")
        log.warn("Текущая цепочка содержит следующие сертификаты:")
        chain.each { cert -> log.warn("  - ${cert.subjectDN}") }
    }

    if (chain.size() < 2) {
        log.warn("Внимание: цепочка содержит менее 2 сертификатов. Убедитесь, что PFX содержит полную цепочку.")
    }

    // Создание CAdES подписи
    log.info("Создание объекта CAdESSignature")
    CAdESSignature cadesSignature = new CAdESSignature(false)

    // Добавление подписчика
    log.info("Добавление подписчика")
    cadesSignature.addSigner(
        JCP.PROVIDER_NAME,
        JCP.GOST_DIGEST_2012_512_OID,
        JCP.GOST_EL_SIGN_2012_512_OID_WITH,
        privateKey,
        chain,
        CAdESType.CAdES_BES,
        null,
        false
    )
    log.info("Подписчик добавлен")

    // Подготовка потока для подписи
    log.info("Подготовка потока для подписи")
    ByteArrayOutputStream signatureStream = new ByteArrayOutputStream()

    // Открытие контекста подписи
    log.info("Открытие контекста подписи")
    cadesSignature.open(signatureStream)

    // Обновление данных
    log.info("Обновление данных для подписи")
    cadesSignature.update(dataBytes)

    // Завершение подписи
    log.info("Завершение подписи")
    cadesSignature.close()

    // Получение результата подписи
    byte[] signature = signatureStream.toByteArray()
    log.info("Подпись успешно создана")
    log.info("Длина подписи: ${signature.length} байт")

    // Проверка результата
    if (signature == null || signature.length == 0) {
        log.error("Ошибка: подпись не создана")
        throw new Exception("Ошибка: подпись не создана")
    }

    // Кодирование подписи в Base64
    log.info("Кодирование подписи в Base64")
    String base64Signature = Base64.getEncoder().encodeToString(signature)
    log.info("Base64-подпись: $base64Signature")
    log.info("Длина Base64-подписи: ${base64Signature.length()} символов")

    // Сохранение результата в переменную JMeter
    vars.put("signed_data", base64Signature)
    log.info("Подпись сохранена в переменную JMeter: signed_data")

    log.info("Завершение выполнения скрипта: Подпись успешно создана")

} catch (Throwable t) {
    log.error("Ошибка при создании CAdES-BES подписи: ", t)
    throw t
}