Credential Functions

void process_credential(kc_credential_t* credential) {
    // Check if credential is valid
    bool is_null = false;
    int result = kc_credential_is_null(credential, &is_null);
    if (result != 0 || is_null) {
        printf("Invalid credential\n");
        return;
    }

    // Get credential ID
    char* cred_id = NULL;
    unsigned int id_size = 0;
    result = kc_credential_id(credential, &cred_id, &id_size);
    if (result == 0) {
        printf("Credential ID: %.*s\n", id_size, cred_id);
        kc_common_delete_buffer(&cred_id);
    }

    // Get issuer information
    char* issuer = NULL;
    char* issuer_name = NULL;
    unsigned int issuer_size = 0, name_size = 0;

    result = kc_credential_issuer(credential, &issuer, &issuer_size);
    if (result == 0) {
        printf("Issued by: %.*s\n", issuer_size, issuer);

        // Try to get issuer name
        if (kc_credential_issuer_name(credential, &issuer_name, &name_size) == 0) {
            printf("Issuer name: %.*s\n", name_size, issuer_name);
            kc_common_delete_buffer(&issuer_name);
        }

        kc_common_delete_buffer(&issuer);
    }

    // Get credential types
    char** types = NULL;
    unsigned int type_count = 0;
    result = kc_credential_type(credential, &types, &type_count);
    if (result == 0) {
        printf("Credential types (%u):\n", type_count);
        for (unsigned int i = 0; i < type_count; i++) {
            printf("  - %s\n", types[i]);
        }
        kc_common_delete_buffer_array(&types, type_count);
    }

    // Get subject ID
    char* subject_id = NULL;
    unsigned int subject_id_size = 0;
    result = kc_credential_credential_subject_id(credential, &subject_id, &subject_id_size);
    if (result == 0) {
        printf("Subject: %.*s\n", subject_id_size, subject_id);
        kc_common_delete_buffer(&subject_id);
    }

    // Check validity period
    uint64_t issued_at = 0, expires_at = 0;
    kc_credential_issuance_timestamp(credential, &issued_at);
    kc_credential_expiration_timestamp(credential, &expires_at);

    uint64_t now = time(NULL) * 1000;
    if (now >= issued_at && now < expires_at) {
        printf("Credential is currently valid\n");

        // Calculate days until expiration
        uint64_t days_left = (expires_at - now) / (1000 * 60 * 60 * 24);
        printf("Expires in %llu days\n", days_left);
    } else if (now < issued_at) {
        printf("Credential is not yet valid\n");
    } else {
        printf("Credential has expired\n");
    }

    // Export to JSON for storage
    char* json_output = NULL;
    unsigned int json_size = 0;
    result = kc_credential_serialize_to_string(credential, &json_output, &json_size,
                                             TKC_SERIALIZATION_FORMAT_JSON);
    if (result == 0) {
        printf("\nCredential as JSON:\n%.*s\n", json_size, json_output);
        kc_common_delete_buffer(&json_output);
    }
}

// Example using gateway and persona to create a credential
void create_identity_credential(kc_gateway_t* gateway, kc_persona_t* issuer) {
    const char* cred_id = "https://example.com/credentials/identity/12345";
    const char* cred_type = "IdentityCredential";
    const char* subject_did = "did:keychain:bob.employee";

    // Set validity for 1 year
    uint64_t now = time(NULL) * 1000;
    uint64_t one_year_later = now + (365ULL * 24 * 60 * 60 * 1000);

    // Create claims
    kc_tag_set_t* claims = NULL;
    kc_tag_set_construct(&claims);
    kc_tag_set_add_string(claims, "name", "Bob Smith");
    kc_tag_set_add_string(claims, "employeeId", "EMP-12345");
    kc_tag_set_add_string(claims, "department", "Engineering");

    // Create credential
    kc_credential_t* credential = NULL;
    int result = kc_persona_create_credential(issuer, &credential,
        cred_id, strlen(cred_id),
        cred_type, strlen(cred_type),
        subject_did, strlen(subject_did),
        now, one_year_later,
        claims, NULL, NULL);

    if (result == 0) {
        printf("Identity credential created successfully\n");

        // Process the credential
        process_credential(credential);

        // Verify the credential
        kc_verification_result_t* verify_result = NULL;
        result = kc_gateway_verify(gateway, &verify_result, issuer,
                                 (kc_verifiable_data_t*)credential);
        if (result == 0) {
            bool is_valid = false;
            kc_verification_result_is_valid(verify_result, &is_valid);
            printf("Credential verification: %s\n", is_valid ? "VALID" : "INVALID");
            kc_verification_result_destruct(&verify_result);
        }

        kc_credential_destruct(&credential);
    }

    kc_tag_set_destruct(&claims);
}