#include <stdio.h>
#include <string.h>

/*
# if !defined OLC9SU523_H
#    include "olc93su523.h"
# endif
*/

#include "f93olc.h"

# if !defined OLC3COMMON_H
#    include "olc3common.h"
# endif

# if !defined STATEMODEL_H
#    include "statemodel.h"
# endif

# if !defined STATE_H
#   include "state.h"
# endif


/*
** StateModelFirst
** StateModelNext
** StateModelDelete
*/
STANDARDROUTINES(StateModel, SM)

FUNCTION2(
hcg_key StateModelCreate,
    const char *,StateModelName,
    const char *,StateModelAbbreviatedName
)
{
   hcg_key SMid;

#ifdef GENV7
   char databuffer[BUFSIZE];
   KEYBUFFER(SMkey);

   pr_gen_pkey("JuicePlant", SM, SMkey);
   sprintf(databuffer, 
	   " %s %.*s %.*s",
	   SMkey,    
	   StateModelAbbreviatedNameMaxLen,
	   StateModelAbbreviatedName,
	   StateModelNameMaxLen,
	   StateModelName);
   pr_add("JuicePlant", databuffer);
   encode(SMkey, &SMid);

#else
   struct SM *SM_elt;
   
   SM_elt = pr_create(SM);
   pr_set_str(SM_elt, Abbrev, StateModelAbbreviatedName);
   pr_set_str(SM_elt, Name, StateModelName);
   pr_add("JuicePlant", SM, SM_elt);
   SMid = pr_get_key(SM_elt, SMid);

#endif

   return SMid;
   
}

FUNCTION8(
hcg_key StateModelCreateCompletely, 
     const char          *,StateModelName,
     const char          *,StateModelAbrreviatedName,
     unsigned int         ,NumberOfEventTypes,
     EventTypeList       *,ListOfEventTypes,     
     unsigned int         ,NumberOfStates,
     StateList           *,ListOfStates,                                       
     unsigned int         ,NumberOfTransitions,
     StateTransitionList *,ListOfStateTransitions
)
{
    hcg_key SMid;
    hcg_key ETid;
    hcg_key STid;
    hcg_key TRid;
    hcg_key ENid;
    hcg_key STidFrom;
    hcg_key STidTo;
    unsigned int i;
    const char *StateName;
    EventTypeList       *NewEventType;
    StateList           *NewState;
    StateTransitionList *NewTransition;
    /*
    ** Create the StateModel
    */
    SMid = StateModelCreate(StateModelName, StateModelAbrreviatedName);

    /*
    ** Create the events in the state model
    */
    for(NewEventType = ListOfEventTypes;
        NewEventType != ListOfEventTypes + NumberOfEventTypes;
        NewEventType += 1) {
        ETid = EventTypeCreate(NewEventType->Label,
                               SMid,
                               NewEventType->Description);
    }

    /*
    ** Create the states in the state model
    */
    for(NewState = ListOfStates;
        NewState != ListOfStates + NumberOfStates;
        NewState += 1) {
        STid = StateCreate(NewState->Name,
                           SMid,
                           NewState->ActionRoutineName,
                           NewState->ActionRoutine);
    }

    /*
    ** Create the transitions.  
    */
    for(NewTransition = ListOfStateTransitions;
        NewTransition != ListOfStateTransitions + NumberOfTransitions;
        NewTransition += 1) {
        
        /*
        ** Find the states involved,  if none, complain
        */
        STidFrom = 0;
        STidTo = 0;

        for(STid = StateFirst(); STid != 0; STid = StateNext(STid)) {
            StateName = StateGetName(STid);
            if (strcmp(StateName, NewTransition->FromState) == 0) {
                STidFrom = STid;
                if (STidTo != 0) {
                    break;
                }
            }
            if (strcmp(StateName, NewTransition->ToState) == 0) {
                STidTo = STid;
                if (STidFrom != 0) {
                    break;
                }
            }
        }
        if ((STidFrom == 0) || (STidTo == 0)) {
            printf("One or both states do not exist for the transition\n");
            printf("from state %s to state %s.\n",  
                   NewTransition->FromState,
                   NewTransition->ToState);                   
            return 0;
        }             

        /*
        ** Look for an existing transition from the FromState to the ToState
        ** If no transition found, create one
        */
        for(TRid = TransitionFirst(); TRid != 0; TRid = TransitionNext(TRid)) {
            if (   (TransitionGetSTid1(TRid) == STidFrom)
                && (TransitionGetSTid2(TRid) == STidTo)) {
                break;
            }
        }
        if (TRid == 0) {
            TRid = TransitionCreate(STidFrom, STidTo);
        }                

        /*
        ** Find the EventType that enables this transition.  Complain if
        ** no such event type.
        */
        for (ETid = EventTypeFirst(); ETid != 0; ETid = EventTypeNext(ETid)) {
            if (0 == strcmp(EventTypeGetLabel(ETid), 
                            NewTransition->EnablingEvent)) {
                ENid = EnableCreate(ETid, TRid);
                break;
            }
        }
        if (ETid == 0) {
            printf("There is no event labeled %s to enable the transition\n",
                   NewTransition->EnablingEvent);
            printf("from state %s to state %s.\n",  
                   NewTransition->FromState,
                   NewTransition->ToState);                   
            return 0;
        }
    }

    return SMid;
}