#include <QDebug>
#include <QDateTime>
#include <QFile>
#include <QIODevice>
#include <QApplication>
#include <QProcess>
#include "config.h"
#include "define.h"
#include "configdatetimedlg.h"
#include "configlanguagedlg.h"
#include "configtemptypedlg.h"
#include "configbacklightdlg.h"
#include "configtimeformatdlg.h"
#include "configresttimeformatdlg.h"
#include "configmastervolumedlg.h"
#include "configsoundselelectdlg.h"
#include "yesnopopupdlg.h"
#include "usbcheckpopupdlg.h"
#include "configipdlg.h"
#include "configfileprocessdlg.h"
#include "confighalfenergydlg.h"
#include "config1digitsetdlg.h"
#include "configdutywashdlg.h"
#include "configsteamwashdlg.h"
#include "fileprocessor.h"
#include "backlight.h"
#include "udphandler.h"
#include "system.h"
#include "unistd.h"
#include "configdemomodedlg.h"
#include "haccpdownloaddlg.h"
#include <QFontDatabase>

using namespace Define;
using namespace System;

Config* Config::instance = NULL;

Config::Config(QObject *parent) : QObject(parent)
{
    //memcpy(config_format,config_format_kr,MAX_CONFIG_COUNT*64);
    loadConfig();
    loadFavorite();
    qApp->installEventFilter(&watcher);
    applyCurrentConfigLanguage();
    applyConfig();
    loadProductInfo();

//    m_setFavorite.insert(2);
//    m_setFavorite.insert(3);
//    m_setFavorite.insert(1);
//    QSetIterator<uint32_t> i = getConstBeginFavorite();
//    while(i.hasNext()){
//        temp = i.next();
//        qDebug() << temp;
//    }
//    while(i.hasPrevious()){
//        temp = i.previous();
//        qDebug() << temp;
//    }
}

Config::~Config(){

}

Config* Config::getInstance(QObject *parent){
    if(instance ==NULL){
        instance = new Config(parent);
    }
    return instance;
}

QString Config::getProductSWVersion()
{
    if(MAJOR_VER == 0)
        return QString("V%1.%2.%3 BETA").arg(MAJOR_VER).arg(MINOR_VER).arg(HOTFIX_VER);
    else return QString("V%1.%2.%3").arg(MAJOR_VER).arg(MINOR_VER).arg(HOTFIX_VER);
}

void Config::initConfig(){
    memset(configlist.data,0x00,MAX_CONFIG_COUNT * 4);
    configlist.items.language.d32=0;
    configlist.items.datetime.d32=0;
    configlist.items.temptype.d32=0;
    configlist.items.backlight.d32=7;
    configlist.items.stop_delay.d32=10;
    configlist.items.best_dish_weight.d32=0;
    configlist.items.party_dish_weight.d32=0;
    configlist.items.ilc_rack_number.d32=10;
    configlist.items.ilc_rack_sequnece.d32=0x30201;
    configlist.items.ilc_cook_wait_time.d32=30;
    configlist.items.cooktime_format.d32=0;
    configlist.items.time_type.d32=1;
    configlist.items.resttime_format.d32=0;
    configlist.items.marster_vol.d32=7;
    configlist.items.keypad_sound1.d32=0;
    configlist.items.keypad_sound2.d32=7;
    configlist.items.request_loadexec.d32=6;
    configlist.items.programstep_finish.d32=7;
    configlist.items.cooktime_finish.d32=8;
    configlist.items.stoperror_distinguish.d32=9;
    configlist.items.sound_factory_reset.d32=0;
    configlist.items.haccp_data_download.d32=0;
    configlist.items.info_data_download.d32=0;
    configlist.items.service_data_download.d32=0;
    configlist.items.program_download.d32=0;
    configlist.items.program_upload.d32=0;
    configlist.items.program_initialize.d32=0;
    configlist.items.ip.d8.d8_0 = 192;
    configlist.items.ip.d8.d8_1 = 168;
    configlist.items.ip.d8.d8_2 = 0;
    configlist.items.ip.d8.d8_3 = 2;
    configlist.items.gateway.d8.d8_0 = 192;
    configlist.items.gateway.d8.d8_1 = 168;
    configlist.items.gateway.d8.d8_2 = 0;
    configlist.items.gateway.d8.d8_3 = 1;
    configlist.items.netmask.d32=0x00ffffff;
    configlist.items.set_download.d32=0;
    configlist.items.set_upload.d32=0;
    configlist.items.set_half_energy.d32=0;
    configlist.items.set_auto_darkness.d32=5;
    configlist.items.set_ilc_cook_temphumi_ready.d32=0;
    configlist.items.set_load_ready.d32=5;
    configlist.items.duty_wash.d32=0;
    configlist.items.loading_door_monitoring.d32=0;
    configlist.items.cooking_door_monitoring.d32=0;
    configlist.items.software_info.d32=0;
    configlist.items.hotline_chef.d32=0;
    configlist.items.hotline_service.d32=0;
    configlist.items.steam_wash.d32=0;
    configlist.items.demo_mode.d32=0;
    configlist.items.enter_engineer_mode.d32=0;
    configlist.items.model.d32 = model_electric_20;
    configlist.items.burner1_pwr1_normal_rpm.d32 = 4000;
    configlist.items.burner1_pwr1_half_rpm.d32 = 4000;
    configlist.items.burner1_pwr2_normal_rpm.d32 =  6000;
    configlist.items.burner1_pwr2_half_rpm.d32 = 4500;
    configlist.items.burner23_pwr1_normal_rpm.d32 = 2300;
    configlist.items.burner23_pwr1_half_rpm.d32 =  2300;
    configlist.items.burner23_pwr2_normal_rpm.d32 = 6500;
    configlist.items.burner23_pwr2_half_rpm.d32 = 4500;
    qDebug() << "Init Config lists";
}

bool Config::saveConfig(void){
    char buff[sizeof(config_lists)+1];
    qint64 writelen;
    QFile file(CONFIG_FILE_NAME);+
    memcpy(buff, configlist.data, sizeof(config_lists));
    buff[sizeof(config_lists)] = 0x9C;
    if(file.open(QIODevice::WriteOnly)){
        writelen = file.write(buff,sizeof(config_lists)+1);
        file.close();
        sync();
        if(writelen == (sizeof(config_lists)+1)){
            qDebug() << "config file saved";
            return true;
        }
    }
    qDebug() << "saving config file is fail!";
    return false;
}

bool Config::loadConfig(){
    uint8_t buff[sizeof(config_lists)+1];
    qint64 readlen;
    QFile file(CONFIG_FILE_NAME);
    initConfig();
    if(file.open(QIODevice::ReadOnly)){
        readlen = file.read((char *) buff,sizeof(config_lists)+1);
        file.close();
        if(readlen != (sizeof(configlist)+1)){
            //File size is wrong. apply default config value & save default value;
            qDebug() << "config file size wrone, apply defult setting!";
            saveConfig();
            return false;
        }
        if (buff[sizeof(config_lists)] ==0x9c){
            memcpy(configlist.data,buff,sizeof(config_lists));
            qDebug() << "loading config file success";
        }
        else {
            qDebug()<<"loading config file fail";
            saveConfig();
            return false;
        }
    }
    else{
        saveConfig();
    }
    return false;
}

void Config::applyConfig(){
    watcher.setDelay(configlist.items.set_auto_darkness.d32);
    Backlight::set(configlist.items.backlight.d32);
    UdpHandler* udp = UdpHandler::getInstance();

    switch (configlist.items.model.d32)
    {
    case Define::model_gas_lng_10:
    case Define::model_gas_lng_20:
    case Define::model_gas_lng_24:
    case Define::model_gas_lng_40:
    case Define::model_gas_lpg_10:
    case Define::model_gas_lpg_20:
    case Define::model_gas_lpg_24:
    case Define::model_gas_lpg_40:
        if (configlist.items.set_half_energy.d32)
        {
            udp->set(TG_BURNER1_1_RPM, configlist.items.burner1_pwr1_half_rpm.d32);
            udp->set(TG_BURNER1_2_RPM, configlist.items.burner1_pwr2_half_rpm.d32);
            udp->set(TG_BURNER23_1_RPM, configlist.items.burner23_pwr1_half_rpm.d32);
            udp->set(TG_BURNER23_2_RPM, configlist.items.burner23_pwr2_half_rpm.d32);
        }
        else
        {            
            udp->set(TG_BURNER1_1_RPM, configlist.items.burner1_pwr1_normal_rpm.d32);
            udp->set(TG_BURNER1_2_RPM, configlist.items.burner1_pwr2_normal_rpm.d32);
            udp->set(TG_BURNER23_1_RPM, configlist.items.burner23_pwr1_normal_rpm.d32);
            udp->set(TG_BURNER23_2_RPM, configlist.items.burner23_pwr2_normal_rpm.d32);
        }
        UdpHandler::getInstance()->set(TG_PRODUCT_TYPE, 1);
        break;
    default:
        UdpHandler::getInstance()->set(TG_PRODUCT_TYPE, 2);
        break;
    }

    switch (configlist.items.model.d32)
    {
    case Define::model_electric_10:
    case Define::model_gas_lng_10:
    case Define::model_gas_lpg_10:
        UdpHandler::getInstance()->set(TG_MODEL_TYPE, 3);
        break;
    case Define::model_electric_20:
    case Define::model_gas_lng_20:
    case Define::model_gas_lpg_20:
        UdpHandler::getInstance()->set(TG_MODEL_TYPE, 2);
        break;
    case Define::model_electric_24:
    case Define::model_gas_lng_24:
    case Define::model_gas_lpg_24:
        UdpHandler::getInstance()->set(TG_MODEL_TYPE, 1);
        break;
    case Define::model_electric_40:
    case Define::model_gas_lng_40:
    case Define::model_gas_lpg_40:
        UdpHandler::getInstance()->set(TG_MODEL_TYPE, 0);
        break;
    }

    System::IPData ipdata;

    ipdata.address = QString("%1.%2.%3.%4").arg(configlist.items.ip.d8.d8_0).arg(configlist.items.ip.d8.d8_1).arg(configlist.items.ip.d8.d8_2).arg(configlist.items.ip.d8.d8_3);
    ipdata.gateway = QString("%1.%2.%3.%4").arg(configlist.items.gateway.d8.d8_0).arg(configlist.items.gateway.d8.d8_1).arg(configlist.items.gateway.d8.d8_2).arg(configlist.items.gateway.d8.d8_3);
    ipdata.netmask = QString("%1.%2.%3.%4").arg(configlist.items.netmask.d8.d8_0).arg(configlist.items.netmask.d8.d8_1).arg(configlist.items.netmask.d8.d8_2).arg(configlist.items.netmask.d8.d8_3);

    System::setIP(ipdata);
    //All Error Reset
    UdpHandler::getInstance()->set(TG_ERROR_CLEAR,0xCECE);
}

Define::config_item Config::getConfigValue(Define::ConfigType idx){
    return configlist.values[idx];
}



void Config::setConfigValue(Define::ConfigType idx, Define::config_item& itemdata){
    configlist.values[idx] = itemdata;
}


QString Config::getValueString(Define::ConfigType idx){
    QString qstrTemp="";
    if( (config_data_type[(uint32_t)idx] & 0x80) ==0){
        switch(config_data_type[(uint32_t)idx]){
        case 0:
            //qstrTemp.sprintf(config_format[(uint32_t)idx], configlist.values[(uint32_t)idx].d32);
            qstrTemp= tr(config_format[(uint32_t)idx]).arg(configlist.values[(uint32_t)idx].d32);
        break;
        case 1:
            qstrTemp.sprintf(config_format[(uint32_t)idx], configlist.values[(uint32_t)idx].f32);
            break;
        case 2:
            qstrTemp = tr(config_format[(uint32_t)idx]);
            break;
        case 3:
            //qstrTemp.sprintf(config_format[(uint32_t)idx], configlist.values[(uint32_t)idx].d32+1);
            qstrTemp= tr(config_format[(uint32_t)idx]).arg(configlist.values[(uint32_t)idx].d32+1);
            break;
        case 0x7f:
            qstrTemp = "";
            break;
        }
        return qstrTemp;
    }

    QDateTime qdt = QDateTime::currentDateTime();

    switch(idx){
        case config_language:
        if(configlist.items.language.d32 >=3) configlist.items.language.d32 = 0;
        qstrTemp = tr(language_menu[configlist.items.language.d32]);
        break;

    case config_datetime:
        qstrTemp = qdt.toString("yyyy.MM.dd hh:mm");
        break;
    case config_temptype:
        if(configlist.items.temptype.d32 >=2 ) configlist.items.temptype.d32 = 0;
        qstrTemp = tr(temptype_menu[configlist.items.temptype.d32]);
        break;
    case config_best_dish_weight:
        if(configlist.items.best_dish_weight.d32 >=4) configlist.items.best_dish_weight.d32 = 0;
        qstrTemp = tr(best_dish_weight_menu[configlist.items.best_dish_weight.d32]);
        break;
    case config_party_dish_weight:
        if(configlist.items.party_dish_weight.d32 >=4) configlist.items.party_dish_weight.d32 = 0;
        qstrTemp = tr(best_dish_weight_menu[configlist.items.party_dish_weight.d32]);
        break;
    case config_time_type:
        if(configlist.items.time_type.d32 >=2) configlist.items.time_type.d32 = 0;
        qstrTemp = tr(time_type_menu[configlist.items.time_type.d32]);
        break;
    case config_resttime_format:
        if(configlist.items.resttime_format.d32 >=2) configlist.items.resttime_format.d32 = 0;
        qstrTemp = tr(rest_time_type_menu[configlist.items.resttime_format.d32]);
        break;
    case config_ip:
        qstrTemp.sprintf("%3d.%3d.%3d.%3d", configlist.items.ip.d8.d8_0,configlist.items.ip.d8.d8_1,configlist.items.ip.d8.d8_2,configlist.items.ip.d8.d8_3);
        break;
    case config_set_half_energy:
        if(configlist.items.set_half_energy.d32 >=2) configlist.items.set_half_energy.d32 = 0;
        qstrTemp = tr(set_unset_menu[configlist.items.set_half_energy.d32]);
        break;
    case config_duty_wash:
        if(configlist.items.duty_wash.d32 >=2) configlist.items.duty_wash.d32 = 0;
        qstrTemp = tr(active_on_off_menu[configlist.items.duty_wash.d32]);
        break;
    case config_cooking_door_monitoring:
        //qstrTemp.sprintf(config_format[(uint32_t)idx],configlist.items.cooking_door_monitoring.d8.d8_0);
        qstrTemp = tr(config_format[(uint32_t)idx]).arg(configlist.items.cooking_door_monitoring.d8.d8_0);
        break;
    case config_loading_door_monitoring:
        qstrTemp = tr(config_format[(uint32_t)idx]).arg(configlist.items.loading_door_monitoring.d8.d8_0);
        break;
    case config_demo_mode:
        if(configlist.items.demo_mode.d32 >=2) configlist.items.demo_mode.d32 = 0;
        qstrTemp = tr(on_off_menu[configlist.items.demo_mode.d32]);
        break;
    default:
        qstrTemp = "";
        break;
    }
    return qstrTemp;
}

QString Config::getTitleString(Define::ConfigType idx){
    return tr(config_title[idx]);//strTemp;
}

bool Config::isFavorite(Define::ConfigType idx){
    return m_setFavorite.contains((uint32_t)idx);
    return true;
}

QSetIterator<uint32_t> Config::getConstBeginFavorite(){
    QSetIterator<uint32_t> i(m_setFavorite);
    return i;
}

QList<uint32_t> Config::getConstSortedFavorite(){
    QList<uint32_t> list = m_setFavorite.toList();
    qSort(list);
    return list;
}

bool Config::loadFavorite(void){
    bool rst;
    uint32_t itemp;
    QFile file(FAVORITE_FILE_NAME);
    if(file.open(QIODevice::ReadOnly | QIODevice::Text)){
        m_setFavorite.clear();
        while(!file.atEnd()){
            QByteArray line = file.readLine();
            QString strTemp = tr(line);
            itemp = strTemp.toInt(&rst,10);
            if(rst && itemp < (uint32_t)config_invalid)  {
                m_setFavorite.insert(itemp);
            }
        }
        file.close();
        qDebug() << "loading Favorite Menu Success";
    }
    else{
        qDebug() << "Favorite File Not Found";
    }
    return false;
}

bool Config::saveFavorite(void){
    uint32_t itemp;
    QFile file(FAVORITE_FILE_NAME);
    if(file.open(QIODevice::WriteOnly | QIODevice::Text)){
        QTextStream out(&file);
        QSetIterator<uint32_t> itr(m_setFavorite);
        while(itr.hasNext()){
            itemp = itr.next();
            out << itemp << "\n";
            qDebug() << "save favorite index" << itemp;
        }
        file.close();
        sync();
        qDebug()<<"saving Favorite menu success";
        return true;
    }
    else{
        qDebug() << "saving favorite fail";
    }
    return false;
}

//Sytem Config Area Copy
void Config::copyConfigArea(const char *buff)
{
    config_item* end = &configlist.items.model;
    config_item *start = &configlist.values[0];

    uint32_t size = end - start;

    qDebug() << "size is "<< size;

    memcpy(&configlist.data[0], buff, sizeof(config_item)*size);
}

void Config::insertFavorite(Define::ConfigType idx){
    m_setFavorite.insert((uint32_t)idx);
}
void Config::removeFavorite(Define::ConfigType idx){
    m_setFavorite.remove((uint32_t)idx);
}

void Config::applyCurrentConfigLanguage()
{
    if(configlist.items.language.d32 == 0){
//        QApplication::removeTranslator();
//        QTranslator* trans = new QTranslator();
//        qDebug() << trans->load(":/lang_zh.qm");
//        QApplication::removeTranslator(QApplication::)
    }
    else if(configlist.items.language.d32 ==2){
        QTranslator* trans = new QTranslator();
        qDebug() << trans->load(":/lang_en.qm");
        QApplication::installTranslator(trans);
    }
    else if(configlist.items.language.d32 == 1){
        //QFontDatabase::addApplicationFont("/prime/fonts/NotoSansCJKsc-Light.subset.otf");
        //QFontDatabase::addApplicationFont("/prime/fonts/NotoSansCJKsc-Regular.subset.otf");
        //qApp->setFont(QFont("/prime/SourceHanSans-Normal.otf"));
        qApp->setFont(QFont("Noto Sans CJK SC"));
        QTranslator* trans = new QTranslator();
        qDebug() << trans->load(":/lang_zh.qm");
        QApplication::installTranslator(trans);
    }
}

void Config::allProgramInit()
{
    QProcess process(this);
    QStringList args;
    process.start("sh -c \"rm -rf /prime/*\"");
    if(process.waitForFinished(30000)==true){
        qDebug()<< "All Program Delete Success:";
        sync();
        QProcess reboot;
        reboot.start("reboot");
        reboot.waitForFinished();
    }
}

bool Config::loadProductInfo()
{
    QString strTemp;
    QMap<QString , QString> mapInfos;

    FileProcessor::readFromInfoFile(mapInfos, QString(MODEL_INFO_FILE_NAME));

    //m_strProductModelName = mapInfos[tr("모  델  명")];

    if(mapInfos.find(tr("모  델  명")) !=mapInfos.end())
        m_strProductModelName = mapInfos[tr("모  델  명")];
    else if(mapInfos.find(("모  델  명")) !=mapInfos.end())
        m_strProductModelName = mapInfos["모  델  명"];
    else m_strProductModelName = "PRIME ST-01";

    //m_strProductDateTime = mapInfos[tr("제조일자")];
    if(mapInfos.find(tr("제조일자")) != mapInfos.end())
        m_strProductDateTime = mapInfos[tr("제조일자")];
    else if(mapInfos.find("제조일자") != mapInfos.end())
        m_strProductDateTime = mapInfos["제조일자"];
    else m_strProductDateTime = "2017-10";


    //m_strProductCountry = mapInfos[tr("제조국")];
    if(mapInfos.find(tr("제조국")) != mapInfos.end())
        m_strProductCountry = mapInfos[tr("제조국")];
    else if(mapInfos.find("제조국") != mapInfos.end())
         m_strProductCountry = mapInfos["제조국"];
    else m_strProductCountry= "Korea";

    //m_strProductCompany = mapInfos[tr("제조사")];
    if(mapInfos.find(tr("제조사"))!= mapInfos.end())
        m_strProductCompany = mapInfos[tr("제조사")];
    else if(mapInfos.find("제조사")!=mapInfos.end())
        m_strProductCompany = mapInfos["제조사"];
    else m_strProductCompany="PRIME";

    //m_strProductSerial = mapInfos[tr("제품번호")];
    if(mapInfos.find(tr("제품번호"))!=mapInfos.end())
        m_strProductSerial = mapInfos[tr("제품번호")];
    else if(mapInfos.find("제품번호")!=mapInfos.end())
        m_strProductSerial = mapInfos["제품번호"];
    else m_strProductSerial = "01";
    m_strProductType = tr(g_strModelTypeName[getConfigValue(Define::config_model).d32]);
}

void Config::execConfigWindow(QWidget *parent, Define::ConfigType idx){
    QDialog *dlg;
    QString usbPath = "";
    switch(idx){
    case config_language:
        dlg = new ConfigLanguageDlg(parent);
        break;
    case config_temptype:
        dlg = new ConfigTempTypeDlg(parent);
        break;
    case config_backlight:
        dlg = new ConfigBackLightDlg(parent);
        break;
    case config_time_type:
        dlg = new ConfigTimeFormatDlg(parent);
        break;
    case config_resttime_format:
        dlg = new configResttimeFormatDlg(parent);
        break;
    case config_marster_vol:
        dlg = new ConfigVolumeDlg(parent, idx);
        break;
    case config_keypad_sound2:
        dlg = new ConfigVolumeDlg(parent, idx);
        break;
    case config_keypad_sound1:
    case config_request_loadexec:
    case config_programstep_finish:
    case config_cooktime_finish:
    case config_stoperror_distinguish:
        dlg = new ConfigSoundSelelectDlg(parent,idx);
        break;
     case config_sound_factory_reset:
        dlg = new YesNoPopupDlg(parent, tr("모든 음향설정 값을 공장초기화\r하시겠습니까?"));
        break;
    case config_ip:
        dlg=new ConfigIpDlg(parent);
        break;
    case config_haccp_data_download:
        dlg = new HaccpDownloadDlg(parent);
        break;
    case config_info_data_download:
    case config_service_data_download:
    case config_program_download:
    case config_set_download:
        if(!FileProcessor::detectUSB(usbPath)){
            dlg = new UsbCheckPopupDlg(parent);
            dlg->exec();
        }
        if(FileProcessor::detectUSB(usbPath)){
            dlg = new ConfigFileProcessDlg(parent,idx);
            dlg->exec();
        }
        return;
    case config_set_upload:
    case config_program_upload:

        if(!FileProcessor::detectUSB(usbPath)){
            dlg = new UsbCheckPopupDlg(parent);
            dlg->exec();
        }
        if(FileProcessor::detectUSB(usbPath)){
            dlg = new ConfigFileProcessDlg(parent,idx,false);
            dlg->exec();
        }
        return;
    case config_program_initialize:
        dlg = new YesNoPopupDlg(parent, tr("모든 프로그램을\r삭제하시겠습니까?"));
        break;
    case config_set_half_energy:
        dlg = new ConfigHalfEnergyDlg(parent);
        break;
     case config_set_auto_darkness:
        dlg = new Config1DigitSetDlg(parent,idx);
        break;
    case config_duty_wash:
        dlg = new ConfigDutyWashDlg(parent);
        break;
    case config_demo_mode:
        dlg = new ConfigDemoModeDlg(parent);
        break;
    case config_steam_wash:
        dlg = new ConfigSteamWashDlg(parent);
        break;
    default:
        dlg=NULL;
    }
    if(dlg == NULL) return;
    dlg->setWindowModality(Qt::WindowModal);
    dlg->exec();
    if(dlg->result() == QDialog::Accepted){
        qDebug()<<"Accepted";
        if(idx == config_sound_factory_reset){
            //Sound Fatory Reset
            soundConfigReset();
            qDebug() << "Process Sound Config Reset";
        }
        else if(idx==config_program_initialize){
            allProgramInit();
            qDebug() << "All Program Reset";
        }
    }
    else{
        qDebug() << "rejected";
    }
}

void Config::soundConfigReset(){
    configlist.items.marster_vol.d32=7;
    configlist.items.keypad_sound1.d32=0;
    configlist.items.keypad_sound2.d32=7;
    configlist.items.request_loadexec.d32=6;
    configlist.items.programstep_finish.d32=7;
    configlist.items.cooktime_finish.d32=8;
    configlist.items.stoperror_distinguish.d32=9;
}