signature_algorithm_class Enum

namespace keychain {
    enum class signature_algorithm_class {
        ECDSA,      // Elliptic Curve Digital Signature Algorithm
        ECGDSA,     // Elliptic Curve German Digital Signature Algorithm
        RSASS,      // RSA Signature Schemes
        DSA,        // Digital Signature Algorithm
        EDDSA       // Edwards-curve Digital Signature Algorithm
    };
}

#include <keychain/keychain.h>

// Check algorithm class
keychain::signature_scheme scheme = keychain::signature_scheme::ECDSA_P256_SHA256;
keychain::signature_algorithm_class alg_class = scheme.get_algorithm_class();

switch (alg_class) {
    case keychain::signature_algorithm_class::ECDSA:
        std::cout << "Using ECDSA signatures" << std::endl;
        break;
    case keychain::signature_algorithm_class::EDDSA:
        std::cout << "Using EdDSA signatures" << std::endl;
        break;
    case keychain::signature_algorithm_class::RSASS:
        std::cout << "Using RSA signatures" << std::endl;
        break;
    default:
        std::cout << "Other signature algorithm" << std::endl;
        break;
}

// Algorithm class capabilities
bool supports_deterministic_signatures(keychain::signature_algorithm_class alg_class) {
    return alg_class == keychain::signature_algorithm_class::EDDSA ||
           alg_class == keychain::signature_algorithm_class::ECGDSA;
}

bool is_quantum_resistant(keychain::signature_algorithm_class alg_class) {
    // Current algorithms are not quantum-resistant
    // This would change with post-quantum algorithms
    return false;
}

// Performance comparison example
void benchmark_signature_classes() {
    std::vector<keychain::signature_scheme> schemes = {
        keychain::signature_scheme::ECDSA_P256_SHA256,
        keychain::signature_scheme::EDDSA_ED25519,
        keychain::signature_scheme::RSASS_2048_PSS_SHA256
    };

    std::string test_data = "Performance test message";

    for (auto scheme : schemes) {
        auto alg_class = scheme.get_algorithm_class();

        // Benchmark signing
        auto start = std::chrono::high_resolution_clock::now();
        for (int i = 0; i < 1000; ++i) {
            // Sign test data with scheme
        }
        auto end = std::chrono::high_resolution_clock::now();
        auto sign_duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);

        // Benchmark verification
        start = std::chrono::high_resolution_clock::now();
        for (int i = 0; i < 1000; ++i) {
            // Verify signature with scheme
        }
        end = std::chrono::high_resolution_clock::now();
        auto verify_duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);

        std::cout << "Algorithm class: " << to_string(alg_class) << std::endl;
        std::cout << "  Sign: " << sign_duration.count() << "μs" << std::endl;
        std::cout << "  Verify: " << verify_duration.count() << "μs" << std::endl;
    }
}

// Prepare for post-quantum algorithms
namespace keychain {
    // Future post-quantum signature classes might include:
    // enum class signature_algorithm_class {
    //     // ... existing algorithms ...
    //     DILITHIUM,     // CRYSTALS-Dilithium
    //     FALCON,        // FALCON
    //     SPHINCS_PLUS   // SPHINCS+
    // };
}

// Migration planning
void plan_post_quantum_migration() {
    // Hybrid signatures during transition period
    // Algorithm agility in protocol design
    // Key size and performance impact assessment
}