#include "TjdUiAppOtaView.h"
#include "TjdUiImageIds.h"
#include "TjdUiMultiLanguageExt.h" //字库
#include "common/image_cache_manager.h"
#include "graphic_service.h"
#include <thread>

#ifdef __cplusplus
extern "C" {
#endif

#include "ble_api.h"
#include "ble_protocol_ota_service.h"
#include "upg_porting.h"
#include "power_display_service.h"
#include "service_ancillary.h"
#include "rtc_api.h"

#ifdef __cplusplus
}
#endif

namespace TJD {

using namespace OHOS;

#define OTA_IMAGE_BIN_PATH TJD_IMAGE_PATH "img_ota.bin"

enum OtaImageInfoIndex
{
    OTA_INFO_UPGRADE,
    OTA_INFO_INTERRUPT,
    OTA_INFO_FAIL,
    OTA_INFO_ENTER,
    OTA_INFO_KNOB,
    OTA_INFO_COUNT
};

static TjdUiAppOtaView *g_pv_AppOtaView = nullptr;
static OHOS::ImageInfo *g_pv_otaimageInfo[OtaImageInfoIndex::OTA_INFO_COUNT]{nullptr};
// static void TjdUiAppIntoOtaView(void)
// {
//     OHOS::NativeAbility::GetInstance().ChangeSlice(TJD_APP_VIEW_OTA);
// }

// static void TjdUiAppOTAInterruptView(void)
// {
//     TjdUiAppOtaView::GetInstance().ShowView(OtaViewIndex::OTA_INTERRUPT_VIEW);
// }

void TjdUiAppGetOtaSchedule(uint32_t ota_file_offset, uint32_t ota_file_size)
{   
    GraphicService::GetInstance()->PostGraphicEvent([&]() {
        uint64_t product = static_cast<uint64_t>(ota_file_offset) * 100;
        uint32_t schedule = static_cast<uint32_t>(product / ota_file_size);
        // printf("ota_file_offset = %d, ota_file_size = %d, schedule:%d\n",ota_file_offset,ota_file_size,schedule);
        TjdUiAppOtaView::GetInstance()->SetOtaSchedule(ota_file_offset);
        TjdUiAppOtaView::GetInstance()->SetOtaVal(schedule);
    }); 
    
}

TjdUiAppOtaView::TjdUiAppOtaView() 
{
    g_pv_AppOtaView = this;
    register_ota_schedule_callback(TjdUiAppGetOtaSchedule);
    otaSchedul = 0;
}
TjdUiAppOtaView::~TjdUiAppOtaView() 
{   
    g_pv_AppOtaView = nullptr;
    unregister_ota_schedule_callback();
}
TjdUiAppOtaView *TjdUiAppOtaView::GetInstance(void) { return g_pv_AppOtaView; }

void TjdUiAppOtaView::OnStart() 
{
    View<TjdUiAppOtaPresenter>::OnStart();
    InitImage();
    if (containerAll_ == nullptr) {
        containerAll_= new UIViewGroup();
    }
    containerAll_->SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);

    otaView[OtaViewIndex::OTA_UPGRADE_VIEW] = InitOtaUpgradeView();
    otaView[OtaViewIndex::OTA_INTERRUPT_VIEW] = InitOtaInterruptView();
    otaView[OtaViewIndex::OTA_FAIL_VIEW] = InitOtaFailView();

    containerAll_->Add(otaView[OtaViewIndex::OTA_UPGRADE_VIEW]);
    containerAll_->Add(otaView[OtaViewIndex::OTA_INTERRUPT_VIEW]);
    containerAll_->Add(otaView[OtaViewIndex::OTA_FAIL_VIEW]);

    // timer_->Start();
    // RootView::GetInstance()->Add(containerAll_);
    AddViewToRootContainer(containerAll_);
    timer_->Start();
}

void TjdUiAppOtaView::OnStop() {
    if (timer_ != nullptr) {
        timer_->Stop();
        delete timer_;
        timer_ = nullptr;
    }

    ImageCacheManager::GetInstance().UnloadAllInMultiRes(OTA_IMAGE_BIN_PATH);
    TjdUiMemManage::DeleteChildren(containerAll_);
}

void TjdUiAppOtaView::ShowView(OtaViewIndex hideView, OtaViewIndex showView)
{
    if (otaView[hideView] != nullptr) {
        otaView[hideView]->SetVisible(false);
    }
    if (otaView[showView] != nullptr) {
        otaView[showView]->SetVisible(true);
        currentView_ = showView;
    }
}

void TjdUiAppOtaView::SetOtaVal(int val)
{
    if (sldotaupg_ == nullptr && lblUpgNum_ == nullptr) {
        return;
    }
    std::string text = std::to_string(val)+ "%";
    lblUpgNum_->SetText(text.c_str());
    int val_=val*0.92;
    sldotaupg_->SetValue(val_ + 4);
    sldotaupg_->Invalidate();
}

// static upg_prepare_info_t prepare_info = {0};

void TjdUiAppOtaView::SetUpgrate(void)
{   
    uint32_t packsize_= tjd_ota_get_fimrware_size();
    upg_prepare_info_t prepare_info = {
                .package_len = packsize_
    };
    // prepare_info.package_len = packsize_;
    printf("%s , line is %d ,prepare_info.package_len = %d , packsize_ = %d\n", __FUNCTION__, __LINE__, prepare_info.package_len,packsize_);
    if(prepare_info.package_len != 0){
        errcode_t ret = uapi_upg_prepare(&prepare_info);
        if(ret != ERRCODE_SUCC){
            printf("uapi_upg_prepare fail! ret = %d\n",ret);
        }
        ret = uapi_upg_request_upgrade(false);
        if(ret != ERRCODE_SUCC){
            printf("uapi_upg_request_upgrade fail! ret = %d\n",ret);
        }
        ret = uapi_upg_start();
        if(ret != ERRCODE_SUCC){
            printf("uapi_upg_start fail! ret = %d\n",ret);
        }
        upg_reboot();
    }else{
        std::thread resetThread([]() {
            printf("ResetSystem thread run\n");

            const power_display_svr_api_t *displayApi = power_display_svr_get_api();
            uint32_t ret = displayApi->turn_off_screen();
            if (ret != ERRCODE_SUCC) {
                printf("turn_off_screen failed %x\n", ret);
            }
            osDelay(1000);
            OHOS::NativeAbility::GetInstance().StopAbility();

            tjd_driver_rtc_save_time();
            tjd_service_ancillary_device_restart();
        });
        resetThread.detach();
    }
    
}

void TjdUiAppOtaView::InitImage()
{
    g_pv_otaimageInfo[OtaImageInfoIndex::OTA_INFO_UPGRADE] = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_OTA_OTA, OTA_IMAGE_BIN_PATH);
    g_pv_otaimageInfo[OtaImageInfoIndex::OTA_INFO_INTERRUPT] = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_OTA_OTA_INTERRUPT, OTA_IMAGE_BIN_PATH);
    g_pv_otaimageInfo[OtaImageInfoIndex::OTA_INFO_ENTER] = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_OTA_ICON_ENTER, OTA_IMAGE_BIN_PATH);
    g_pv_otaimageInfo[OtaImageInfoIndex::OTA_INFO_FAIL] = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_OTA_OTA_NO_MATCH, OTA_IMAGE_BIN_PATH);
    g_pv_otaimageInfo[OtaImageInfoIndex::OTA_INFO_KNOB] = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_OTA_KONB, OTA_IMAGE_BIN_PATH);
}

void TimerCallback(void *param)
{   
    //定时器每30秒读一次GetOtaSchedule()的值，如果这次读值 == 上次读值，则显示升级中断页面
    static uint32_t value = 0;
    uint32_t curValue = TjdUiAppOtaView::GetInstance()->GetOtaSchedule();
    if (curValue == value && curValue != 0) {
        TjdUiAppOtaView::GetInstance()->ShowView(OTA_UPGRADE_VIEW,OTA_INTERRUPT_VIEW);
    }else{
        value = curValue;
    }
    // else{
    //     value = curValue;
    //     TjdUiAppOtaView::GetInstance()->GetOtaSchedultimer()->SetPeriod(3000);
    //     TjdUiAppOtaView::GetInstance()->ShowView(OTA_INTERRUPT_VIEW,OTA_UPGRADE_VIEW);
    // }
    // uint32_t * ota_val = (uint32_t *)param;
    // if (value <= 5) {
    //     TjdUiAppOtaView::GetInstance()->SetOtaVal(value);
    // }
    // if (value > 100) {
    //     value = 0;
    // }
}

OHOS::UIViewGroup *TjdUiAppOtaView::InitOtaUpgradeView()
{
    OHOS::UIViewGroup *otaUpgradeView = new OHOS::UIViewGroup();
    otaUpgradeView->SetPosition(0, 0, 466, 466);

    if (otaUpg_ == nullptr) {
        otaUpg_ = new OHOS::UIImageView();
    }
    otaUpg_->SetPosition(164, 64, 139, 172);
    otaUpg_->SetViewId(BTN_OTA_UPGRADE_ID);
    otaUpg_->SetTouchable(true);
    otaUpg_->SetOnClickListener(TjdUiAppOtaPresenter::GetInstance());
    if (g_pv_otaimageInfo[OtaImageInfoIndex::OTA_INFO_UPGRADE] != nullptr) {
            otaUpg_->SetSrc(g_pv_otaimageInfo[OtaImageInfoIndex::OTA_INFO_UPGRADE]);
        }

    if (lblUpgrade_ == nullptr) {
        lblUpgrade_ = new UILabel();
    }
    lblUpgrade_->SetFont(TJD_VECTOR_FONT_FILENAME, 34);
    lblUpgrade_->SetText("升级中...");
    lblUpgrade_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    lblUpgrade_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    lblUpgrade_->SetPosition(170, 262);

    if (lblUpgNum_ == nullptr) {
        lblUpgNum_ = new UILabel();
    }
    lblUpgNum_->SetFont(TJD_VECTOR_FONT_FILENAME, 34);
    lblUpgNum_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    lblUpgNum_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    lblUpgNum_->SetText("0%");
    lblUpgNum_->SetPosition(202, 389);

    if (lblUpgPercent_ == nullptr) {
        lblUpgPercent_ = new UILabel();
    }
    lblUpgPercent_->SetFont(TJD_VECTOR_FONT_FILENAME, 34);
    lblUpgPercent_->SetText("%");
    lblUpgPercent_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    lblUpgPercent_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    lblUpgPercent_->SetPosition(222, 389);

    if (sldotaupg_ == nullptr) {
        sldotaupg_ = new UISlider();
    }
    sldotaupg_->SetPosition(71, 345); 
    sldotaupg_->Resize(324, 24);          
    sldotaupg_->SetViewId("slider_ota");
    sldotaupg_->SetStyle(STYLE_BACKGROUND_OPA, 0xff);
    sldotaupg_->SetStyle(STYLE_BORDER_RADIUS, 6);

    sldotaupg_->SetValidWidth(324);
    sldotaupg_->SetValidHeight(12);
    sldotaupg_->SetSliderColor(Color::GetColorFromRGBA(0x74, 0x6c, 0x6c, 0xff), Color::GetColorFromRGBA(0x32, 0x99, 0xFE, 0xff));
    sldotaupg_->SetKnobWidth(25);
    sldotaupg_->SetKnobStyle(STYLE_BACKGROUND_COLOR, 0xff3299FE);
    sldotaupg_->SetKnobRadius(12);
    sldotaupg_->SetValue(4);
    sldotaupg_->SetTouchable(false);
    if (g_pv_otaimageInfo[OtaImageInfoIndex::OTA_INFO_KNOB] != nullptr) {
        sldotaupg_->SetKnobImage(g_pv_otaimageInfo[OtaImageInfoIndex::OTA_INFO_KNOB]);
    } else {
        sldotaupg_->SetKnobStyle(STYLE_BACKGROUND_COLOR, 0xffe30d0d);
    }
    sldotaupg_->SetForegroundStyle(STYLE_BACKGROUND_OPA, 0xff);
    sldotaupg_->SetSliderRadius(6, 6);

    if (timer_ == nullptr) {
        timer_ = new OHOS::GraphicTimer(30000, TimerCallback, nullptr, true);//1000ms 1次TimerCallback 继而1次SetOtaVal
    }

    otaUpgradeView->Add(otaUpg_);
    otaUpgradeView->Add(lblUpgNum_);
    otaUpgradeView->Add(lblUpgrade_);
    otaUpgradeView->Add(sldotaupg_);
    return otaUpgradeView;
}

OHOS::UIViewGroup *TjdUiAppOtaView::InitOtaInterruptView() 
{
    OHOS::UIViewGroup *otaInterruptView = new OHOS::UIViewGroup();
    otaInterruptView->SetPosition(0, 0, 466, 466);

    if (otaInterrupt_ == nullptr) {
        otaInterrupt_ = new OHOS::UIImageView();
    }
    otaInterrupt_->SetPosition(165, 64, 156, 172);
    otaInterrupt_->SetViewId(BTN_OTA_INTERRUPT_ID);
    otaInterrupt_->SetTouchable(true);
    otaInterrupt_->SetOnClickListener(TjdUiAppOtaPresenter::GetInstance());
    if (g_pv_otaimageInfo[OtaImageInfoIndex::OTA_INFO_INTERRUPT] != nullptr) {
        otaInterrupt_->SetSrc(g_pv_otaimageInfo[OtaImageInfoIndex::OTA_INFO_INTERRUPT]);//pic
    }

    if (lblInterrupt_ == nullptr) {
        lblInterrupt_ = new UILabel();
    }
    lblInterrupt_->SetFont(TJD_VECTOR_FONT_FILENAME,32);
    lblInterrupt_->SetText("升级中断\n请连接后再次升级！");
    lblInterrupt_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    lblInterrupt_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    lblInterrupt_->SetPosition(83, 261);

    if (otaEnter_ == nullptr) {
        otaEnter_ = new OHOS::UIImageView();
    }
    otaEnter_->SetPosition(183, 376, 100, 50);
    otaEnter_->SetViewId(BTN_OTA_ENTER_ID);
    otaEnter_->SetTouchable(true);
    otaEnter_->SetOnClickListener(TjdUiAppOtaPresenter::GetInstance());
    if (g_pv_otaimageInfo[OtaImageInfoIndex::OTA_INFO_ENTER] != nullptr) {
        otaEnter_->SetSrc(g_pv_otaimageInfo[OtaImageInfoIndex::OTA_INFO_ENTER]);
    }

    otaInterruptView->Add(otaInterrupt_);
    otaInterruptView->Add(otaEnter_);
    otaInterruptView->Add(lblInterrupt_);
    otaInterruptView->SetVisible(false);
     return otaInterruptView;
}

OHOS::UIViewGroup *TjdUiAppOtaView::InitOtaFailView() 
{
    OHOS::UIViewGroup *otaFailView = new OHOS::UIViewGroup();
    otaFailView->SetPosition(0, 0, 466, 466);

    if (otaFail_ == nullptr) {
        otaFail_ = new OHOS::UIImageView();
    }
    otaFail_->SetPosition(165, 64, 156, 172);
    otaFail_->SetViewId(BTN_OTA_FAIL_ID);
    otaFail_->SetTouchable(true);
    otaFail_->SetOnClickListener(TjdUiAppOtaPresenter::GetInstance());
    if (g_pv_otaimageInfo[OtaImageInfoIndex::OTA_INFO_FAIL] != nullptr) {
        otaFail_->SetSrc(g_pv_otaimageInfo[OtaImageInfoIndex::OTA_INFO_FAIL]);
    }

    if (lblFail_ == nullptr) {
        lblFail_ = new UILabel();
    }
    lblFail_->SetFont(TJD_VECTOR_FONT_FILENAME, 30);
    lblFail_->SetText("监测到资源不匹配，无法正常\n使用！请重新连接升级");
    lblFail_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    lblFail_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    lblFail_->SetPosition(44, 261);

    if (lblFailMac_ == nullptr) {
        lblFailMac_ = new UILabel();
    }
    lblFailMac_->SetFont(TJD_VECTOR_FONT_FILENAME, 26);
    lblFailMac_->SetText("MAC:");
    lblFailMac_->SetTextColor(Color::GetColorFromRGBA(0x6B, 0x6B, 0x6B, 0xff));
    lblFailMac_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    lblFailMac_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    lblFailMac_->SetPosition(201, 364);

    if (lblFailNum_ == nullptr) {
        lblFailNum_ = new UILabel();
    }
    lblFailNum_->SetFont(TJD_VECTOR_FONT_FILENAME, 26);
    lblFailNum_->SetText("12::34:56:78:90:12");
    lblFailNum_->SetTextColor(Color::GetColorFromRGBA(0x6B, 0x6B, 0x6B, 0xff));
    lblFailNum_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    lblFailNum_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    lblFailNum_->SetPosition(122, 398);

    otaFailView->Add(otaFail_);
    otaFailView->Add(lblFail_);
    otaFailView->Add(lblFailMac_);
    otaFailView->Add(lblFailNum_);
    otaFailView->SetVisible(false);
     return otaFailView;
}

}//TJD