// This file is under GNU General Public License 3.0

// see LICENSE.txt

#include "pEp_internal.h"

#include <memory.h>

#include <assert.h>

#include "asn1_helper.h"

#include "../asn.1/DeviceGroup-Protocol.h"

// receive_sync_msg is defined in the sync_impl

PEP_STATUS receive_sync_msg(

        PEP_SESSION session,

        sync_msg_t *sync_msg,

        time_t *timeout

    );

DYNAMIC_API PEP_STATUS register_sync_callbacks(

        PEP_SESSION session,

        void *management,

        messageToSend_t messageToSend,

        notifyHandshake_t notifyHandshake,

        inject_sync_msg_t inject_sync_msg,

        retrieve_next_sync_msg_t retrieve_next_sync_msg

    )

{

    assert(session && management && messageToSend && notifyHandshake && inject_sync_msg && retrieve_next_sync_msg);

    if (!(session && management && messageToSend && notifyHandshake && inject_sync_msg && retrieve_next_sync_msg))

        return PEP_ILLEGAL_VALUE;

    pEpUUID uuid;

    uuid_generate_random(uuid);

    uuid_unparse_upper(uuid, session->sync_uuid);

    session->sync_management = management;

    session->messageToSend = messageToSend;

    session->notifyHandshake = notifyHandshake;

    session->inject_sync_msg = inject_sync_msg;

    session->retrieve_next_sync_msg = retrieve_next_sync_msg;

    // start state machine

    session->sync_state = InitState;

    time_t unused = 0;

    PEP_STATUS status = fsm_DeviceState_inject(session, Init, NULL, NULL, &unused);

    if (status != PEP_STATUS_OK)

        unregister_sync_callbacks(session);

    return status;

}

DYNAMIC_API PEP_STATUS attach_sync_session(

        PEP_SESSION session,

        PEP_SESSION sync_session

    )

{

    assert(session && sync_session && sync_session->sync_management && sync_session->inject_sync_msg );

    if (!(session && sync_session && sync_session->sync_management && sync_session->inject_sync_msg ))

        return PEP_ILLEGAL_VALUE;

    session->sync_session = sync_session;

    // memcpy(session->sync_uuid, sync_session->sync_uuid, 37);

    // session->sync_management = sync_session->sync_management;

    // session->inject_sync_msg = sync_session->inject_sync_msg;

    return PEP_STATUS_OK;

}

DYNAMIC_API PEP_STATUS detach_sync_session(PEP_SESSION session)

{

    assert(session);

    if (!(session))

        return PEP_ILLEGAL_VALUE;

    session->sync_session = session;

    // memset(session->sync_uuid, 0, 37);

    // session->sync_management = NULL;

    // session->inject_sync_msg = NULL;

    return PEP_STATUS_OK;

}

int call_inject_sync_msg(PEP_SESSION session, void *msg)

{

    if(session->sync_session->inject_sync_msg &&

       session->sync_session->sync_management)

        return session->sync_session->inject_sync_msg(msg, 

            session->sync_session->sync_management);

    else

       return PEP_SYNC_NO_INJECT_CALLBACK;

}

DYNAMIC_API void unregister_sync_callbacks(PEP_SESSION session) {

    // stop state machine

    session->sync_state = DeviceState_state_NONE;

    // unregister

    session->sync_management = NULL;

    session->messageToSend = NULL;

    session->notifyHandshake = NULL;

    session->inject_sync_msg = NULL;

    session->retrieve_next_sync_msg = NULL;

}

DYNAMIC_API PEP_STATUS deliverHandshakeResult(

        PEP_SESSION session,

        Identity partner,

        sync_handshake_result result

    )

{

    assert(session);

    if (!session)

        return PEP_ILLEGAL_VALUE;

    PEP_STATUS status = PEP_STATUS_OK;

    DeviceState_event event;

    bool need_partner = false;

    switch (result) {

        case SYNC_HANDSHAKE_CANCEL:

            event = Cancel;

            break;

        case SYNC_HANDSHAKE_ACCEPTED:

        {

            event = HandshakeAccepted;

            need_partner = true;

            break;

        }

        case SYNC_HANDSHAKE_REJECTED:

        {

            event = HandshakeRejected;

            need_partner = true;

            break;

        }

        default:

            return PEP_ILLEGAL_VALUE;

    }

    pEp_identity *_partner = NULL;

    if(need_partner){

        _partner = identity_dup(partner);

        if (_partner == NULL)

            return PEP_OUT_OF_MEMORY;

    }

    status = inject_DeviceState_event(session, event, _partner, NULL);

    return status;

}

DYNAMIC_API PEP_STATUS do_sync_protocol(

        PEP_SESSION session,

        void *obj

    )

{

    sync_msg_t *msg = NULL;

    PEP_STATUS status = PEP_STATUS_OK;

    time_t timeout = 0;

    assert(session && session->retrieve_next_sync_msg);

    assert(obj);

    if (!(session && session->retrieve_next_sync_msg) || !obj)

        return PEP_ILLEGAL_VALUE;

    log_event(session, "sync_protocol thread started", "pEp sync protocol", NULL, NULL);

    session->sync_obj = obj;

    while (true) 

    {

        msg = (sync_msg_t *) session->retrieve_next_sync_msg(session->sync_management, &timeout);

        if(msg == NULL && timeout == 0)

            break;

        else if(msg == NULL && timeout != 0){

            status = fsm_DeviceState_inject(session, Timeout, NULL, NULL, &timeout);

#ifndef NDEBUG

            char buffer[MAX_LINELENGTH];

            memset(buffer, 0, MAX_LINELENGTH);

            snprintf(buffer, MAX_LINELENGTH, "problem with timeout event : %d\n", (int) status);

            log_event(session, buffer, "pEp sync protocol", NULL, NULL);

            continue;

#endif

        }

        else {

            status = receive_sync_msg(session, msg, &timeout);

            if (status != PEP_STATUS_OK && status != PEP_MESSAGE_IGNORE) {

#ifndef NDEBUG

                char buffer[MAX_LINELENGTH];

                memset(buffer, 0, MAX_LINELENGTH);

                snprintf(buffer, MAX_LINELENGTH, "problem with msg received: %d\n", (int) status);

                log_event(session, buffer, "pEp sync protocol", NULL, NULL);

#endif

            }

        }

    }

    log_event(session, "sync_protocol thread shutdown", "pEp sync protocol", NULL, NULL);

    session->sync_obj = NULL;

    return PEP_STATUS_OK;

}

DYNAMIC_API PEP_STATUS decode_sync_msg(

        const char *data,

        size_t size,

        char **text

    )

{

    PEP_STATUS status = PEP_STATUS_OK;

    assert(data && text);

    if (!(data && text))

        return PEP_ILLEGAL_VALUE;

    *text = NULL;

    DeviceGroup_Protocol_t *msg = NULL;

    uper_decode_complete(NULL, &asn_DEF_DeviceGroup_Protocol, (void **) &msg,

            data, size);

    if (!msg)

        return PEP_SYNC_ILLEGAL_MESSAGE;

    growing_buf_t *dst = new_growing_buf();

    if (!dst) {

        status = PEP_OUT_OF_MEMORY;

        goto the_end;

    }

    asn_enc_rval_t er = xer_encode(&asn_DEF_DeviceGroup_Protocol, msg,

            XER_F_BASIC, (asn_app_consume_bytes_f *) consume_bytes, (void *) dst);

    if (er.encoded == -1) {

        status = PEP_CANNOT_ENCODE;

        goto the_end;

    }

    *text = dst->data;

    dst->data = NULL;

the_end:

    free_growing_buf(dst);

    ASN_STRUCT_FREE(asn_DEF_DeviceGroup_Protocol, msg);

    return status;

}

DYNAMIC_API PEP_STATUS encode_sync_msg(

        const char *text,

        char **data,

        size_t *size

    )

{

    PEP_STATUS status = PEP_STATUS_OK;

    assert(text && data && size);

    if (!(text && data && size))

        return PEP_ILLEGAL_VALUE;

    *data = NULL;

    *size = 0;

    DeviceGroup_Protocol_t *msg = NULL;

    asn_dec_rval_t dr = xer_decode(NULL, &asn_DEF_DeviceGroup_Protocol,

            (void **) &msg, (const void *) text, strlen(text));

    if (dr.code != RC_OK) {

        status = PEP_SYNC_ILLEGAL_MESSAGE;

        goto the_end;

    }

    char *payload = NULL;

    ssize_t _size = uper_encode_to_new_buffer(&asn_DEF_DeviceGroup_Protocol,

            NULL, msg, (void **) &payload);

    if (_size == -1) {

        status = PEP_CANNOT_ENCODE;

        goto the_end;

    }

    *data = payload;

    *size = (size_t) _size;

the_end:

    ASN_STRUCT_FREE(asn_DEF_DeviceGroup_Protocol, msg);

    return status;

}