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

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

const int gStmEventNo[] = {
    STM_EVT_NO_ACTIVATE,
    STM_EVT_NO_DEACTIVATE,
    STM_EVT_NO_TRANS_GEAR_N,
    STM_EVT_NO_TRANS_GEAR_NOT_N,
    STM_EVT_NO_PARKING_BRAKE_OFF,
    STM_EVT_NO_PARKING_BRAKE_ON,
    STM_EVT_NO_ACCEL_PEDAL_OFF,
    STM_EVT_NO_ACCEL_PEDAL_ON,
    STM_EVT_NO_TIMER_EXPIRED,
    STM_EVT_NO_LAMP_OFF,
    STM_EVT_NO_LAMP_ON,
    STM_EVT_NO_LIGHTSTATUS_BRAKE_OFF,
    STM_EVT_NO_LIGHTSTATUS_BRAKE_ON,
    STM_EVT_NO_RESTRICTION_MODE_OFF,
    STM_EVT_NO_RESTRICTION_MODE_ON,
};

const char* gStmCategoryName[] = {
    "none",
    "homescreen",
    "map",
    "general",
    "splitable",
    "popup",
    "system_alert",
    "restriction",
};

const int gStmCategoryNo[] = {
    STM_CTG_NO_NONE,
    STM_CTG_NO_HOMESCREEN,
    STM_CTG_NO_MAP,
    STM_CTG_NO_GENERAL,
    STM_CTG_NO_SPLITABLE,
    STM_CTG_NO_POPUP,
    STM_CTG_NO_SYSTEM_ALERT,
    STM_CTG_NO_RESTRICTION,
};

const char* gStmAreaName[] = {
    "full",
    "normal",
    "split.main",
    "split.sub",
    "onscreen",
    "restriction.normal",
    "restriction.split.main",
    "restriction.split.sub",
};

const int gStmAreaNo[] = {
    STM_ARA_NO_FULL,
    STM_ARA_NO_NORMAL,
    STM_ARA_NO_SPLIT_MAIN,
    STM_ARA_NO_SPLIT_SUB,
    STM_ARA_NO_ON_SCREEN,
    STM_ARA_NO_RESTRICTION_NORMAL,
    STM_ARA_NO_RESTRICTION_SPLIT_MAIN,
    STM_ARA_NO_RESTRICTION_SPLIT_SUB,
};

// String for state
const char* gStmTransGearStateNo2Name[] = {
    "trans_gear_neutral",
    "trans_gear_not_neutral"
};

const char* gStmParkingBrakeStateNo2Name[] = {
    "parking_brake_off",
    "parking_brake_on"
};

const char* gStmAccelPedalStateNo2Name[] = {
    "accel_pedal_off",
    "accel_pedal_on"
};

const char* gStmCarStateNo2Name[] = {
    "car_stop",
    "car_run"
};

const char* gStmLampStateNo2Name[] = {
    "lamp_off",
    "lamp_on"
};

const char* gStmLightstatusBrakeStateNo2Name[] = {
    "lightstatus_brake_off",
    "lightstatus_brake_on"
};

const char* gStmRestrictionModeStateNo2Name[] = {
    "restriction_mode_off",
    "restriction_mode_on"
};

const char* gStmLayoutNo2Name[] = {
    "none",
    "pu",
    "sa",
    "m1",
    "m2",
    "mf",
    "s1",
    "s2",
    "g",
    "hs",
    "restriction",
    "restriction.split.main",
    "restriction.split.sub",
};

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

stm_state_t g_crr_state;
stm_state_t g_prv_state;
int g_prv_restriction_state_car_stop = 0;
int g_prv_apps_state_car_stop = 0;
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[gStmLayerNoOnScreen].state   = gStmLayoutNoNone;
    g_prv_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoNone;
    g_prv_state.layer[gStmLayerNoApps].state        = gStmLayoutNoNone;
    g_prv_state.layer[gStmLayerNoHomescreen].state  = gStmLayoutNoNone;
    g_prv_state.trans_gear.state        = gStmTransGearStateNoN;
    g_prv_state.lightstatus_brake.state = gStmLightstatusBrakeStateNoOn;
    g_prv_state.accel_pedal.state       = gStmAccelPedalStateNoOff;
    g_prv_state.car.state               = gStmCarStateNoStop;
    g_prv_state.lamp.state              = gStmLampStateNoOff;
    g_prv_state.parking_brake.state     = gStmParkingBrakeStateNoOn;
    g_prv_state.restriction_mode.state  = gStmRestrictionModeStateNoOff;

    // Initialize current state
    g_crr_state = g_prv_state;
}

int stmTransitionState(int event, stm_state_t* state) {
    int event_no, category_no, area_no;
    int 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    = event & STM_MSK_EVT_NO;
    category_no = event & STM_MSK_CTG_NO;
    area_no     = event & STM_MSK_ARA_NO;

    // Backup previous state
    g_prv_state = g_crr_state;

    // Get previous state
    restriction_state = g_prv_state.layer[gStmLayerNoRestriction].state;
    apps_state        = g_prv_state.layer[gStmLayerNoApps].state;
    trans_gear_state        = g_prv_state.trans_gear.state;
    parking_brake_state     = g_prv_state.parking_brake.state;
    accel_pedal_state       = g_prv_state.accel_pedal.state;
    car_state               = g_prv_state.car.state;
    lamp_state              = g_prv_state.lamp.state;
    lightstatus_brake_state = g_prv_state.lightstatus_brake.state;
    restriction_mode_state  = g_prv_state.restriction_mode.state;

    // Clear flags
    g_crr_state.layer[gStmLayerNoOnScreen].is_changed   = STM_FALSE;
    g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_FALSE;
    g_crr_state.layer[gStmLayerNoApps].is_changed        = STM_FALSE;
    g_crr_state.layer[gStmLayerNoHomescreen].is_changed  = STM_FALSE;
    g_crr_state.trans_gear.is_changed        = STM_FALSE;
    g_crr_state.parking_brake.is_changed     = STM_FALSE;
    g_crr_state.lightstatus_brake.is_changed = STM_FALSE;
    g_crr_state.accel_pedal.is_changed       = STM_FALSE;
    g_crr_state.car.is_changed               = STM_FALSE;
    g_crr_state.lamp.is_changed              = STM_FALSE;
    g_crr_state.restriction_mode.is_changed  = STM_FALSE;


    // Set car state
    switch (event_no) {
    case STM_EVT_NO_TRANS_GEAR_N:
        if (gStmTransGearStateNoN != trans_gear_state) {
            g_crr_state.trans_gear.state = gStmTransGearStateNoN;
            g_crr_state.trans_gear.is_changed = STM_TRUE;
        }
        break;
    case STM_EVT_NO_TRANS_GEAR_NOT_N:
        if (gStmTransGearStateNoNotN != trans_gear_state) {
            g_crr_state.trans_gear.state = gStmTransGearStateNoNotN;
            g_crr_state.trans_gear.is_changed = STM_TRUE;
        }
        break;
    case STM_EVT_NO_PARKING_BRAKE_OFF:
        if (gStmParkingBrakeStateNoOff != parking_brake_state) {
            g_crr_state.parking_brake.state = gStmParkingBrakeStateNoOff;
            g_crr_state.parking_brake.is_changed = STM_TRUE;
        }
        break;
    case STM_EVT_NO_PARKING_BRAKE_ON:
        if (gStmParkingBrakeStateNoOn != parking_brake_state) {
            g_crr_state.parking_brake.state = gStmParkingBrakeStateNoOn;
            g_crr_state.parking_brake.is_changed = STM_TRUE;
        }
        break;
    case STM_EVT_NO_ACCEL_PEDAL_OFF:
        if (gStmAccelPedalStateNoOff != accel_pedal_state) {
            g_crr_state.accel_pedal.state = gStmAccelPedalStateNoOff;
            g_crr_state.accel_pedal.is_changed = STM_TRUE;
        }
        break;
    case STM_EVT_NO_ACCEL_PEDAL_ON:
        if (gStmAccelPedalStateNoOn != accel_pedal_state) {
            g_crr_state.accel_pedal.state = gStmAccelPedalStateNoOn;
            g_crr_state.accel_pedal.is_changed = STM_TRUE;
        }
        break;
    case STM_EVT_NO_LAMP_OFF:
        if (gStmLampStateNoOff != lamp_state) {
            g_crr_state.lamp.state = gStmLampStateNoOff;
            g_crr_state.lamp.is_changed = STM_TRUE;
        }
        break;
    case STM_EVT_NO_LAMP_ON:
        if (gStmLampStateNoOn != lamp_state) {
            g_crr_state.lamp.state = gStmLampStateNoOn;
            g_crr_state.lamp.is_changed = STM_TRUE;
        }
        break;
    case STM_EVT_NO_LIGHTSTATUS_BRAKE_OFF:
        if (gStmLightstatusBrakeStateNoOff != lightstatus_brake_state) {
            g_crr_state.lightstatus_brake.state = gStmLightstatusBrakeStateNoOff;
            g_crr_state.lightstatus_brake.is_changed = STM_TRUE;
        }
        break;
    case STM_EVT_NO_LIGHTSTATUS_BRAKE_ON:
        if (gStmLightstatusBrakeStateNoOn != lightstatus_brake_state) {
            g_crr_state.lightstatus_brake.state = gStmLightstatusBrakeStateNoOn;
            g_crr_state.lightstatus_brake.is_changed = STM_TRUE;
        }
        break;
    default:
        // nop
        break;
    }

#if 1 // FOR ALS
    if (g_crr_state.lightstatus_brake.is_changed
        || g_crr_state.accel_pedal.is_changed) {
        if ((gStmLightstatusBrakeStateNoOff == g_crr_state.lightstatus_brake.state)
            && (gStmAccelPedalStateNoOn == g_crr_state.accel_pedal.state)){
#else
    if (g_crr_state.parking_brake.is_changed
        || g_crr_state.trans_gear.is_changed) {
        if ((gStmParkingBrakeStateNoOff == g_crr_state.parking_brake.state)
            && (gStmTransGearStateNoNotN == g_crr_state.trans_gear.state)){
#endif
            if (gStmCarStateNoRun != car_state) {
                // Car state is changed stop -> run
                g_crr_state.car.state = gStmCarStateNoRun;
                g_crr_state.car.is_changed = STM_TRUE;
            }
        }
        else {
            if (gStmCarStateNoStop != car_state) {
                // Car state is changed run -> stop
                g_crr_state.car.state = gStmCarStateNoStop;
                g_crr_state.car.is_changed = STM_TRUE;
            }
        }
    }

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

        // Restriction mode is changed OFF -> ON
        g_crr_state.restriction_mode.state = gStmRestrictionModeStateNoOn;
        g_crr_state.restriction_mode.is_changed = STM_TRUE;

        // Update restriction layer
        g_prv_restriction_state_car_stop = restriction_state;
        g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoNone;
        g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;

        // Update apps layer
        g_prv_apps_state_car_stop = apps_state;
        if (STM_TRUE == g_map_is_activated) {
            g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM1;
            g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
        }
    }
    else if ((STM_EVT_NO_RESTRICTION_MODE_OFF == event_no)
      && (gStmRestrictionModeStateNoOff != restriction_mode_state)) {
        HMI_DEBUG("wm:pm:stm", "Restriction mode ON -> OFF");

        // Restriction mode is changed ON -> OFF
        g_crr_state.restriction_mode.state = gStmRestrictionModeStateNoOff;
        g_crr_state.restriction_mode.is_changed = STM_TRUE;

        // Update restriction layer
        g_crr_state.layer[gStmLayerNoRestriction].state = g_prv_restriction_state_car_stop;
        g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;

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

    // Set apps/homescreen layer
    switch (event_no) {
    case STM_EVT_NO_ACTIVATE:
        if (gStmRestrictionModeStateNoOff == restriction_mode_state) {
            switch (category_no) {
            case STM_CTG_NO_HOMESCREEN:
                // Apps layer
                g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoNone;
                g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;

                // Homescreen layer
                g_crr_state.layer[gStmLayerNoHomescreen].state = gStmLayoutNoHs;
                g_crr_state.layer[gStmLayerNoHomescreen].is_changed = STM_TRUE;
                break;
            case STM_CTG_NO_MAP:
                switch (area_no) {
                case STM_ARA_NO_FULL:
                    // Apps layer
                    switch (apps_state) {
                    case gStmLayoutNoMf:
                        // nop
                        break;
                    default:
                        g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoMf;
                        g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
                        break;
                    }
                    break;
                case STM_ARA_NO_NORMAL:
                    // Apps layer
                    switch (apps_state) {
                    case gStmLayoutNoM1:
                        // nop
                        break;
                    case gStmLayoutNoS1:
                        g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM2;
                        g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
                        break;
                    default:
                        g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM1;
                        g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
                    }
                    break;
                case STM_ARA_NO_SPLIT_MAIN:
                    // Apps layer
                    switch (apps_state) {
                    case gStmLayoutNoS1:
                    case gStmLayoutNoS2:
                        g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
                        g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
                        break;
                    default:
                        // nop
                        break;
                    }
                    break;
                }
                break;
            case STM_CTG_NO_GENERAL:
                switch (area_no) {
                case STM_ARA_NO_NORMAL:
                    // Apps layer
                    switch (apps_state) {
                    case gStmLayoutNoMf:
                        // nop
                        break;
                    default:
                        g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoG;
                        g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
                        break;
                    }
                    break;
                default:
                    // nop
                    break;
                }
                break;
            case STM_CTG_NO_SPLITABLE:
                switch (area_no) {
                case STM_ARA_NO_NORMAL:
                    // Apps layer
                    switch (apps_state) {
                    case gStmLayoutNoM1:
                        g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM2;
                        g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
                        break;
                    case gStmLayoutNoMf:
                    case gStmLayoutNoS1:
                        // nop
                        break;
                    default:
                        g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS1;
                        g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
                        break;
                    }
                    break;
                case STM_ARA_NO_SPLIT_MAIN:
                    // Apps layer
                    switch (apps_state) {
                    case gStmLayoutNoS1:
                        g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
                        g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
                        break;
                    case gStmLayoutNoS2:
                        g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
                        g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
                        break;
                    default:
                        // nop
                        break;
                    }
                    break;
                case STM_ARA_NO_SPLIT_SUB:
                    // Apps layer
                    switch (apps_state) {
                    case gStmLayoutNoM1:
                        g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM2;
                        g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
                        break;
                    case gStmLayoutNoM2:
                        g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoM2;
                        g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
                        break;
                    case gStmLayoutNoS1:
                        g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
                        g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
                        break;
                    case gStmLayoutNoS2:
                        g_crr_state.layer[gStmLayerNoApps].state = gStmLayoutNoS2;
                        g_crr_state.layer[gStmLayerNoApps].is_changed = STM_TRUE;
                        break;
                    default:
                        // nop
                        break;
                    }
                    break;
                default:
                    // nop
                    break;
                }
                break;
            default:
                // nop
                break;
            }
            break;
        }
    case STM_EVT_NO_DEACTIVATE:
        switch (category_no) {
        default:
            // nop
            break;
        }
        break;
    default:
        // nop
        break;
    }


    // Set restriction layer
    if (STM_CTG_NO_RESTRICTION == category_no) {
        if (STM_EVT_NO_ACTIVATE == event_no) {
            if (gStmLightstatusBrakeStateNoOff == g_crr_state.lightstatus_brake.state) {
                switch (area_no) {
                case STM_ARA_NO_RESTRICTION_NORMAL:
                    switch (restriction_state) {
                    case gStmLayoutNoNone:
                        if (g_crr_state.layer[gStmLayerNoApps].state == gStmLayoutNoS1) {
                            g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestriction;
                            g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
                        }
                        break;
                    default:
                        // nop
                        break;
                    }
                    break;
                case STM_ARA_NO_RESTRICTION_SPLIT_MAIN:
                    switch (restriction_state) {
                    case gStmLayoutNoNone:
                        g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestrictionSplitMain;
                        g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
                        break;
                    default:
                        // nop
                        break;
                    }
                    break;
                case STM_ARA_NO_RESTRICTION_SPLIT_SUB:
                    switch (restriction_state) {
                    case gStmLayoutNoNone:
                        if (g_crr_state.layer[gStmLayerNoApps].state == gStmLayoutNoM2) {
                            g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestrictionSplitSub;
                            g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
                        }
                        break;
                    default:
                        // nop
                        break;
                    }
                    break;
                default:
                    // nop
                    break;
                }
            }
        }
        else if (STM_EVT_NO_DEACTIVATE == event_no) {
            switch (restriction_state) {
            case gStmLayoutNoRestriction:
            case gStmLayoutNoRestrictionSplitMain:
            case gStmLayoutNoRestrictionSplitSub:
                g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoNone;
                g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
                break;
            default:
                // nop
                break;
            }
        }
    }
    else if (g_crr_state.layer[gStmLayerNoApps].is_changed) {
        if (gStmLightstatusBrakeStateNoOff == g_crr_state.lightstatus_brake.state) {
            if (gStmLayoutNoM2 == g_crr_state.layer[gStmLayerNoApps].state) {
                g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestrictionSplitSub;
                g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
            }
            else if (gStmLayoutNoS1 == g_crr_state.layer[gStmLayerNoApps].state) {
                g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoRestriction;
                g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
            }
            else {
                if (gStmLayoutNoNone != g_crr_state.layer[gStmLayerNoRestriction].state) {
                    g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoNone;
                    g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
                }
            }
        }
        else {
            if (gStmLayoutNoNone != g_crr_state.layer[gStmLayerNoRestriction].state) {
                g_crr_state.layer[gStmLayerNoRestriction].state = gStmLayoutNoNone;
                g_crr_state.layer[gStmLayerNoRestriction].is_changed = STM_TRUE;
            }
        }
    }

    // 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[gStmLayerNoApps].is_changed)
        && ((gStmLayoutNoM1 == g_crr_state.layer[gStmLayerNoApps].state)
            || (gStmLayoutNoM2 == g_crr_state.layer[gStmLayerNoApps].state)
            || (gStmLayoutNoMf == g_crr_state.layer[gStmLayerNoApps].state))) {
        g_map_is_activated = STM_TRUE;
    }

    return 0;
}