// This file is under GNU General Public License 3.0

// see LICENSE.txt

// generate state machine code

// Copyleft (c) 2016 - 2018, p≡p foundation

// Written by Volker Birk

include yslt.yml2

tstylesheet {

    include standardlib.ysl2

    include ./functions.ysl2

    template "/protocol" {

        document "generated/{@name}_event.h", "text"

        ||

        // This file is under GNU General Public License 3.0

        // see LICENSE.txt

        #pragma once

        #include "dynamic_api.h"

        #ifdef __cplusplus

        extern "C" {

        #endif

        #include "«@name».h"

        typedef struct «@name»_event {

            «@name»_PR fsm;

            int event;

            «@name»_t *msg;

        } «@name»_event_t;

        // new_«@name»_event() - allocate a new «@name»_event

        //

        //  parameters:

        //      fsm (in)        finite state machine the event is for

        //      event (in)      event or None

        //      msg (in)        message to compute event from

        //

        //  return value:

        //      pointer to new event or NULL in case of failure

        //

        //  caveat:

        //      event must be valid for fsm or None

        //      in case msg is given event will be calculated out of message

        DYNAMIC_API «@name»_event_t *new_«@name»_event(«@name»_PR fsm, int event, «@name»_t *msg);

        // free_«@name»_event() - free memory occupied by event

        //

        //  parameters:

        //      ev (in)         event to free

        DYNAMIC_API void free_«@name»_event(«@name»_event_t *ev);

        #ifdef __cplusplus

        }

        #endif

        ||

        document "generated/{@name}_event.c", "text"

        ||

        // This file is under GNU General Public License 3.0

        // see LICENSE.txt

        #include "pEp_internal.h"

        #include "«@name»_event.h"

        #include "«@name»_func.h"

        `` for "fsm" | #include "«@name»_fsm.h"

        DYNAMIC_API «@name»_event_t *new_«@name»_event(«@name»_PR fsm, int event, «@name»_t *msg)

        {

            assert(fsm > 0 && (event >= 0 |`> |` msg));

            if (!(fsm > 0 && (event >= 0 |`> |` msg)))

                return NULL;

            «@name»_event_t *ev = («@name»_event_t *) calloc(1, sizeof(«@name»_event_t));

            assert(ev);

            if (!ev)

                return NULL;

            ev->fsm = fsm;

            ev->event = event;

            ev->msg = msg;

            if (msg) {

                switch (fsm) {

                    `` apply "fsm", 3, mode=event

                    default:

                        // unknown protocol

                        free(ev);

                        return NULL;

                }

            }

            return ev;

        }

        DYNAMIC_API void free_«@name»_event(«@name»_event_t *ev)

        {

            if (ev) {

                free_«@name»_message(ev->msg);

                free(ev);

            }

        }

        ||

        document "generated/{@name}_impl.h", "text" {

        ||

        // This file is under GNU General Public License 3.0

        // see LICENSE.txt

        #pragma once

        #include "fsm_common.h"

        #include "message_api.h"

        #include "«@name»_event.h"

        #ifdef __cplusplus

        extern "C" {

        #endif

        // conditions

        ||

        for "func:distinctName(*//condition)"

            | PEP_STATUS «@name»(PEP_SESSION session, bool *result);

        ||

        // actions

        ||

        for "func:distinctName(*//action)"

            | PEP_STATUS «@name»(PEP_SESSION session);

        ||

        // notify state machine from event

        // use state to generate «@name» message if necessary

        PEP_STATUS «@name»_notify(

                PEP_SESSION session, 

                «@name»_PR fsm,

                int message_type

            );

        // send message about an event to communication partners using state

        PEP_STATUS send_«@name»_message(

                PEP_SESSION session, 

                «@name»_PR fsm,

                int message_type

            );

        // receive message and store it in state

        PEP_STATUS recv_«@name»_event(

                PEP_SESSION session,

                «@name»_event_t *ev

            );

        // state machine driver

        // if fsm or event set to 0 use fields in src if present

        PEP_STATUS «@name»_driver(

                PEP_SESSION session,

                «@name»_PR fsm,

                int event

            );

        PEP_STATUS inject_«@name»_event(

                PEP_SESSION session, 

                «@name»_PR fsm,

                int event

            );

        #ifdef __cplusplus

        }

        #endif

        ||

        }

        document "generated/{@name}_impl.c", "text"

        ||

        // This file is under GNU General Public License 3.0

        // see LICENSE.txt

        #include "«@name»_impl.h"

        #include "pEp_internal.h"

        #include "«@name»_event.h"

        #include "«@name»_codec.h"

        #include "baseprotocol.h"

        `` for "fsm" | #include "«@name»_fsm.h"

        PEP_STATUS «@name»_driver(

                PEP_SESSION session,

                «@name»_PR fsm,

                int event

            )

        {

            assert(session && fsm);

            if (!(session && fsm))

                return PEP_ILLEGAL_VALUE;

            int next_state = None;

            do {

                switch (fsm) {

                    `` apply "fsm", 3, mode=driver               

                    default:

                        return PEP_ILLEGAL_VALUE;

                }

            }  while (next_state);

            return PEP_STATUS_OK;

        }

        PEP_STATUS inject_«@name»_event(

                PEP_SESSION session, 

                «@name»_PR fsm,

                int event

            )

        {

            «@name»_t *msg = NULL;

            «@name»_event_t *ev = NULL;

            assert(session && fsm > 0 && event > None);

            if (!(session && fsm > 0 && event > None))

                return PEP_ILLEGAL_VALUE;

            PEP_STATUS status = PEP_STATUS_OK;

            if (!session->inject_«yml:lcase(@name)»_event) {

               status = PEP_«yml:ucase(@name)»_NO_INJECT_CALLBACK;

               goto error;

            }

            if (event < Extra) {

                msg = new_«@name»_message(fsm, event);

                if (!msg) {

                    status = PEP_OUT_OF_MEMORY;

                    goto error;

                }

                status = update_«@name»_message(session, msg);

                if (status)

                    goto error;

            }

            ev = («@name»_event_t *) calloc(1, sizeof(«@name»_event_t));

            assert(ev);

            if (!ev) {

                status = PEP_OUT_OF_MEMORY;

                goto error;

            }

            ev->fsm = fsm;

            ev->event = event;

            ev->msg = msg;

            int result = session->inject_«yml:lcase(@name)»_event(ev,

                    session->«yml:lcase(@name)»_management);

            if (result) {

                status = PEP_STATEMACHINE_ERROR;

                goto error;

            }

            goto the_end;

        error:

            free(ev);

            free_«@name»_message(msg);

        the_end:

            return status;

        }

        PEP_STATUS «@name»_notify(

                PEP_SESSION session, 

                «@name»_PR fsm,

                int message_type

            )

        {

            assert(session && fsm > 0 && message_type > 1 && message_type < Extra);

            if (!(session && fsm > 0 && message_type > 1 && message_type < Extra))

                return PEP_ILLEGAL_VALUE;

            PEP_STATUS status = PEP_STATUS_OK;

            «@name»_t *msg = new_«@name»_message(fsm, message_type);

            if (!msg) {

                status = PEP_OUT_OF_MEMORY;

                goto error;

            }

            status = update_«@name»_message(session, msg);

            if (status)

                goto error;

            goto the_end;

        error:

            free_«@name»_message(msg);

        the_end:

            return status;

        }

        PEP_STATUS send_«@name»_message(

                PEP_SESSION session, 

                «@name»_PR fsm,

                int message_type

            )

        {

            PEP_STATUS status = PEP_STATUS_OK;

            assert(session && fsm > None && message_type > None);

            if (!(session && fsm > None && message_type > None))

                return PEP_ILLEGAL_VALUE;

            «@name»_t *msg = new_«@name»_message(fsm, message_type);

            if (!msg)

                return PEP_OUT_OF_MEMORY;

            char *data = NULL;

            message *m = NULL;

            identity_list *channels = NULL;

            status = update_«@name»_message(session, msg);

            if (status)

                goto the_end;

            size_t size = 0;

            status = encode_«@name»_message(msg, &data, &size);

            if (status)

                goto the_end;

            switch (message_type) {

                // these messages are broadcasted

                `` for "fsm/message[@type='broadcast']" |>> case «@name»:

                    status = _own_identities_retrieve(session, &channels, PEP_idf_not_for_sync);

                    if (!status)

                        goto the_end;

                    break;

                // all other go unicast

                default: {

                    if (!session->«yml:lcase(@name)»_state.common.from `> |`|

                        (session->«yml:lcase(@name)»_state.common.from->flags &

                        PEP_idf_not_for_sync))

                    {

                        status = PEP_SYNC_NO_CHANNEL;

                        goto the_end;

                    }

                    pEp_identity *channel = identity_dup(session->«yml:lcase(@name)»_state.common.from);

                    if (!channel) {

                        status = PEP_OUT_OF_MEMORY;

                        goto the_end;

                    }

                    channels = new_identity_list(channel);

                    if (!channels) {

                        status = PEP_OUT_OF_MEMORY;

                        goto the_end;

                    }

                }

            }

            for (identity_list *li = channels; li && li->ident ; li = li->next) {

                status = base_prepare_message(

                        li->ident,

                        li->ident,

                        data,

                        size,

                        &m

                    );

                if (status)

                    goto the_end;

                status = session->messageToSend(session->«yml:lcase(@name)»_obj, m);

                free_message(m);

                m = NULL;

            }

        the_end:

            free_identity_list(channels);

            free_message(m);

            free(data);

            free_«@name»_message(msg);

            return status;

        }

        PEP_STATUS recv_«@name»_event(

                PEP_SESSION session,

                «@name»_event_t *ev

            )

        {

            assert(session && ev);

            if (!(session && ev))

                return PEP_ILLEGAL_VALUE;

            PEP_STATUS status = PEP_STATUS_OK;

            if (ev->event < Extra) {

                «@name»_PR fsm = (int) None;

                int event = None;

                status = update_«@name»_state(session, ev->msg, &fsm, &event);

                if (status)

                    goto error;

                if (ev->fsm) {

                    if (ev->fsm != fsm |`> |` ev->event != event) {

                        status = PEP_«yml:ucase(@name)»_ILLEGAL_MESSAGE;

                        goto error;

                    }

                }

                else {

                    if (ev->event) {

                        status = PEP_«yml:ucase(@name)»_ILLEGAL_MESSAGE;

                        goto error;

                    }

                    ev->fsm = fsm;

                    ev->event = event;

                }

            }

            free_«@name»_message(ev->msg);

            free(ev);

            status = «@name»_driver(session, ev->fsm, ev->event);

            return status;

        error:

            free_«@name»_message(ev->msg);

            free(ev);

            return status;

        }

        ||

        apply "fsm", 0, mode=gen;

    }

    template "fsm", mode=event

    {

    ||

    case «../@name»_PR_«yml:lcase(@name)»: {

        switch (msg->choice.«yml:lcase(@name)».payload.present) {

    ||

    for "message"

    ||

            case «../@name»__payload_PR_«yml:mixedCase(@name)»:

                ev->event = «@name»;

                break;

    ||

    ||

            default:

                // unknown message type

                free(ev);

                return NULL;

        }

        break;

    }

    ||

    }

    template "fsm", mode=driver

    ||

    case «../@name»_PR_«yml:lcase(@name)»: {

        int state = session->«yml:lcase(../@name)»_state.«yml:lcase(@name)».state;

        next_state = fsm_«@name»(session, state, event);

        if (next_state > None) {

            session->«yml:lcase(../@name)»_state.«yml:lcase(@name)».state = next_state;

            event = Init;

        }

        else if (next_state < None) {

            return PEP_STATEMACHINE_ERROR - state;

        }

        break;

    }

    ||

    template "fsm", mode=gen {

        document "generated/{@name}_fsm.h", "text" {

        ||

        // This file is under GNU General Public License 3.0

        // see LICENSE.txt

        #pragma once

        #include "«../@name»_impl.h"

        #ifdef __cplusplus

        extern "C" {

        #endif

        // state machine for «@name»

        // states

        typedef enum _«@name»_state {

            «@name»_state_None = None,

            «@name»_state_Init = Init,

        ||

        for "func:distinctName(state[not(@name='InitState')])"

            |> «@name»`if "position()!=last()" > , `

        ||

        } «@name»_state;

        // events

        typedef enum _«@name»_event {

            «@name»_event_None = None,

            «@name»_event_Init = Init,

        ||

        for "func:distinctName(state/event[not(not(../../message/@name=@name))])" {

            const "name", "@name";

            |> «$name» = «/protocol/fsm/message[@name=$name]/@id»,

        }

        for "func:distinctName(state/event[not(not(../../external/@name=@name))])" {

            const "name", "@name";

            |> «$name» = «/protocol/fsm/external[@name=$name]/@id»,

        }

        |> «@name»_event_Extra = Extra,

        for "func:distinctName(state/event[not(../../message/@name=@name or ../../external/@name=@name)])" {

            if "@name!='Init'"

                |> «@name»`if "position()!=last()" > , `

        }

        ||

        } «@name»_event;

        // state machine

        const char *«@name»_state_name(int state);

        // the state machine function is returning the next state in case of a

        // transition or None for staying

        «@name»_state fsm_«@name»(

                PEP_SESSION session,

                «@name»_state state,

                «@name»_event event

            );

        #ifdef __cplusplus

        }

        #endif

        ||

        }

        document "generated/{@name}_fsm.c", "text" {

        ||

        // This file is under GNU General Public License 3.0

        // see LICENSE.txt

        #include "«@name»_fsm.h"

        #include <stdlib.h>

        const char *«@name»_state_name(int state)

        {

            switch (state) {

                case End:

                    return "End";

                case None:

                    return "None";

                case Init:

                    return "InitState";

        ||

        for "func:distinctName(state[not(@name='InitState')])" {

            |>> case «@name»:

            |>>> return "«@name»";

        }

        ||

                default:

                    return "unknown state";

            }

        }

        static char *_str(int n, bool hex)

        {

            char *buf = calloc(1, 24);

            assert(buf);

            if (!buf)

                return NULL;

            if (hex)

                snprintf(buf, 24, "%.4x", n);

            else

                snprintf(buf, 24, "%d", n);

            return buf;

        }

        #define «@name»_ERR_LOG(t, d) log_event(session, (t), "«@name»", (d), "error")

        static PEP_STATUS _«@name»_ERR_LOG_int(PEP_SESSION session, char *t, int n, bool hex)

        {

            char *_buf = _str(n, hex);

            if (!_buf)

                return PEP_OUT_OF_MEMORY;

            PEP_STATUS status = «@name»_ERR_LOG(t, _buf);

            free(_buf);

            return status;

        }

        #define «@name»_ERR_LOG_INT(t, n) _«@name»_ERR_LOG_int(session, (t), (n), false)

        #define «@name»_ERR_LOG_HEX(t, n) _«@name»_ERR_LOG_int(session, (t), (n), true)

        #ifndef SERVICE_LOG

        // SERVICE LOG is meant to check session->service_log in runtime config;

        // for older engines log more than needed

        #define SERVICE_LOG(session, t, n, d) log_event((session), (t), (n), (d), "service")

        #endif 

        #define «@name»_SERVICE_LOG(t, d) SERVICE_LOG(session, (t), "«@name»", (d))

        «@name»_state fsm_«@name»(

                PEP_SESSION session,

                «@name»_state state,

                «@name»_event event

            )

        {

            assert(session);

            if (!session)

                return invalid_state;

            switch (state) {

                case None:

                    return «@name»_state_Init;

                `` apply "state", 2, mode=fsm

                default:

                    «@name»_ERR_LOG_INT("invalid state", state);

                    return invalid_state;

            }

            return None;

        }

        ||

        }

    }

    template "state", mode=fsm {

        choose {

            when "@name='InitState'" | case «../@name»_state_Init:

            otherwise | case «@name»:

        }

        ||

            «../@name»_SERVICE_LOG("in state", "«@name»");

            switch (event) {

                case None:

                    «../@name»_SERVICE_LOG("received None event", "ignoring");

                    break;

        ||

        if "not(event[@name='Init'])"

        ||

                case Init:

                    // nothing to do

                    break;

        ||

        ||

                `` apply "event", 2, mode=fsm

                default:

                    «../@name»_ERR_LOG_INT("invalid event", event);

                    return invalid_event;

            }

            break;

        ||

    }

    template "event", mode=fsm {

        | case «@name»: {

        if "condition|action|send" |> PEP_STATUS status;

        if "condition" |> bool result = false;

        if "condition|action|send" |

        ||

            «../../@name»_SERVICE_LOG("received event", "«@name»");

            `` apply "transition|action|condition|send";

        ||

        if "name(*[last()])!='transition'" {

            |

            |> «../../@name»_SERVICE_LOG("remaining in state", "«../@name»");

            |> break;

        }

        ||

        }

        ||

    }

    template "transition" {

        const "fsm", "ancestor::fsm";

        ||

        «$fsm/@name»_SERVICE_LOG("transition to state", "«@target»");

        return «@target»;

        ||

    }

    template "send" {

        const "fsm", "ancestor::fsm";

        const "protocol", "ancestor::protocol";

        ||

        «$fsm/@name»_SERVICE_LOG("send message", "«@name»");

        status = send_«$protocol/@name»_message(session, «$fsm/@id», «$fsm/@name»__payload_PR_«yml:mixedCase(@name)»);

        ||

    }

    template "action" {

        const "fsm", "ancestor::fsm";

        ||

        «$fsm/@name»_SERVICE_LOG("do action", "«@name»");

        status = «@name»(session);

        if (status) {

            «$fsm/@name»_ERR_LOG_HEX("executing action «@name»() failed", status);

            return invalid_action;

        }

        ||

    }

    template "condition" {

        const "fsm", "ancestor::fsm";

        ||

        status = «@name»(session, &result);

        if (status) {

            «$fsm/@name»_ERR_LOG_HEX("computing condition «@name» failed", status);

            return invalid_condition;

        }

        if (result) {

            «$fsm/@name»_SERVICE_LOG("condition applies", "«@name»");

        ||

        apply "transition|action|condition|send";

        | }

    }

}