Constants and Enums

from keychain.constants import (
    SecurityLevel,
    KeychainType,
    ConsensusAlgorithm,
    EncryptionScheme,
    SignatureScheme,
    DEFAULT_SECURITY_LEVEL,
    STRONG_DEPTH
)
from keychain.core.gateway import Gateway

def create_secure_persona():
    """Create a persona with high security settings."""

    gateway = Gateway()

    # Use high security level
    security_level = SecurityLevel.HIGH
    print(f"Creating persona with {security_level.name} security")

    # Create persona with custom settings
    persona = gateway.create_persona(
        name="secure_persona",
        security_level=security_level
    )

    return persona

def setup_consensus_transaction():
    """Setup a transaction with three-phase commit consensus."""

    # Configure consensus algorithm
    consensus_algo = ConsensusAlgorithm.THREE_PHASE_COMMIT
    print(f"Using {consensus_algo.name} consensus algorithm")

    # Transaction setup with consensus
    transaction_config = {
        "consensus_algorithm": consensus_algo,
        "confirmation_depth": STRONG_DEPTH
    }

    return transaction_config

def compare_crypto_algorithms():
    """Compare different cryptographic algorithm options."""

    # Available encryption schemes
    encryption_options = [
        EncryptionScheme.ECIES_ECP_SECP256R1,
        EncryptionScheme.RSA_OAEP_SHA_2048,
        EncryptionScheme.ECIES_ECP_SECP384R1
    ]

    # Available signature schemes
    signature_options = [
        SignatureScheme.ECDSA_ECP_SECP256R1,
        SignatureScheme.RSASS_PSS_2048,
        SignatureScheme.ECDSA_ECP_SECP384R1
    ]

    print("Encryption Options:")
    for scheme in encryption_options:
        print(f"  {scheme.name} (value: {scheme.value})")

    print("\\nSignature Options:")
    for scheme in signature_options:
        print(f"  {scheme.name} (value: {scheme.value})")

def check_data_types(data_objects):
    """Check and categorize different data types."""

    for obj in data_objects:
        data_type = obj.data_type()

        if data_type == DataType.CREDENTIAL:
            print(f"Found credential: {obj}")
        elif data_type == DataType.DID:
            print(f"Found DID: {obj}")
        elif data_type == DataType.TRANSACTION:
            print(f"Found transaction: {obj}")
        elif data_type.name.startswith("ARRAY_"):
            print(f"Found array of {data_type.name[6:].lower()}: {obj}")
        else:
            print(f"Found {data_type.name.lower()}: {obj}")

def demonstrate_keychain_types():
    """Demonstrate different keychain types."""

    # Create different keychain types
    for keychain_type in KeychainType:
        print(f"Creating {keychain_type.name.lower()} keychain")

        # Keychain type determines purpose
        if keychain_type == KeychainType.ENCRYPT:
            print("  - Used for encryption operations")
        elif keychain_type == KeychainType.SIGN:
            print("  - Used for signature operations")

# Usage examples
if __name__ == "__main__":
    print("=== Keychain Constants and Enums Demo ===\\n")

    # Default values
    print(f"Default security level: {DEFAULT_SECURITY_LEVEL.name}")
    print(f"Strong confirmation depth: {STRONG_DEPTH} blocks\\n")

    # Create secure persona
    persona = create_secure_persona()
    print()

    # Setup consensus
    config = setup_consensus_transaction()
    print(f"Transaction config: {config}\\n")

    # Compare algorithms
    compare_crypto_algorithms()
    print()

    # Demonstrate keychain types
    demonstrate_keychain_types()

from keychain.constants import (
    SecurityLevel,
    EncryptionScheme,
    SignatureScheme,
    CipherClass,
    Cipher
)

class CryptographicProfile:
    """Cryptographic algorithm profile for different security needs."""

    def __init__(self, security_level: SecurityLevel):
        self.security_level = security_level
        self.encryption_scheme = self._select_encryption_scheme()
        self.signature_scheme = self._select_signature_scheme()
        self.cipher = self._select_cipher()

    def _select_encryption_scheme(self) -> EncryptionScheme:
        """Select encryption scheme based on security level."""
        if self.security_level <= SecurityLevel.LOW:
            return EncryptionScheme.ECIES_ECP_SECP256R1
        elif self.security_level == SecurityLevel.MEDIUM:
            return EncryptionScheme.ECIES_ECP_SECP384R1
        elif self.security_level == SecurityLevel.HIGH:
            return EncryptionScheme.ECIES_ECP_SECP521R1
        else:  # ULTRA
            return EncryptionScheme.RSA_OAEP_SHA_4096

    def _select_signature_scheme(self) -> SignatureScheme:
        """Select signature scheme based on security level."""
        if self.security_level <= SecurityLevel.LOW:
            return SignatureScheme.ECDSA_ECP_SECP256R1
        elif self.security_level == SecurityLevel.MEDIUM:
            return SignatureScheme.ECDSA_ECP_SECP384R1
        elif self.security_level == SecurityLevel.HIGH:
            return SignatureScheme.ECDSA_ECP_SECP521R1
        else:  # ULTRA
            return SignatureScheme.RSASS_PSS_4096

    def _select_cipher(self) -> Cipher:
        """Select symmetric cipher based on security level."""
        if self.security_level <= SecurityLevel.MEDIUM:
            return Cipher.AES_GCM_256
        else:
            return Cipher.CAMELLIA_GCM_256

    def get_profile_summary(self) -> dict:
        """Get a summary of the cryptographic profile."""
        return {
            "security_level": self.security_level.name,
            "encryption": self.encryption_scheme.name,
            "signature": self.signature_scheme.name,
            "symmetric_cipher": self.cipher.name
        }

# Usage example
def create_security_profiles():
    """Create cryptographic profiles for different security levels."""

    profiles = {}

    for level in SecurityLevel:
        if level == SecurityLevel.UNKNOWN_LEVEL:
            continue

        profile = CryptographicProfile(level)
        profiles[level.name] = profile.get_profile_summary()

    return profiles

# Demonstrate security profiles
profiles = create_security_profiles()
for level_name, profile in profiles.items():
    print(f"\\n{level_name} Security Profile:")
    for key, value in profile.items():
        print(f"  {key}: {value}")