#include "MenuComponent.h"
#include "DisplayCenter.h"
#include "keymonitor.h"
#include "regsaccess.h"
#include "StateControl.h"
#include "wakeup.hpp"
#include "MotorboardParam.h"
#include "jsonconfig.h"
#include "deviceconfig.h"

StateControl::StateControl(std::shared_ptr<IRegsAccess> m_regsAccess,std::shared_ptr<WakeUp> wake):m_regs(m_regsAccess),m_wake(wake),
is_runing(false),is_cover_open(false),is_autopaper(false),en_autopaper_key(false){
    m_menu.reset(new MenuComponent());
    m_menu->initmenu();
    m_discenter.reset(new DisplayCenter());
    uint reg6value = 0;
    m_regs->read(0x6,reg6value);
    auto reg = *(reg6*)&reg6value;
    MotorboardParam::MBParam mb_param =  MotorboardParam().GetParam();
    reg.param.work_mode = 0;
    reg.param.lift_init_set = mb_param.trayposition;
    switch (mb_param.feedmode)
    {
    case 0:
        reg.param.func_feed_low =1;
        reg.param.func_feed_high = reg.param.func_feed_mid = 0;
        break;
    case 1:
        reg.param.func_feed_mid =1;
        reg.param.func_feed_high = reg.param.func_feed_low = 0;
        break;
    case 2:
        reg.param.func_feed_high =1;
        reg.param.func_feed_mid = reg.param.func_feed_low = 0;
        break;
    default:
        reg.param.func_feed_mid =1;
        reg.param.func_feed_high = reg.param.func_feed_low = 0;
        break;
    }
    m_regs->write(0x6,reg.value);
    auto keycall = [&](int keyvalye)
    {
        if(wake.get())
            wake->resettime();
        std::cout << "keycallback keyvalue= " << keyvalye << std::endl;
        uint value = 0;
        auto key = (KeyMonitor::HGKey)(keyvalye);
        if((is_autopaper && (!en_autopaper_key)) || (is_autopaper && en_autopaper_key && (key!=KeyMonitor::HGKey::Key_Cancle)))
            return ;
        if((is_runing && key!=KeyMonitor::HGKey::Key_Cancle)||is_cover_open)
            return ;
        value = 0;
        switch (key)
        {
        case KeyMonitor::HGKey::Key_Enter:
        {
            m_regs->read(0x6,value);
            auto reg = *(reg6*)&value;
            printf("\n reg.param.work_mode = %d ",reg.param.work_mode);
            if(reg.param.work_mode !=1)
                break;
            m_regs->read(0x02,value);
            if(!(value&0x10000))
            {
                PutMsg(DisType::Dis_Err_NoPaper,0,ClearScreen::All);
                break;
            }
            setrunstate(true);
            reg.param.func_encount = 1;
            reg.param.motor_disable = false;
            m_regs->write(0x6,reg.value);
            reg.param.func_encount = 0;
            m_regs->write(0x6,reg.value);
            if(m_wake.get())
                m_wake->setsleepfalg(true);
            printf("\n m_menu->getcurindex() %d",m_menu->getcurindex());
            m_discenter->PutMsg(DisType::Dis_Set_Count,0,ClearScreen::All);
            PutMsg(DisType::Dis_Scan_Page,getpapercount(),ClearScreen::BOT);
            break;
        }
        case KeyMonitor::HGKey::Key_Cancle:
        {
            reg6 func = {0};
            m_regs->read(0x06,func.value);
            m_regs->read(0x0a,value);
            m_menu->setcurindex(0);
            m_discenter->PutMsg(func.param.work_mode == 0? (is_runing?DisType::Dis_Scan : DisType::Dis_Idel):(func.param.work_mode == 1?DisType::Dis_Set_Count:DisType::Dis_HandMode),0,ClearScreen::All);
            if(m_discenter->getcurdistype() == DisType::Dis_Scan || m_discenter->getcurdistype() == DisType::Dis_Set_Count)
            {
                PutMsg(DisType::Dis_Scan_Page,getpapercount(),ClearScreen::BOT);
            }
            autopaperstop?autopaperstop():void();
            if(!is_runing)
                break;
            func.param.key_stop_enable = true;
            m_regs->write(0x06,func.value);
            func.param.key_stop_enable = false;
            func.param.motor_disable = value > 0 ? true:false;
            m_regs->write(0x06,func.value);
            if(m_wake.get())
                m_wake->setsleepfalg(false);
            //is_runing = false;
            // if(int(m_discenter->getcurdistype()) > 4 && int(m_discenter->getcurdistype())<14)
            //     m_discenter->PutMsg(DisType::Dis_Idel,0,ClearScreen::All);
            break;
        }
        case KeyMonitor::HGKey::Key_Count:
        {
            if(m_discenter->getcurdistype() != DisType::Dis_Idel)
            {
                m_menu->setcurindex(0);
                m_discenter->PutMsg(DisType::Dis_Idel, 0,ClearScreen::All);
            }
            m_regs->read(0x6,value);
            auto reg = *(reg6*)&value;
            printf("\n reg.param.work_mode = %d ",reg.param.work_mode);
            if(reg.param.work_mode!= 0 && reg.param.work_mode !=1)
                break;
            if(reg.param.work_mode == 1){
                reg.param.work_mode = 0;
                m_keymonitor->setled(KeyMonitor::HGLed::Led_Count_close);
            }
            else{
                reg.param.work_mode = 1;
                clearcount();
                getpapercount();
                PutMsg(DisType::Dis_Scan_Page,getpapercount(),ClearScreen::BOT);
                m_keymonitor->setled(KeyMonitor::HGLed::Led_Count_open);
            }
            m_regs->write(0x6,reg.value);
            m_discenter->PutMsg(reg.param.work_mode == 1?DisType::Dis_Set_Count:DisType::Dis_Idel,0, reg.param.work_mode == 1?ClearScreen::TOP : ClearScreen::All);
            break;
        }
        // case KeyMonitor::HGKey::Key_Handle:
        // {
        //     m_regs->read(0x6,value);
        //     auto reg = *(reg6*)&value;
        //     printf("\n reg.param.work_mode = %d ",reg.param.work_mode);
        //     if(reg.param.work_mode!= 0 && reg.param.work_mode !=5)
        //         break;
        //     if(reg.param.work_mode == 5){
        //         reg.param.work_mode = 0;
        //         m_keymonitor->setled(KeyMonitor::HGLed::Led_Handle_close);
        //     }
        //     else{
        //         reg.param.work_mode = 5;
        //         m_keymonitor->setled(KeyMonitor::HGLed::Led_Handle_open);
        //     }
        //     m_regs->write(0x6,reg.value);            
        //     m_discenter->PutMsg(reg.param.work_mode == 5?DisType::Dis_HandMode:DisType::Dis_Idel,0,ClearScreen::All);
        //     break;
        // }
        case KeyMonitor::HGKey::Key_DoubleFeed:
        {
            m_regs->read(0x6,value);
            auto reg = *(reg6*)&value;
            printf("\n reg.param.key_endouble_feed =%d ",reg.param.key_endouble_feed);
            if(reg.param.key_endouble_feed){
                reg.param.key_endouble_feed = 0;
                m_keymonitor->setled(KeyMonitor::HGLed::Led_DoubleFeed_close);
            }
            else{
                reg.param.key_endouble_feed = 1;
                m_keymonitor->setled(KeyMonitor::HGLed::Led_DoubleFeed_open);
            }
            m_regs->write(0x6,reg.value);
            break;
        }
        case KeyMonitor::HGKey::Key_Left:
        case KeyMonitor::HGKey::Key_Menu:
        case KeyMonitor::HGKey::Key_Right:
        {
            m_regs->read(0x6,value);
            auto reg = *(reg6*)&value;
            if(reg.param.work_mode != 0)
                break;
            if(keyvalye == (int)KeyMonitor::HGKey::Key_Menu)
                menu_func(m_menu->getcurtype());
            printf("\n m_menu->getcurindex() %d",m_menu->getcurindex());
            printf("\n mb 6 value%d",reg.value);
            if(keyvalye == (int)KeyMonitor::HGKey::Key_Menu && m_menu->getcurindex() == 2) //2 分纸强度项
                m_menu->setcurindex(reg.param.func_feed_high?9:(reg.param.func_feed_mid?10:11));  //8分纸强度高 9 分纸强度中 10 分纸强度弱
            else if(keyvalye == (int)KeyMonitor::HGKey::Key_Menu && m_menu->getcurindex() == 4) //2 分纸强度项
                m_menu->setcurindex(reg.param.lift_init_set == 2?22:(reg.param.lift_init_set == 1?23:24));  //7 分纸强度高 8 分纸强度中 9 分纸强度弱
            else
                m_menu->option(keyvalye);
            if(m_menu->getcurindex() >=26 && m_menu->getcurindex()<= 27)
            {
                m_discenter->PutMsg(m_menu->getcurtype(),
                m_menu->getcurindex() ==26  ? Get_static_jsonconfig().getmemparam().RollerNum :  Get_static_jsonconfig().getmemparam().TotalScanned,ClearScreen::BOT);
            }
            else if(m_menu->getcurindex() >=9 && m_menu->getcurindex()<= 36)
                m_discenter->PutMsg(m_menu->getcurtype(),0,ClearScreen::BOT);
            else
                m_discenter->PutMsg(m_menu->getcurtype(),0,ClearScreen::All);
            break;
        }
        case KeyMonitor::HGKey::Key_Clear:
        {
            clearcount();
            if(m_discenter->getcurdistype() == DisType::Dis_Count_Page || m_discenter->getcurdistype() == DisType::Dis_Scan_Page)
                m_discenter->PutMsg(DisType::Dis_Count_Page,0,ClearScreen::BOT);
            break;
        }
        default:
            break;
        }
        value = 0;
        m_regs->read(0x6, value);
        m_regs->write(0x6, value | 128);
        m_regs->write(0x6, value & 0xffffff7f);
    };
    m_keymonitor.reset(new KeyMonitor(keycall));
}

StateControl::~StateControl()
{
    uint value;
    m_regs->read(0x06,value);
    reg6 func = *(reg6*)&value;
    func.param.key_stop_enable = true;
    m_regs->write(0x06,func.value);
    func.param.key_stop_enable = false;
    m_regs->write(0x06,func.value);
    if(m_menu.get())
        m_menu.reset();
    if(m_discenter.get())
        m_discenter.reset();
    if(m_keymonitor.get())
        m_keymonitor.reset();
}

void StateControl::PutMsg(DisType type,int value,ClearScreen clearscreen)
{
    if(m_discenter)
    {
        if(type == DisType::Dis_Idel)
        {          
            uint value = 0;
            m_regs->read(0x6,value);
            auto tmp = *(reg6*)&value;
            switch (tmp.param.work_mode)
            {
            case 1:
                m_discenter->PutMsg(DisType::Dis_Set_Count,0,ClearScreen::All);
                m_discenter->PutMsg(DisType::Dis_Scan_Page,getpapercount(),ClearScreen::BOT);
                return ;
            case 5:
                m_discenter->PutMsg(DisType::Dis_HandMode,0,ClearScreen::All);
                return;
            default:
                m_discenter->PutMsg(type,value,clearscreen);
                break;
            }
        }
        else
            m_discenter->PutMsg(type,value,clearscreen);
    }
}

void StateControl::menu_func(DisType type)
{
    uint value = 0;
    MotorboardParam func_feed;
    m_regs->read(0x6,value);
    auto tmp = *(reg6*)&value;
    switch (type)
    {
    case DisType::Dis_Set_Poweroff:
        system("poweroff");
        break;
    case DisType::Dis_Set_ClearPaperPass:
        tmp.param.func_clean_passthro = 1;
        tmp.param.motor_disable = false;
        m_regs->write(0x6,tmp.value);
        tmp.param.func_clean_passthro = 0;
        m_regs->write(0x6,tmp.value);
        break;
    case DisType::Dis_Set_PollPI_High:
        tmp.param.func_feed_high = 1;
        tmp.param.func_feed_low = tmp.param.func_feed_mid = 0;
        m_regs->write(0x6,tmp.value);
        func_feed.GetOrSetFeedMode(false,2);
        break;
    case DisType::Dis_Set_PollPI_Mid:
        tmp.param.func_feed_mid = 1;
        tmp.param.func_feed_low = tmp.param.func_feed_high = 0;
        m_regs->write(0x6,tmp.value);
        func_feed.GetOrSetFeedMode(false,1);
        break;
    case DisType::Dis_Set_PollPI_Low:
        tmp.param.func_feed_low = 1;
        tmp.param.func_feed_mid = tmp.param.func_feed_high = 0;
        m_regs->write(0x6,tmp.value);
        func_feed.GetOrSetFeedMode(false,0);
        break;
    case DisType::Dis_Set_SleepMode_5M:
        if(m_wake.get())
            m_wake->settime(300);
        break;
    case DisType::Dis_Set_SleepMode_10M:
        if(m_wake.get())
            m_wake->settime(600);
        break;
    case DisType::Dis_Set_SleepMode_20M:
        if(m_wake.get())
            m_wake->settime(1200);
        break;
    case DisType::Dis_Set_SleepMode_30M:
        if(m_wake.get())
            m_wake->settime(1800);
        break;
    case DisType::Dis_Set_SleepMode_1H:
        if(m_wake.get())
            m_wake->settime(3600);
        break;
    case DisType::Dis_Set_SleepMode_2H:
        if(m_wake.get())
            m_wake->settime(7200);
        break;
    case DisType::Dis_Set_SleepMode_4H:
        if(m_wake.get())
            m_wake->settime(14400);
        break;
    case DisType::Dis_Set_SleepMode_NEVER:
        if(m_wake.get())
            m_wake->settime(-1);
        break;
    case DisType::Dis_Set_TrayPosition_High:
        tmp.param.lift_init_set  = 2;
        m_regs->write(0x6,tmp.value);
        func_feed.GetOrSetTrayPosition(false,2);
        break;
    case DisType::Dis_Set_TrayPosition_Mid:
        tmp.param.lift_init_set  = 1;
        m_regs->write(0x6,tmp.value);
        func_feed.GetOrSetTrayPosition(false,1);
        break;
    case DisType::Dis_Set_TrayPosition_Low:
        tmp.param.lift_init_set  = 0;
        m_regs->write(0x6,tmp.value);
        func_feed.GetOrSetTrayPosition(false,0);
        break;
    case DisType::Dis_Set_Clear_Roller_ScanNum:
    {
        PutMsg(DisType::Dis_Set_Is_Sure,0,ClearScreen::BOT);
        break;
    }
    case DisType::Dis_Set_YES:
    {
        if(m_menu->getcurindex() == 30)
        {
            auto tmp = Get_static_jsonconfig().getscannerinfo();
            tmp.RollerNum =0;
            Get_static_jsonconfig().savescannerinfo(tmp);
            PutMsg(DisType::Dis_Set_ScanNum_Option,0,ClearScreen::TOP);
        }
        break;
    }
    case DisType::Dis_Set_No:
    {
        if(m_menu->getcurindex() == 31)
            PutMsg(DisType::Dis_Set_ScanNum_Option,0,ClearScreen::TOP);
        break;
    }
    case DisType::Dis_Set_Item_Return:
    {
        if(m_menu->getcurindex() == 32)
            PutMsg(DisType::Dis_Set_ScanNum_Option,0,ClearScreen::TOP);
        break;
    }
    case DisType::Dis_Language_Chinese:
    {
        auto param = Get_static_deviceconfig().GetParam();
        if(param.language!=0){
            param.language = 0;
            Get_static_deviceconfig().SaveParam(param);
        }
        m_discenter->set_language(LCDDisplay::Language::Chinese);
        break;
    }
    case DisType::Dis_Language_Chinese_Traditional:
    {
        auto param = Get_static_deviceconfig().GetParam();
        if(param.language!=1){
            param.language = 1;
            Get_static_deviceconfig().SaveParam(param);
        }
        m_discenter->set_language(LCDDisplay::Language::TraditionalChinese);
        break;
    }
    case DisType::Dis_Language_English:
    {
        auto param = Get_static_deviceconfig().GetParam();
        if(param.language!=2){
            param.language = 2;
            Get_static_deviceconfig().SaveParam(param);
        }
        m_discenter->set_language(LCDDisplay::Language::English);
        break;
    }
    default:
        break;
    }
}

void StateControl::lcdcontrol(int led){
    if(m_keymonitor)
        m_keymonitor->setled((KeyMonitor::HGLed)led);
}

void StateControl::setrunstate(bool value)
{
    is_runing = value;
    if(is_runing){
        m_keymonitor->setled(KeyMonitor::HGLed::Led_Enter_open);
        m_menu->setcurindex(0);
    }
    else
    {
        uint value = 0;
        m_regs->read(0x6,value);
        auto tmp = *(reg6*)&value;
        m_keymonitor->setled(tmp.param.key_endouble_feed?KeyMonitor::HGLed::Led_DoubleFeed_open : KeyMonitor::HGLed::Led_DoubleFeed_close);
        m_keymonitor->setled(KeyMonitor::HGLed::Led_Enter_close);
    }
}

bool StateControl::getrunstate()
{
    return is_runing;
}

void StateControl::setcoverstate(bool value)
{
    is_cover_open = value;
}
bool StateControl::getcoverstate()
{
    return is_cover_open;
}
void StateControl::setmenuindex(int menu){
    m_menu->setcurindex(menu);
}

uint StateControl::getpapercount(){
    unsigned int papercount = 0;
    m_regs->read(0x02,papercount);
    printf("\nmotorcount = %d ",papercount&0x3fff);
    return papercount&0x3fff;
}

void StateControl::clearcount(){
    uint value = 0;
    m_regs->read(0x6,value);
    auto reg = *(reg6*)&value;
    reg.param.func_clear_count = 1;
    m_regs->write(0x6,reg.value);
    reg.param.func_clear_count = 0;
    m_regs->write(0x6,reg.value);
}

void StateControl::setautopaperflag(bool enable,bool enkey){
    is_autopaper = enable;
    en_autopaper_key = enkey;
}

 void StateControl::setautopaperstopcallback(std::function<void()> func)
 {
     if(func)
        autopaperstop = func;
 }