#include "member.h"

typedef enum memberstate {
    ON,
    ISSUERPUB,
    RCVPUBLIC,
    JOIN,
    APPEND,
    JOINPROCEED,
    JOINED,
    ATTEST,
    PUBLISH
} memberstate_e;

typedef struct member {
    struct ecdaa_member_public_key_FP256BN mpk;
    struct ecdaa_member_secret_key_FP256BN msk;
    memberstate_e state;
    uint8_t nonce[NONCE_SIZE];
    struct ecdaa_credential_FP256BN cred;
    struct ecdaa_credential_FP256BN_signature cred_sig;
    struct ecdaa_issuer_public_key_FP256BN ipk;
} member_t;

member_t member;

int member_join(char *buffer);

int member_attest(char *buffer);

int member_publish(char *buffer);

int member_getpublic(char *buffer);

int member_joinappend(char *buffer);

int member_joinfinish(char *buffer);

int main() {

    if (2 != server_start(&process_member, MEMBERPORT)) {
        printf("server failed\n");
    }
    return 0;
}

int process_member(char *buffer) {
    int ret = 0;

    printf("> MEMBER: %s\n", buffer);

    if (member.state == JOINED && 0 == strncasecmp("ATTEST", buffer, 6)) {
        bzero(buffer, MAX_BUFSIZE);
        strncpy(buffer, "ATTEST ", 7);
        member_attest(buffer);
    } else if (member.state == ON && 0 == strncasecmp("GETPUBLIC", buffer, 9)) {
        bzero(buffer, MAX_BUFSIZE);
        ret = client_connect(&member_getpublic, ISSUERIP, ISSUERPORT);
        if (0 >= ret || RCVPUBLIC != member.state) {
            printf("process_member: issuer connection failed\n");
            bzero(buffer, MAX_BUFSIZE);
            strncpy(buffer, "ERR\n", 4);
        } else {
            bzero(buffer, MAX_BUFSIZE);
            strncpy(buffer, "OK\n", 3);
        }
        ret = 0;
    } else if (0 == strncasecmp("PUBLISH", buffer, 7)) {
        bzero(buffer, MAX_BUFSIZE);
        member_publish(buffer);
    } else if (member.state == RCVPUBLIC && 0 == strncasecmp("JOIN", buffer, 4)) {
        member.state = JOIN;
        ret = client_connect(&member_join, ISSUERIP, ISSUERPORT);
        if (0 >= ret || JOINED != member.state) {
            printf("process_member: issuer connection failed\n");
            bzero(buffer, MAX_BUFSIZE);
            strncpy(buffer, "ERR\n", 4);
        } else {
            bzero(buffer, MAX_BUFSIZE);
            strncpy(buffer, "OK\n", 3);
        }
        ret = 0;
    } else if (0 == strncasecmp("EXIT", buffer, 4)) {
        bzero(buffer, MAX_BUFSIZE);
        strncpy(buffer, "OK\n", 3);
        ret = 1;
    } else if (0 == strncasecmp("SHUTDOWN", buffer, 8)) {
        bzero(buffer, MAX_BUFSIZE);
        strncpy(buffer, "OK\n", 3);
        ret = 2;
    } else {
        bzero(buffer, MAX_BUFSIZE);
        strncpy(buffer, "ERR\n", 4);
        ret = 0;
    }

    printf("< MEMBER: %s\n", buffer);
    return ret;
}

int member_join(char *buffer) {
    int ret = 0;

    switch (member.state) {
        case JOIN:
            bzero(buffer, MAX_BUFSIZE);
            strncpy(buffer, "JOIN\n", 5);
            member.state = APPEND;
            break;
        case APPEND:
            if (0 == strncasecmp("JOINSTART", buffer, 9)) {
                printf("ISSUER > MEMBER: %s", buffer);
                member_joinappend(buffer);
                member.state = JOINPROCEED;
            }
            break;
        case JOINPROCEED:
            if (0 == strncasecmp("JOINPROCEED", buffer, 11)) {
                printf("ISSUER > MEMBER: %s", buffer);
                member_joinfinish(buffer);
                member.state = JOINED;
                ret = 1;
            }
            break;
        default:
            ret - 1;
    }
    if (0 == ret) {
        printf("ISSUER < MEMBER: %s", buffer);
    }
    return ret;
}

int member_getpublic(char *buffer) {
    int ret = 0;

    switch (member.state) {
        case ON:
            bzero(buffer, MAX_BUFSIZE);
            strncpy(buffer, "PUBLISH\n", 8);
            member.state = ISSUERPUB;
            break;
        case ISSUERPUB:
            if (0 == strncasecmp("PUBLISH", buffer, 7)) {
                printf("ISSUER > MEMBER: %s", buffer);
                uint8_t binbuf[MAX_BUFSIZE];
                char *current = &buffer[8];
                ecdaa_hextobin(current, binbuf, ECDAA_ISSUER_PUBLIC_KEY_FP256BN_LENGTH);
                ret = ecdaa_issuer_public_key_FP256BN_deserialize(&member.ipk, binbuf);
                if (-1 == ret) {
                    printf("member_getpublic: issuer public key is malformed!\n");
                    ret = -1;
                } else if (-2 == ret) {
                    printf("member_getpublic: signature of issuer public key is invalid\n");
                    ret = -1;
                } else {
                    member.state = RCVPUBLIC;
                    ret = 1;
                }
            }
            break;
        default:
            ret = -1;
            break;
    }
    if (0 == ret) {
        printf("ISSUER < MEMBER: %s", buffer);
    }
    return ret;
}

//"ATTEST" > "ATTEST <attestval>"
int member_attest(char *buffer) {
    strncat(buffer, "<attestval>\n", 13);
    return 0;
}

//"PUBLISH" > "PUBLISH <member.mpk>"
int member_publish(char *buffer) {
    char *current;
    uint8_t binbuf[MAX_BUFSIZE];
    bzero(buffer, MAX_BUFSIZE);

    strncpy(buffer, "PUBLISH ", 8);

    current = &buffer[8];
    bzero(binbuf, MAX_BUFSIZE);
    ecdaa_member_public_key_FP256BN_serialize(binbuf, &member.mpk);
    ecdaa_bintohex(binbuf, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH, current);

    buffer[2 * ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH + 8] = '\n';

    return 0;
}

//"JOINSTART <issuer.nonce>" > "APPEND <member.mpk>"
int member_joinappend(char *buffer) {
    char *current = &buffer[10];
    uint8_t binbuf[MAX_BUFSIZE];
    ecdaa_hextobin(current, member.nonce, NONCE_SIZE);

    if (0 != ecdaa_member_key_pair_FP256BN_generate(&member.mpk, &member.msk, member.nonce, NONCE_SIZE, ecdaa_rand)) {
        fprintf(stderr, "Error generating member key-pair\n");
        return -1;
    }
    bzero(buffer, MAX_BUFSIZE);
    strncpy(buffer, "APPEND ", 7);

    current = &buffer[7];
    bzero(binbuf, MAX_BUFSIZE);
    ecdaa_member_public_key_FP256BN_serialize(binbuf, &member.mpk);
    ecdaa_bintohex(binbuf, ECDAA_MEMBER_PUBLIC_KEY_FP256BN_LENGTH, current);
    return 0;
}

//"JOINPROCEED <member.cred><member.cred_sig>" > ""
int member_joinfinish(char *buffer) {
    char *current = &buffer[12];
    uint8_t *bincur;
    uint8_t binbuf[MAX_BUFSIZE];
    int ret = 0;
    bzero(binbuf, MAX_BUFSIZE);
    ecdaa_hextobin(current, binbuf, ECDAA_CREDENTIAL_FP256BN_LENGTH);

    current = &buffer[12 + 2 * ECDAA_CREDENTIAL_FP256BN_LENGTH + 1];
    bincur = &binbuf[ECDAA_CREDENTIAL_FP256BN_LENGTH];
    ecdaa_hextobin(current, bincur, ECDAA_CREDENTIAL_FP256BN_SIGNATURE_LENGTH);
    ret = ecdaa_credential_FP256BN_deserialize_with_signature(&member.cred, &member.mpk, &member.ipk.gpk, binbuf, bincur);
    if(-1 == ret) {
        printf("member_joinfinish: credential is malformed!\n");
        ret = -1;
    } else if(-2 == ret) {
        printf("member_joinfinish: siganture of credential is invalid");
        ret = -1;
    }

    return ret;
}