#ifndef __KEY_PRIVATE_FSM_H_
#define __KEY_PRIVATE_FSM_H_

#include "FSM_protected.h"
#include "keyFSM.h"
#include <stdio.h>
#include <assert.h>

/* 
    继承基类
 */
typedef struct _KeyFSM
{   
    // 继承父类
    FSM base;
}KeyFSM;

/* 
    状态和对应的 action, exit, during 函数
 */

typedef enum _State
{
    Idle_State,
    Waiting,
    DownDebouncing,
    Downing,
    Holding,
    UpDebouncing,
    MultiDownWaiting,
    MultiDowning,
    HoldUpDebouncing,
    MultiDownDebouncing,

    Count_State,
} State;
#define     DEFAULT_STATE       Waiting


static void actionFcn(enter, Waiting)(KeyFSMData* data){
 
    data->out = Idle;
    data->countDelay = 0;
    data->countMultiDown = 0;
}


static void actionFcn(during, DownDebouncing)(KeyFSMData* data)
{
 
    data->countDelay++;
    FSM_LOG(" during开启消抖 ");
}

static void actionFcn(during, Downing)(KeyFSMData* data)
{
 
    data->countDelay++;
    data->out = Idle;
}



static void actionFcn(during, UpDebouncing)(KeyFSMData* data){
 
    data->countDelay++;
    FSM_LOG(" during松开消抖 ");
}


static void actionFcn(during, Holding)(KeyFSMData* data){
    data->out = Idle;
    data->countDelay++;
    if(data->countDelay == 2){
        data->out = Hold;
        data->countDelay = 0;
    }
}

static void actionFcn(exit, Holding)(KeyFSMData* data){
    data->out = Idle;
}



static void actionFcn(during, MultiDownWaiting)(KeyFSMData* data){
    data->countDelay++;
    FSM_LOG(" during多击等待 ");
}



static void actionFcn(during, HoldUpDebouncing)(KeyFSMData* data)
{
    data->countDelay++;
}


static void actionFcn(during, MultiDownDebouncing)(KeyFSMData* data)
{
    data->countDelay++;
}




/* 
    事件和对应的转移函数
 */

typedef enum _Event{
    Idle_Event,
    PhsicalDown,
    PhsicalUp,
    DelayCount3,
    HoldCount4,

    Count_Event,
}Event;

static State transitionHandler(PhsicalDown)(KeyFSMData* data, State curState, int *isDelayExecuted)
{
    FSM_LOG(" 物理按键按下 ");
    data->countDelay = 0;
 
    switch (curState)
    {
    case Waiting:
        return DownDebouncing;
        
    case UpDebouncing:
        if(data->countMultiDown)
            return MultiDowning;
        else
            return Downing;

    case HoldUpDebouncing:
        return Holding;

    case MultiDownWaiting:
        return MultiDownDebouncing;


    default:
        FSM_LOG("检查状态转移表设计，不应该到这里");
        assert(0);
       
    }
}

static State transitionHandler(PhsicalUp)(KeyFSMData* data, State curState, int *isDelayExecuted)
{
    FSM_LOG(" 物理按键松开 ");
    data->countDelay = 0;
 
    switch (curState)
    {
    case DownDebouncing:
        if(data->countMultiDown){
            return MultiDownWaiting;
        }
        return Waiting;

    case Downing:
        return UpDebouncing;
    case Holding:
        return HoldUpDebouncing;

    case MultiDowning:
        return UpDebouncing;

    default:
        FSM_LOG("检查状态转移表设计，不应该到这里");
        assert(0);

    }
}

static void delayHanlder(DelayCount3)(KeyFSMData* data){
    data->out = Idle;
}

static State transitionHandler(DelayCount3)(KeyFSMData* data, State curState, int *isDelayExecuted){
    FSM_LOG(" 延迟计数到3 ");
    data->countDelay = 0;
    
    switch (curState)
    {
    case DownDebouncing:
        data->out = Down;
        isDelayExecuted[DelayCount3] = 0;
        
        FSM_LOG("按键按下");
        return Downing;

    case UpDebouncing:
        data->out = Up;
        data->countMultiDown++;

        FSM_LOG("按键松开");
        return MultiDownWaiting;

    case MultiDownWaiting:
        return Waiting;

    case HoldUpDebouncing:
        return Waiting;

    case MultiDownDebouncing:
        switch (data->countMultiDown + 1)
        {
        case 2:
            data->out = Down_2times;
            break;
        case 3:
            data->out = Down_3times;
            break;
        
        default:
            printf("reach MultiDown Limit!\n");
            break;
        }
        FSM_LOG(" 多击%d ", data->countMultiDown+1);
        isDelayExecuted[DelayCount3] = 0;
        return MultiDowning;

    default:
        FSM_LOG("检查状态转移表设计，不应该到这里");
        assert(0);
    }
}


static State transitionHandler(HoldCount4)(KeyFSMData* data, State curState, int *isDelayExecuted){
    FSM_LOG(" 计数到2进入长按模式 ");
    data->countDelay = 0;
 
    data->out = Hold;
    return Holding;
}




/* 
    用户自定义事件选择逻辑—————————————————begin 
*/
const static char *stateStr[] = {
    "Idle",
    "Waiting",
    "DownDebouncing",
    "Downing",
    "Holding",
    "UpDebouncing",
    "MultiDownWaiting",
    "MultiDowning",
    "HoldUpDebouncing",
    "MultiDownDebouncing",
    };
const static char *eventStr[] = {
    "Idle",
    "PhsicalDown",
    "PhsicalUp",
    "DelayCount3",
    "HoldCount4",
};
static void printFSM(KeyFSM* pFSM){
    KeyFSMData* data = pFSM->base.data;
    FSM_LOG("KeyFSM: ");
    FSM_LOG("%d, 当前状态:%s, \t当前事件:%s \t转移：",  data->countDelay, stateStr[getFSMCurState((FSM_Ptr)pFSM)], eventStr[getFSMCurEvent((FSM_Ptr)pFSM)]);
}


#endif