#include "issuer.h"

typedef enum issuer_state {
    ON,
    JOINSTART,
    READY
} issuerstate_e;

typedef struct issuer {
    struct ecdaa_issuer_public_key_FP256BN ipk;
    struct ecdaa_issuer_secret_key_FP256BN isk;
    uint8_t nonce[NONCE_SIZE];
    struct ecdaa_member_public_key_FP256BN mpk;
    issuerstate_e state;
    struct ecdaa_credential_FP256BN cred;
    struct ecdaa_credential_FP256BN_signature cred_sig;
} issuer_t;

issuer_t issuer;

int issuer_setup();
int issuer_reset(char *buffer);
int issuer_joinstart(char *buffer);
int issuer_joinproceed(char *buffer);
int issuer_publish(char *buffer);

int main() {
    issuer.state = ON;
    if(ON == issuer.state) {
        if (0 == issuer_setup()) {
            issuer.state = READY;
        } else {
            printf("Error: Issuer setup failed.\n");
            return 1;
        }
    } 
    
    if (2 != server_start(&process_issuer, ISSUERPORT)) {
        printf("Error: Server failed.\n");
    }
    return 0;
}

int process_issuer(char *buffer) {
    int ret = 0;
    
#ifdef DEBUG
    printf("> ISSUER: %s\n", buffer);
#endif

    if (0 == strncasecmp("OK", buffer, 2)) {
        printf("Nothing to confirm.\n");
    } else if (0 == strncasecmp("ERR", buffer, 3)) {
        printf("Ignoring command.\n");
    } else if (0 == strncasecmp("ABORT", buffer, 5)) {
        switch (issuer.state) {
            case JOINSTART:
                printf("Aborting join.\n");
                issuer.state = READY;
                bzero(buffer, MAX_BUFSIZE);
                strncpy(buffer, "OK\n", 3);
                break;
            default:
                printf("Nothing to abort.\n");
                bzero(buffer, MAX_BUFSIZE);
                strncpy(buffer, "ERR\n", 4);
                break;
        }
    } else if (0 == strncasecmp("RESET", buffer, 5)) {
        switch (issuer.state) {
            case READY:
            case JOINSTART:
                printf("Generate new issuer identity.\n");
                if (0 == issuer_setup(buffer)) {
                    issuer.state = READY;
                    bzero(buffer, MAX_BUFSIZE);
                    strncpy(buffer, "OK\n", 3);
                } else {
                    printf("Error: Issuer setup failed.\n");
                    return 2;
                }
                break;
            default:
                printf("Reset not possible.\n");
                bzero(buffer, MAX_BUFSIZE);
                strncpy(buffer, "ERR\n", 4);
                break;
        }
    } else if (0 == strncasecmp("JOIN", buffer, 4)) {
        switch (issuer.state) {
            case READY:
                if(0 == issuer_joinstart(buffer)) {
                    issuer.state = JOINSTART;
                }
                break;
            default:
                printf("Issuer not ready for join.\n");
                bzero(buffer, MAX_BUFSIZE);
                strncpy(buffer, "ERR\n", 4);
                break;
        }
    } else if (0 == strncasecmp("APPEND", buffer, 6)) {
        switch (issuer.state) {
            case JOINSTART:
                if(0 == issuer_joinproceed(buffer)) {
                    issuer.state = READY;
                }
                break;
            default:
                printf("Issuer not ready for append.\n");
                bzero(buffer, MAX_BUFSIZE);
                strncpy(buffer, "ERR\n", 4);
                break;
        }
    } else if (0 == strncasecmp("PUBLISH", buffer, 7)) {
        switch (issuer.state) {
            case READY:
            case JOINSTART:
                issuer_publish(buffer);
                break;
            default:
                printf("There are no keys to publish.\n");
                bzero(buffer, MAX_BUFSIZE);
                strncpy(buffer, "ERR\n", 4);
                break;
        }
    } else if (0 == strncasecmp("EXIT", buffer, 4)) {
        printf("Closing client session.\n");
        bzero(buffer, MAX_BUFSIZE);
        ret = 1;
    } else if (0 == strncasecmp("SHUTDOWN", buffer, 8)) {
        bzero(buffer, MAX_BUFSIZE);
        ret = 2;
    } else {
        printf("Unknown command.\n");
        bzero(buffer, MAX_BUFSIZE);
        strncpy(buffer, "ERR\n", 4);
        ret = 0;
    }

    if(0 == ret) {
#ifdef DEBUG
        printf("< ISSUER: %s\n", buffer);
#endif
    }
    return ret;
}

// "JOIN" > "JOINSTART <issuer.nonce>"
int issuer_joinstart(char *buffer) {
    ecdaa_rand(issuer.nonce, NONCE_SIZE);
    char* current;
    int ret = 0;

    bzero(buffer, MAX_BUFSIZE);
    strncpy(buffer, "JOINSTART ", 10);
    current = &buffer[10];
    ret = ecdaa_encode(issuer.nonce, current, NONCE_SIZE);

    current[ret] = '\n';
    return 0;
}

// "APPEND <member.mpk>" > "JOINPROCEED <member.cred><member.cred_sig>"
int issuer_joinproceed(char *buffer) {
    char *current = &buffer[7];
    uint8_t binbuf[MAX_BUFSIZE];
    bzero(binbuf, MAX_BUFSIZE);
    int ret = 0;

    ecdaa_decode(current, binbuf, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH);
    bzero(buffer, MAX_BUFSIZE);
    ret = ecdaa_member_public_key_FP256BN_deserialize(&issuer.mpk, binbuf, issuer.nonce, NONCE_SIZE);
    if(-1 == ret) {
        strncpy(buffer, "ERR\n", 4);
        printf("issuer_joinproceed: Member public key is malformed!\n");
        return -1;
    } else if (-2 == ret) {
        strncpy(buffer, "ERR\n", 4);
        printf("issuer_joinproceed: Signature of member public key is invalid.\n");
        return -1;
    }

    if (0 != ecdaa_credential_FP256BN_generate(&issuer.cred, &issuer.cred_sig, &issuer.isk, &issuer.mpk, ecdaa_rand)) {
        strncpy(buffer, "ERR\n", 4);
        printf("issuer_joinproceed: Error generating credential.\n");
        return -1;
    }
    bzero(buffer, MAX_BUFSIZE);
    strncpy(buffer, "JOINPROCEED ", 12);

    current = &buffer[12];
    bzero(binbuf, MAX_BUFSIZE);
    ecdaa_credential_FP256BN_serialize(binbuf, &issuer.cred);
    ret = ecdaa_encode(binbuf, current, ECDAA_CREDENTIAL_FP256BN_LENGTH);

    current = &current[ret];
    bzero(binbuf, MAX_BUFSIZE);
    ecdaa_credential_FP256BN_signature_serialize(binbuf, &issuer.cred_sig);
    ret = ecdaa_encode(binbuf, current, ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH);

    current[ret] = '\n';
    return 0;
}

// "RESET > RESETDONE"
int issuer_reset(char *buffer) {
    printf("issuer_reset: Generating new keys and save them to disk.\n");
    if (0 != ecdaa_issuer_key_pair_FP256BN_generate(&issuer.ipk, &issuer.isk, ecdaa_rand)) {
        printf("issuer_reset: Error generating issuer key-pair.\n");
        strncpy(buffer, "ERR\n", 4);
        return -1;
    }
    if(0 != ecdaa_issuer_public_key_FP256BN_serialize_file(ISSUER_PUBLIC_KEY_FILE, &issuer.ipk) || 
            0 != ecdaa_issuer_secret_key_FP256BN_serialize_file(ISSUER_SECRET_KEY_FILE, &issuer.isk)) {
        printf("issuer_reset: Error saving key-pair to disk.\n");
        strncpy(buffer, "ERR\n", 4);
        return -1;
    }
    bzero(buffer, MAX_BUFSIZE);
    strncpy(buffer, "OK\n", 3);
    return 0;
}

//Load or generate issuer keypair initially
int issuer_setup() {
#ifdef DEBUG
    printf("setup()\n");
#endif
    if (0 == ecdaa_issuer_public_key_FP256BN_deserialize_file(&issuer.ipk, ISSUER_PUBLIC_KEY_FILE)) {
        if (0 == ecdaa_issuer_secret_key_FP256BN_deserialize_file(&issuer.isk, ISSUER_SECRET_KEY_FILE)) {
            printf("issuer_setup: Loaded keys from disk.\n");
            return 0;
        }
    }
    printf("issuer_setup: Generating new keys and save them to disk.\n");
    if (0 != ecdaa_issuer_key_pair_FP256BN_generate(&issuer.ipk, &issuer.isk, ecdaa_rand)) {
        printf("issuer_setup: Error generating issuer key-pair.\n");
        return -1;
    }
    if(0 != ecdaa_issuer_public_key_FP256BN_serialize_file(ISSUER_PUBLIC_KEY_FILE, &issuer.ipk) || 
            0 != ecdaa_issuer_secret_key_FP256BN_serialize_file(ISSUER_SECRET_KEY_FILE, &issuer.isk)) {
        printf("issuer_setup: Error saving key-pair to disk.\n");
        return -1;
    }
    return 0;
}

// "PUBLISH" > "PUBLISH <issuer.ipk>"
int issuer_publish(char *buffer) {
    char *current;
    uint8_t binbuf[MAX_BUFSIZE];
    bzero(buffer, MAX_BUFSIZE);
    int ret = 0;

    strncpy(buffer, "PUBLISH ", 8);

    current = &buffer[8];
    bzero(binbuf, MAX_BUFSIZE);
    ecdaa_issuer_public_key_FP256BN_serialize(binbuf, &issuer.ipk);
    ret = ecdaa_encode(binbuf, current, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH);

    current[ret] = '\n';

    return 0;
}