#ifndef CAPI_H_INCLUDED
#define CAPI_H_INCLUDED

#define SIZEOF_VOID_P (UINTPTR_MAX+0 > 0xffffffffUL ? 8 : 4)

typedef struct library_s library_t;

#include <stdarg.h>

#include <cades.h>

#include <stdbool.h>

#define DECLARE_FN(api, type, name, args) typedef WINAPI type (*name ## _FN) args

DECLARE_FN(WINBASEAPI, DWORD, GET_LAST_ERROR, (void));
DECLARE_FN(WINADVAPI, BOOL, CRYPT_RELEASE_CONTEXT, (HCRYPTPROV hProv, DWORD dwFlags));
DECLARE_FN(WINCRYPT32API,
           BOOL,
           CRYPT_SIGN_MESSAGE,
           (IN PCRYPT_SIGN_MESSAGE_PARA pSignPara,
            IN BOOL fDetachedSignature,
            IN DWORD cToBeSigned,
            IN const BYTE *rgpbToBeSigned[],
            IN DWORD rgcbToBeSigned[],
            OUT BYTE *pbSignedBlob,
            IN OUT DWORD *pcbSignedBlob));

DECLARE_FN(WINCRYPT32API,
           BOOL,
           CERT_FREE_CERTIFICATE_CONTEXT,
           (IN PCCERT_CONTEXT pCertContext));

DECLARE_FN(WINCRYPT32API,
           BOOL,
           CERT_GET_CERTIFICATE_CONTEXT_PROPERTY,
           (IN PCCERT_CONTEXT pCertContext,
            IN DWORD dwPropId,
            OUT void *pvData,
            IN OUT DWORD *pcbData));

DECLARE_FN(WINCRYPT32API,
           BOOL,
           CERT_SET_CERTIFICATE_CONTEXT_PROPERTY,
           (IN PCCERT_CONTEXT pCertContext,
            IN DWORD dwPropId,
            IN DWORD dwFlags,
            IN const void *pvData));

DECLARE_FN(WINCRYPT32API,
           PCCERT_CONTEXT,
           CERT_FIND_CERTIFICATE_IN_STORE,
           (IN HCERTSTORE hCertStore,
            IN DWORD dwCertEncodingType,
            IN DWORD dwFindFlags,
            IN DWORD dwFindType,
            IN const void *pvFindPara,
            IN PCCERT_CONTEXT pPrevCertContext));

DECLARE_FN(WINCRYPT32API,
           HCERTSTORE,
           CERT_OPEN_STORE,
           (IN LPCSTR lpszStoreProvider,
            IN DWORD dwEncodingType,
            IN HCRYPTPROV hCryptProv,
            IN DWORD dwFlags,
            IN const void *pvPara));

DECLARE_FN(WINCRYPT32API,
           BOOL,
           CERT_CLOSE_STORE,
           (IN HCERTSTORE hCertStore,
            DWORD dwFlags));

DECLARE_FN(WINCRYPT32API,
           BOOL,
           CRYPT_ACQUIRE_CERTIFICATE_PRIVATE_KEY,
           (IN PCCERT_CONTEXT pCert,
            IN DWORD dwFlags,
            IN void *pvReserved,
            OUT HCRYPTPROV *phCryptProv,
            OUT OPTIONAL DWORD *pdwKeySpec,
            OUT OPTIONAL BOOL *pfCallerFreeProv));

DECLARE_FN(WINADVAPI,
           BOOL,
           CRYPT_CREATE_HASH,
           (HCRYPTPROV hProv,
            ALG_ID Algid,
            HCRYPTKEY hKey,
            DWORD dwFlags,
            HCRYPTHASH *phHash));

DECLARE_FN(WINADVAPI,
           BOOL,
           CRYPT_HASH_DATA,
           (HCRYPTHASH hHash,
            CONST BYTE *pbData,
            DWORD dwDataLen,
            DWORD dwFlags));

DECLARE_FN (WINADVAPI,
            BOOL,
            CRYPT_DESTROY_HASH,
            (HCRYPTHASH hHash));

DECLARE_FN(WINADVAPI,
           BOOL,
           CRYPT_SIGN_HASH_A,
           (HCRYPTHASH hHash,
            DWORD dwKeySpec,
            LPCSTR szDescription,
            DWORD dwFlags,
            BYTE *pbSignature,
            DWORD *pdwSigLen));

DECLARE_FN(WINADVAPI,
           BOOL,
           CRYPT_SIGN_HASH_W,
           (HCRYPTHASH hHash,
            DWORD dwKeySpec,
            LPCWSTR szDescription,
            DWORD dwFlags,
            BYTE *pbSignature,
            DWORD *pdwSigLen));

DECLARE_FN(WINADVAPI,
           BOOL,
           CRYPT_VERIFY_SIGNATURE_A,
           (HCRYPTHASH hHash,
            CONST BYTE *pbSignature,
            DWORD dwSigLen,
            HCRYPTKEY hPubKey,
            LPCSTR szDescription,
            DWORD dwFlags));

DECLARE_FN(WINADVAPI,
           BOOL,
           CRYPT_VERIFY_SIGNATURE_W,
           (HCRYPTHASH hHash,
            CONST BYTE *pbSignature,
            DWORD dwSigLen,
            HCRYPTKEY hPubKey,
            LPCWSTR szDescription,
            DWORD dwFlags));

DECLARE_FN(WINADVAPI,
           BOOL,
           CRYPT_ACQUIRE_CONTEXT_A,
           (HCRYPTPROV *phProv,
            LPCSTR pszContainer,
            LPCSTR pszProvider,
            DWORD dwProvType,
            DWORD dwFlags));

DECLARE_FN(WINADVAPI,
           BOOL,
           CRYPT_ACQUIRE_CONTEXT_W,
           (HCRYPTPROV *phProv,
            LPCSTR pszContainer,
            LPCSTR pszProvider,
            DWORD dwProvType,
            DWORD dwFlags)); 

DECLARE_FN(WINADVAPI,
            BOOL,
            CRYPT_IMPORT_PUBLIC_KEY_INFO,
            (HCRYPTPROV hCryptProv,
             DWORD dwCertEncodingType,
             PCERT_PUBLIC_KEY_INFO pInfo,
             HCRYPTKEY *phKey));

DECLARE_FN(WINADVAPI,
           BOOL,
           CRYPT_DESTROY_KEY,
           (HCRYPTKEY hKey));

DECLARE_FN(WINADVAPI,
           BOOL,
           CERT_GET_CERTIFICATE_CHAIN,
            (HCERTCHAINENGINE hChainEngine,
             PCCERT_CONTEXT pCertContext,
             LPFILETIME pTime,
             HCERTSTORE hAdditionalStore,
             PCERT_CHAIN_PARA pChainPara,
             DWORD dwFlags,
             LPVOID pvReserved,
             PCCERT_CHAIN_CONTEXT* ppChainContext));

DECLARE_FN(WINADVAPI,
           BOOL,
           CERT_VERIFY_CERTIFICATE_CHAIN_POLICY,
           (LPCSTR pszPolicyOID,
            PCCERT_CHAIN_CONTEXT pChainContext,
            PCERT_CHAIN_POLICY_PARA pPolicyPara,
            PCERT_CHAIN_POLICY_STATUS pPolicyStatus));

DECLARE_FN(WINADVAPI,
           VOID,
           CERT_FREE_CERTIFICATE_CHAIN,
           (PCCERT_CHAIN_CONTEXT pChainContext));

DECLARE_FN(WINADVAPI,
            BOOL,
            CRYPT_GEN_RANDOM,
            (HCRYPTPROV hProv,
            DWORD dwLen,
            BYTE *pbBuffer));

#ifdef UNICODE
#define CRYPT_SIGN_HASH_FN          CRYPT_SIGN_HASH_W_FN
#define CRYPT_VERIFY_SIGNATURE_FN   CRYPT_VERIFY_SIGNATURE_W_FN
#define CRYPT_ACQUIRE_CONTEXT_FN    CRYPT_ACQUIRE_CONTEXT_W_FN
#else
#define CRYPT_SIGN_HASH_FN          CRYPT_SIGN_HASH_A_FN
#define CRYPT_VERIFY_SIGNATURE_FN   CRYPT_VERIFY_SIGNATURE_A_FN
#define CRYPT_ACQUIRE_CONTEXT_FN    CRYPT_ACQUIRE_CONTEXT_A_FN
#endif // !UNICODE


typedef struct {
    CRYPT_SIGN_MESSAGE_FN CryptSignMessage;
    CERT_FREE_CERTIFICATE_CONTEXT_FN CertFreeCertificateContext;
    CERT_OPEN_STORE_FN CertOpenStore;
    CERT_CLOSE_STORE_FN CertCloseStore;
    GET_LAST_ERROR_FN GetLastError;
    CRYPT_ACQUIRE_CERTIFICATE_PRIVATE_KEY_FN CryptAcquireCertificatePrivateKey;
    CRYPT_CREATE_HASH_FN CryptCreateHash;
    CRYPT_HASH_DATA_FN CryptHashData;
    CRYPT_SIGN_HASH_FN CryptSignHash;
    CRYPT_DESTROY_HASH_FN CryptDestroyHash;
    CRYPT_RELEASE_CONTEXT_FN CryptReleaseContext;
    CERT_FIND_CERTIFICATE_IN_STORE_FN CertFindCertificateInStore;
    CERT_GET_CERTIFICATE_CONTEXT_PROPERTY_FN CertGetCertificateContextProperty;
    CERT_SET_CERTIFICATE_CONTEXT_PROPERTY_FN CertSetCertificateContextProperty;
    CRYPT_VERIFY_SIGNATURE_FN CryptVerifySignature;
    CRYPT_ACQUIRE_CONTEXT_FN CryptAcquireContext;
    CRYPT_IMPORT_PUBLIC_KEY_INFO_FN CryptImportPublicKeyInfo;
    CRYPT_DESTROY_KEY_FN CryptDestroyKey;
    CERT_GET_CERTIFICATE_CHAIN_FN CertGetCertificateChain;
    CERT_VERIFY_CERTIFICATE_CHAIN_POLICY_FN CertVerifyCertificateChainPolicy;
    CERT_FREE_CERTIFICATE_CHAIN_FN CertFreeCertificateChain;
    CRYPT_GEN_RANDOM_FN CryptGenRandom;

} capi_function_list_t;


bool capi_function_list_init(library_t *lib, capi_function_list_t *fl);

#endif // CAPI_H_INCLUDED