#include <string.h>
#include "dummy_stm.h"
#include "hmi-debug.h"

const char* kStmEventName[] = {
    "none",
    "activate",
    "deactivate",
    "trans_gear_neutral",
    "trans_gear_not_neutral",
    "parking_brake_off",
    "parking_brake_on",
    "accel_pedal_off",
    "accel_pedal_on",
    "lamp_off",
    "lamp_on",
    "lightstatus_brake_off",
    "lightstatus_brake_on",
    "restriction_mode_off",
    "restriction_mode_on",
};

const char* kStmCategoryName[] = {
    "none",
    "homescreen",
    "map",
    "general",
    "splitable",
    "pop_up",
    "system_alert",
    "restriction",
    "system",
};

const char* kStmAreaName[] = {
    "none",
    "fullscreen",
    "normal",
    "split.main",
    "split.sub",
    "pop_up",
    "restriction.normal",
    "restriction.split.main",
    "restriction.split.sub",
};

// String for state
const char* kStmTransGearStateName[] = {
    "neutral",
    "not_neutral"
};

const char* kStmParkingBrakeStateName[] = {
    "off",
    "on"
};

const char* kStmAccelPedalStateName[] = {
    "off",
    "on"
};

const char* kStmRunningSttNo2Name[] = {
    "stop",
    "run"
};

const char* kStmLampStateName[] = {
    "off",
    "on"
};

const char* kStmLightstatusBrakeStateName[] = {
    "off",
    "on"
};

const char* kStmRestrictionModeStateName[] = {
    "off",
    "on"
};

const char* kStmLayoutName[] = {
    "none",
    "pop_up",
    "system_alert",
    "map.normal",
    "map.split",
    "map.fullscreen",
    "splitable.normal",
    "splitable.split",
    "general.normal",
    "homescreen",
    "restriction.normal",
    "restriction.split.main",
    "restriction.split.sub",
    "system.normal",
};

const char* kStmLayerName[] = {
    "homescreen",
    "apps",
    "restriction",
    "on_screen",
};

const char* kStmCarElementName[] = {
    "trans_gear",
    "parking_brake",
    "accel_pedal",
    "running",
    "lamp",
    "lightstatus_brake",
    "restriction_mode",
};

const char** kStmCarStateNameList[] = {
    kStmTransGearStateName,
    kStmParkingBrakeStateName,
    kStmAccelPedalStateName,
    kStmRunningSttNo2Name,
    kStmLampStateName,
    kStmLightstatusBrakeStateName,
    kStmRestrictionModeStateName,
};

static StmState g_crr_state;
static StmState g_prv_state;
static int g_prv_on_screen_state_car_stop = 0;
static int g_prv_restriction_state_car_stop = 0;
static int g_prv_apps_state_car_stop = 0;
static int g_map_is_activated = STM_FALSE;

void stmInitialize() {
    // Initialize previous state
    memset(&g_prv_state, 0, sizeof(g_prv_state));

    g_prv_state.layer[StmLayerNoOnScreen].state    = StmLayoutNoNone;
    g_prv_state.layer[StmLayerNoRestriction].state = StmLayoutNoNone;
    g_prv_state.layer[StmLayerNoApps].state        = StmLayoutNoNone;
    g_prv_state.layer[StmLayerNoHomescreen].state  = StmLayoutNoNone;
    g_prv_state.car_element[StmCarElementNoTransGear].state        = StmTransGearSttNoN;
    g_prv_state.car_element[StmCarElementNoLightstatusBrake].state = StmLightstatusBrakeSttNoOn;
    g_prv_state.car_element[StmCarElementNoAccelPedal].state       = StmAccelPedalSttNoOff;
    g_prv_state.car_element[StmCarElementNoRunning].state          = StmRunningNoStop;
    g_prv_state.car_element[StmCarElementNoLamp].state             = StmLampSttNoOff;
    g_prv_state.car_element[StmCarElementNoParkingBrake].state     = StmParkingBrakeSttNoOn;
    g_prv_state.car_element[StmCarElementNoRestrictionMode].state  = StmRestrictionModeSttNoOff;

    // Initialize current state
    g_crr_state = g_prv_state;
}

int stmTransitionState(int event, StmState* state) {
    int event_no, category_no, area_no;
    int on_screen_state, restriction_state, apps_state;
    int trans_gear_state, parking_brake_state, lightstatus_brake_state, accel_pedal_state, car_state, lamp_state, restriction_mode_state;

    event_no    = STM_GET_EVENT_FROM_ID(event);
    category_no = STM_GET_CATEGORY_FROM_ID(event);
    area_no     = STM_GET_AREA_FROM_ID(event);

    // Backup previous state
    g_prv_state = g_crr_state;

    // Get previous state
    on_screen_state   = g_prv_state.layer[StmLayerNoOnScreen].state;
    restriction_state = g_prv_state.layer[StmLayerNoRestriction].state;
    apps_state        = g_prv_state.layer[StmLayerNoApps].state;
    trans_gear_state        = g_prv_state.car_element[StmCarElementNoTransGear].state;
    parking_brake_state     = g_prv_state.car_element[StmCarElementNoParkingBrake].state;
    accel_pedal_state       = g_prv_state.car_element[StmCarElementNoAccelPedal].state;
    car_state               = g_prv_state.car_element[StmCarElementNoRunning].state;
    lamp_state              = g_prv_state.car_element[StmCarElementNoLamp].state;
    lightstatus_brake_state = g_prv_state.car_element[StmCarElementNoLightstatusBrake].state;
    restriction_mode_state  = g_prv_state.car_element[StmCarElementNoRestrictionMode].state;

    // Clear flags
    g_crr_state.layer[StmLayerNoOnScreen].changed    = STM_FALSE;
    g_crr_state.layer[StmLayerNoRestriction].changed = STM_FALSE;
    g_crr_state.layer[StmLayerNoApps].changed        = STM_FALSE;
    g_crr_state.layer[StmLayerNoHomescreen].changed  = STM_FALSE;
    g_crr_state.car_element[StmCarElementNoTransGear].changed        = STM_FALSE;
    g_crr_state.car_element[StmCarElementNoParkingBrake].changed     = STM_FALSE;
    g_crr_state.car_element[StmCarElementNoLightstatusBrake].changed = STM_FALSE;
    g_crr_state.car_element[StmCarElementNoAccelPedal].changed       = STM_FALSE;
    g_crr_state.car_element[StmCarElementNoRunning].changed          = STM_FALSE;
    g_crr_state.car_element[StmCarElementNoLamp].changed             = STM_FALSE;
    g_crr_state.car_element[StmCarElementNoRestrictionMode].changed  = STM_FALSE;


    // Set car state
    switch (event_no) {
    case StmEvtNoTransGearN:
        if (StmTransGearSttNoN != trans_gear_state) {
            g_crr_state.car_element[StmCarElementNoTransGear].state = StmTransGearSttNoN;
            g_crr_state.car_element[StmCarElementNoTransGear].changed = STM_TRUE;
        }
        break;
    case StmEvtNoTransGearNotN:
        if (StmTransGearSttNoNotN != trans_gear_state) {
            g_crr_state.car_element[StmCarElementNoTransGear].state = StmTransGearSttNoNotN;
            g_crr_state.car_element[StmCarElementNoTransGear].changed = STM_TRUE;
        }
        break;
    case StmEvtNoParkingBrakeOff:
        if (StmParkingBrakeSttNoOff != parking_brake_state) {
            g_crr_state.car_element[StmCarElementNoParkingBrake].state = StmParkingBrakeSttNoOff;
            g_crr_state.car_element[StmCarElementNoParkingBrake].changed = STM_TRUE;
        }
        break;
    case StmEvtNoParkingBrakeOn:
        if (StmParkingBrakeSttNoOn != parking_brake_state) {
            g_crr_state.car_element[StmCarElementNoParkingBrake].state = StmParkingBrakeSttNoOn;
            g_crr_state.car_element[StmCarElementNoParkingBrake].changed = STM_TRUE;
        }
        break;
    case StmEvtNoAccelPedalOff:
        if (StmAccelPedalSttNoOff != accel_pedal_state) {
            g_crr_state.car_element[StmCarElementNoAccelPedal].state = StmAccelPedalSttNoOff;
            g_crr_state.car_element[StmCarElementNoAccelPedal].changed = STM_TRUE;
        }
        break;
    case StmEvtNoAccelPedalOn:
        if (StmAccelPedalSttNoOn != accel_pedal_state) {
            g_crr_state.car_element[StmCarElementNoAccelPedal].state = StmAccelPedalSttNoOn;
            g_crr_state.car_element[StmCarElementNoAccelPedal].changed = STM_TRUE;
        }
        break;
    case StmEvtNoLampOff:
        if (StmLampSttNoOff != lamp_state) {
            g_crr_state.car_element[StmCarElementNoLamp].state = StmLampSttNoOff;
            g_crr_state.car_element[StmCarElementNoLamp].changed = STM_TRUE;
        }
        break;
    case StmEvtNoLampOn:
        if (StmLampSttNoOn != lamp_state) {
            g_crr_state.car_element[StmCarElementNoLamp].state = StmLampSttNoOn;
            g_crr_state.car_element[StmCarElementNoLamp].changed = STM_TRUE;
        }
        break;
    case StmEvtNoLightstatusBrakeOff:
        if (StmLightstatusBrakeSttNoOff != lightstatus_brake_state) {
            g_crr_state.car_element[StmCarElementNoLightstatusBrake].state = StmLightstatusBrakeSttNoOff;
            g_crr_state.car_element[StmCarElementNoLightstatusBrake].changed = STM_TRUE;
        }
        break;
    case StmEvtNoLightstatusBrakeOn:
        if (StmLightstatusBrakeSttNoOn != lightstatus_brake_state) {
            g_crr_state.car_element[StmCarElementNoLightstatusBrake].state = StmLightstatusBrakeSttNoOn;
            g_crr_state.car_element[StmCarElementNoLightstatusBrake].changed = STM_TRUE;
        }
        break;
    default:
        // nop
        break;
    }

#if 1 // FOR ALS
    if (g_crr_state.car_element[StmCarElementNoLightstatusBrake].changed
        || g_crr_state.car_element[StmCarElementNoAccelPedal].changed) {
        if ((StmLightstatusBrakeSttNoOff == g_crr_state.car_element[StmCarElementNoLightstatusBrake].state)
            && (StmAccelPedalSttNoOn == g_crr_state.car_element[StmCarElementNoAccelPedal].state)){
#else
    if (g_crr_state.car_element[StmCarElementNoParkingBrake].changed
        || g_crr_state.car_element[StmCarElementNoTransGear].changed) {
        if ((StmParkingBrakeSttNoOff == g_crr_state.car_element[StmCarElementNoParkingBrake].state)
            && (StmTransGearSttNoNotN == g_crr_state.car_element[StmCarElementNoTransGear].state)){
#endif
            if (StmRunningNoRun != car_state) {
                // Car state is changed stop -> run
                g_crr_state.car_element[StmCarElementNoRunning].state = StmRunningNoRun;
                g_crr_state.car_element[StmCarElementNoRunning].changed = STM_TRUE;
            }
        }
        else {
            if (StmRunningNoStop != car_state) {
                // Car state is changed run -> stop
                g_crr_state.car_element[StmCarElementNoRunning].state = StmRunningNoStop;
                g_crr_state.car_element[StmCarElementNoRunning].changed = STM_TRUE;
            }
        }
    }

    // Set restriction mode
    if ((StmEvtNoRestrictionModeOn == event_no)
      && (StmRestrictionModeSttNoOn != restriction_mode_state)) {
        HMI_DEBUG("wm:pm:stm", "Restriction mode OFF -> ON");

        // Restriction mode is changed OFF -> ON
        g_crr_state.car_element[StmCarElementNoRestrictionMode].state = StmRestrictionModeSttNoOn;
        g_crr_state.car_element[StmCarElementNoRestrictionMode].changed = STM_TRUE;

        // Update on screen layer
        g_prv_on_screen_state_car_stop = on_screen_state;
        g_crr_state.layer[StmLayerNoOnScreen].state = StmLayoutNoNone;
        g_crr_state.layer[StmLayerNoOnScreen].changed = STM_TRUE;

        // Update restriction layer
        g_prv_restriction_state_car_stop = restriction_state;
        g_crr_state.layer[StmLayerNoRestriction].state = StmLayoutNoNone;
        g_crr_state.layer[StmLayerNoRestriction].changed = STM_TRUE;

        // Update apps layer
        g_prv_apps_state_car_stop = apps_state;
        if ((STM_TRUE == g_map_is_activated)
	    && (StmLayoutNoSysNml != apps_state)) {
            g_crr_state.layer[StmLayerNoApps].state = StmLayoutNoMapNml;
            g_crr_state.layer[StmLayerNoApps].changed = STM_TRUE;
        }
    }
    else if ((StmEvtNoRestrictionModeOff == event_no)
      && (StmRestrictionModeSttNoOff != restriction_mode_state)) {
        HMI_DEBUG("wm:pm:stm", "Restriction mode ON -> OFF");

        // Restriction mode is changed ON -> OFF
        g_crr_state.car_element[StmCarElementNoRestrictionMode].state = StmRestrictionModeSttNoOff;
        g_crr_state.car_element[StmCarElementNoRestrictionMode].changed = STM_TRUE;

        // Update on screen layer
        g_crr_state.layer[StmLayerNoOnScreen].state = g_prv_on_screen_state_car_stop;
        g_crr_state.layer[StmLayerNoOnScreen].changed = STM_TRUE;

        // Update restriction layer
        g_crr_state.layer[StmLayerNoRestriction].state = g_prv_restriction_state_car_stop;
        g_crr_state.layer[StmLayerNoRestriction].changed = STM_TRUE;

        // Update apps layer
        if (STM_TRUE == g_map_is_activated) {
            g_crr_state.layer[StmLayerNoApps].state = g_prv_apps_state_car_stop;
            g_crr_state.layer[StmLayerNoApps].changed = STM_TRUE;
        }
    }

    // Set apps/homescreen layer
    switch (event_no) {
    case StmEvtNoActivate:
        if (StmRestrictionModeSttNoOff == restriction_mode_state) {
            switch (category_no) {
            case StmCtgNoHomescreen:
                // Homescreen layer
                g_crr_state.layer[StmLayerNoHomescreen].state = StmLayoutNoHms;
                g_crr_state.layer[StmLayerNoHomescreen].changed = STM_TRUE;

                // Apps layer
                if (StmLayoutNoNone != apps_state) {
                    g_crr_state.layer[StmLayerNoApps].state = StmLayoutNoNone;
                    g_crr_state.layer[StmLayerNoApps].changed = STM_TRUE;
                }
                break;
            case StmCtgNoMap:
                switch (area_no) {
                case StmAreaNoFullscreen:
                    // Apps layer
                    switch (apps_state) {
                    case StmLayoutNoMapFll:
                        // nop
                        break;
                    default:
                        g_crr_state.layer[StmLayerNoApps].state = StmLayoutNoMapFll;
                        g_crr_state.layer[StmLayerNoApps].changed = STM_TRUE;
                        break;
                    }
                    break;
                case StmAreaNoNormal:
                    // Apps layer
                    switch (apps_state) {
                    case StmLayoutNoMapNml:
                        // nop
                        break;
                    case StmLayoutNoSplNml:
                        g_crr_state.layer[StmLayerNoApps].state = StmLayoutNoMapSpl;
                        g_crr_state.layer[StmLayerNoApps].changed = STM_TRUE;
                        break;
                    default:
                        g_crr_state.layer[StmLayerNoApps].state = StmLayoutNoMapNml;
                        g_crr_state.layer[StmLayerNoApps].changed = STM_TRUE;
                    }
                    break;
                case StmAreaNoSplitMain:
                    // Apps layer
                    switch (apps_state) {
                    case StmLayoutNoSplNml:
                    case StmLayoutNoSplSpl:
                        g_crr_state.layer[StmLayerNoApps].state = StmLayoutNoSplSpl;
                        g_crr_state.layer[StmLayerNoApps].changed = STM_TRUE;
                        break;
                    default:
                        // nop
                        break;
                    }
                    break;
                }
                break;
            case StmCtgNoGeneral:
                switch (area_no) {
                case StmAreaNoNormal:
                    // Apps layer
                    switch (apps_state) {
                    case StmLayoutNoMapFll:
                        // nop
                        break;
                    default:
                        g_crr_state.layer[StmLayerNoApps].state = StmLayoutNoGenNml;
                        g_crr_state.layer[StmLayerNoApps].changed = STM_TRUE;
                        break;
                    }
                    break;
                default:
                    // nop
                    break;
                }
                break;
            case StmCtgNoSystem:
                switch (area_no) {
                case StmAreaNoNormal:
                    // Apps layer
                    switch (apps_state) {
                    case StmLayoutNoMapFll:
                        // nop
                        break;
                    default:
                        g_crr_state.layer[StmLayerNoApps].state = StmLayoutNoSysNml;
                        g_crr_state.layer[StmLayerNoApps].changed = STM_TRUE;
                        break;
                    }
                    break;
                default:
                    // nop
                    break;
                }
                break;
            case StmCtgNoSplitable:
                switch (area_no) {
                case StmAreaNoNormal:
                    // Apps layer
                    switch (apps_state) {
                    case StmLayoutNoMapNml:
                        g_crr_state.layer[StmLayerNoApps].state = StmLayoutNoMapSpl;
                        g_crr_state.layer[StmLayerNoApps].changed = STM_TRUE;
                        break;
                    case StmLayoutNoMapFll:
                    case StmLayoutNoSplNml:
                        // nop
                        break;
                    default:
                        g_crr_state.layer[StmLayerNoApps].state = StmLayoutNoSplNml;
                        g_crr_state.layer[StmLayerNoApps].changed = STM_TRUE;
                        break;
                    }
                    break;
                case StmAreaNoSplitMain:
                    // Apps layer
                    switch (apps_state) {
                    case StmLayoutNoSplNml:
                        g_crr_state.layer[StmLayerNoApps].state = StmLayoutNoSplSpl;
                        g_crr_state.layer[StmLayerNoApps].changed = STM_TRUE;
                        break;
                    case StmLayoutNoSplSpl:
                        g_crr_state.layer[StmLayerNoApps].state = StmLayoutNoSplSpl;
                        g_crr_state.layer[StmLayerNoApps].changed = STM_TRUE;
                        break;
                    default:
                        // nop
                        break;
                    }
                    break;
                case StmAreaNoSplitSub:
                    // Apps layer
                    switch (apps_state) {
                    case StmLayoutNoMapNml:
                        g_crr_state.layer[StmLayerNoApps].state = StmLayoutNoMapSpl;
                        g_crr_state.layer[StmLayerNoApps].changed = STM_TRUE;
                        break;
                    case StmLayoutNoMapSpl:
                        g_crr_state.layer[StmLayerNoApps].state = StmLayoutNoMapSpl;
                        g_crr_state.layer[StmLayerNoApps].changed = STM_TRUE;
                        break;
                    case StmLayoutNoSplNml:
                        g_crr_state.layer[StmLayerNoApps].state = StmLayoutNoSplSpl;
                        g_crr_state.layer[StmLayerNoApps].changed = STM_TRUE;
                        break;
                    case StmLayoutNoSplSpl:
                        g_crr_state.layer[StmLayerNoApps].state = StmLayoutNoSplSpl;
                        g_crr_state.layer[StmLayerNoApps].changed = STM_TRUE;
                        break;
                    default:
                        // nop
                        break;
                    }
                    break;
                default:
                    // nop
                    break;
                }
                break;
            default:
                // nop
                break;
            }
            break;
        }
	else {  // (StmRestrictionModeSttNoOn == restriction_mode_state)
            switch (category_no) {
            case StmCtgNoMap:
                switch (area_no) {
                case StmAreaNoFullscreen:
                case StmAreaNoNormal:
                case StmAreaNoSplitMain:
                    // Apps layer
                    switch (apps_state) {
                    case StmLayoutNoMapNml:
                        // nop
                        break;
                    default:
                        g_crr_state.layer[StmLayerNoApps].state = StmLayoutNoMapNml;
                        g_crr_state.layer[StmLayerNoApps].changed = STM_TRUE;
                    }
                    break;
                }
                break;
            case StmCtgNoSystem:
                switch (area_no) {
                case StmAreaNoNormal:
                    // Apps layer
                    switch (apps_state) {
                    case StmLayoutNoMapFll:
                        // nop
                        break;
                    default:
                        g_crr_state.layer[StmLayerNoApps].state = StmLayoutNoSysNml;
                        g_crr_state.layer[StmLayerNoApps].changed = STM_TRUE;
                        break;
                    }
                    break;
                default:
                    // nop
                    break;
                }
                break;
	    }
	}
    case StmEvtNoDeactivate:
        switch (category_no) {
        default:
            // nop
            break;
        }
        break;
    default:
        // nop
        break;
    }


    // Set restriction layer
    if (StmCtgNoRestriction == category_no) {
        if (StmEvtNoActivate == event_no) {
            if (StmLightstatusBrakeSttNoOff == g_crr_state.car_element[StmCarElementNoLightstatusBrake].state) {
                switch (area_no) {
                case StmAreaNoRestrictionNormal:
                    switch (restriction_state) {
                    case StmLayoutNoNone:
                        if (g_crr_state.layer[StmLayerNoApps].state == StmLayoutNoSplNml) {
                            g_crr_state.layer[StmLayerNoRestriction].state = StmLayoutNoRstNml;
                            g_crr_state.layer[StmLayerNoRestriction].changed = STM_TRUE;
                        }
                        else if (g_crr_state.layer[StmLayerNoApps].state == StmLayoutNoMapSpl) {
                            g_crr_state.layer[StmLayerNoRestriction].state = StmLayoutNoRstSplSub;
                            g_crr_state.layer[StmLayerNoRestriction].changed = STM_TRUE;
                        }
                        break;
                    default:
                        // nop
                        break;
                    }
                    break;
                case StmAreaNoRestrictionSplitMain:
                    switch (restriction_state) {
                    case StmLayoutNoNone:
                        g_crr_state.layer[StmLayerNoRestriction].state = StmLayoutNoRstSplMain;
                        g_crr_state.layer[StmLayerNoRestriction].changed = STM_TRUE;
                        break;
                    default:
                        // nop
                        break;
                    }
                    break;
                case StmAreaNoRestrictionSplitSub:
                    switch (restriction_state) {
                    case StmLayoutNoNone:
                        if (g_crr_state.layer[StmLayerNoApps].state == StmLayoutNoMapSpl) {
                            g_crr_state.layer[StmLayerNoRestriction].state = StmLayoutNoRstSplSub;
                            g_crr_state.layer[StmLayerNoRestriction].changed = STM_TRUE;
                        }
                        break;
                    default:
                        // nop
                        break;
                    }
                    break;
                default:
                    // nop
                    break;
                }
            }
        }
        else if (StmEvtNoDeactivate == event_no) {
            switch (restriction_state) {
            case StmLayoutNoRstNml:
            case StmLayoutNoRstSplMain:
            case StmLayoutNoRstSplSub:
                g_crr_state.layer[StmLayerNoRestriction].state = StmLayoutNoNone;
                g_crr_state.layer[StmLayerNoRestriction].changed = STM_TRUE;
                break;
            default:
                // nop
                break;
            }
        }
    }
    else if (g_crr_state.layer[StmLayerNoApps].changed) {
        if (StmLightstatusBrakeSttNoOff == g_crr_state.car_element[StmCarElementNoLightstatusBrake].state) {
            if (StmLayoutNoMapSpl == g_crr_state.layer[StmLayerNoApps].state) {
                g_crr_state.layer[StmLayerNoRestriction].state = StmLayoutNoRstSplSub;
                g_crr_state.layer[StmLayerNoRestriction].changed = STM_TRUE;
            }
            else if (StmLayoutNoSplNml == g_crr_state.layer[StmLayerNoApps].state) {
                g_crr_state.layer[StmLayerNoRestriction].state = StmLayoutNoRstNml;
                g_crr_state.layer[StmLayerNoRestriction].changed = STM_TRUE;
            }
            else {
                if (StmLayoutNoNone != g_crr_state.layer[StmLayerNoRestriction].state) {
                    g_crr_state.layer[StmLayerNoRestriction].state = StmLayoutNoNone;
                    g_crr_state.layer[StmLayerNoRestriction].changed = STM_TRUE;
                }
            }
        }
        else {
            if (StmLayoutNoNone != g_crr_state.layer[StmLayerNoRestriction].state) {
                g_crr_state.layer[StmLayerNoRestriction].state = StmLayoutNoNone;
                g_crr_state.layer[StmLayerNoRestriction].changed = STM_TRUE;
            }
        }
    }

    // Set on screen layer
    if (StmCtgNoPopUp == category_no) {
        if (StmEvtNoActivate == event_no) {
            switch (on_screen_state) {
            case StmLayoutNoNone:
                g_crr_state.layer[StmLayerNoOnScreen].state = StmLayoutNoPopUp;
                g_crr_state.layer[StmLayerNoOnScreen].changed = STM_TRUE;
                break;
            default:
                // nop
                break;
            }
        }
        else if (StmEvtNoDeactivate == event_no) {
            switch (on_screen_state) {
            case StmLayoutNoPopUp:
                g_crr_state.layer[StmLayerNoOnScreen].state = StmLayoutNoNone;
                g_crr_state.layer[StmLayerNoOnScreen].changed = STM_TRUE;
                break;
            default:
                // nop
                break;
            }
        }
    }

    // Copy current state for return
    memcpy(state, &g_crr_state, sizeof(g_crr_state));

    if ((STM_FALSE == g_map_is_activated)
        && (STM_TRUE == g_crr_state.layer[StmLayerNoApps].changed)
        && ((StmLayoutNoMapNml == g_crr_state.layer[StmLayerNoApps].state)
            || (StmLayoutNoMapSpl == g_crr_state.layer[StmLayerNoApps].state)
            || (StmLayoutNoMapFll == g_crr_state.layer[StmLayerNoApps].state))) {
        g_map_is_activated = STM_TRUE;
    }

    return 0;
}

void stmUndoState() {
    g_crr_state = g_prv_state;
}