#include "TjdUiAppHrView.h"
#include "TjdUiAppHrModel.h"
#include "TjdUiImageIds.h"
#include "TjdUiMultiLanguageExt.h"
#include "TjdUiUtils.h"
#include "common/image_cache_manager.h"
#include "dfx/event_injector.h"
#include "graphic_service.h"
#include "rtc_api.h"
#include "sql_fit.h"
#include "sys_config.h"
#include "wearable_log.h"
#include <stdio.h>
// #include "core/render_manager.h"
using namespace OHOS;

#define ENABLE_PRINT_INFO 1
#define DEBUG_ENABLE 0
#if ENABLE_PRINT_INFO
#define static_print_info(...) sys_ui_log_i(__VA_ARGS__)  // 一般信息打印宏控制
#define static_print_warn(...) sys_ui_log_w(__VA_ARGS__)  // 警告信息打印一般常开
#define static_print_error(...) sys_ui_log_e(__VA_ARGS__) // 错误信息打印一般常开
#if DEBUG_ENABLE
#define static_print_debug(...) sys_ui_log_d(__VA_ARGS__)
#else
#define static_print_debug(...)
#endif
#else
#define static_print_info(...)
#define static_print_warn(...)
#define static_print_error(...)
#endif

#define HR_IMAGE_BIN_PATH TJD_IMAGE_PATH "img_heartrate.bin"
#define IMAGE_RETURN_BIN_PATH TJD_IMAGE_PATH "img_return.bin"

static ImageAnimatorInfo g_imageAnimator1Info[3] = {
    {nullptr, {111, 68}, 56, 50, IMG_SRC_IMAGE_INFO},
    {nullptr, {111, 68}, 56, 50, IMG_SRC_IMAGE_INFO},
    {nullptr, {111, 68}, 56, 50, IMG_SRC_IMAGE_INFO},
};

namespace TJD {

static TjdUiAppHrView *g_pv_AppHrView = nullptr;
static struct rtc_time localTime;
HeratRateScrollPickerCallback *g_HeratRateScrollPickerCallback = nullptr;
uint8_t TjdUiAppHrView::herarRateWaitTime_ = 0;

static void FlickerTimerCallback(void *arg)
{
    GraphicService::GetInstance()->PostGraphicEvent([arg]() {
        auto hrView = TjdUiAppHrView::GetInstance();
        if (hrView == nullptr) {
            return;
        }
        UILabel *label = static_cast<UILabel *>(arg);
        if (label == nullptr) {
            return;
        }
        if (TjdUiAppHrView::herarRateWaitTime_ < 10) { //等待5s待出值稳定
            TjdUiAppHrView::herarRateWaitTime_ += 1;
            label->SetText("---");
            label->IsVisible() ? label->SetVisible(false) : label->SetVisible(true);
            return;
        }
        static_print_debug("label->GetText: %s", label->GetText());
        if (label->GetText() == std::string("---")) {
            label->IsVisible() ? label->SetVisible(false) : label->SetVisible(true);
        } else {
            hrView->flickerTimer->Stop();
            hrView->Invalidate();
        }
    });
}

bool HeratRateScrollPicker::CheckValueChanges(uint8_t value)
{

    if (value != hrValues_) {
        needsUpdate_ = true;
        directions_ = (value < hrValues_);

        label[1 + (directions_ ? -1 : 1)].SetText(std::to_string(value).c_str());
        hrValues_ = value;
        return true;
    } else {
        needsUpdate_ = false;
    }

    return false;
}
// static bool direction = true; // 0向上 1向下
void HeratRateScrollPickerCallback::Callback(OHOS::UIView *view)
{
    auto scrollPicker = dynamic_cast<HeratRateScrollPicker *>(view);
    if (!scrollPicker)
        return;

    if (!scrollPicker->needsUpdate_) {
        return;
    }
    state_ = true;
    int16_t x;
    int16_t y;

    UIView *childView = scrollPicker->GetChildrenHead();
    while (childView != nullptr) {
        bool dir = scrollPicker->directions_;
        int16_t y = childView->GetY() + (dir ? 2 : -2);
        childView->SetY(y);
        childView = childView->GetNextSibling();

        if (++cnt >= 90) {
            if (animator_)
                animator_->Stop();
            cnt = 0;
            scrollPicker->needsUpdate_ = false;
            dir ? CycleLabelsUp(view) : CycleLabelsDown(view);
            scrollPicker->ResetLabelPositions();
            state_ = false;
        }

        scrollPicker->Invalidate();
    }
}

void HeratRateScrollPickerCallback::CycleLabelsUp(OHOS::UIView *view)
{
    auto scrollPicker = dynamic_cast<HeratRateScrollPicker *>(view);
    if (!scrollPicker)
        return;

    scrollPicker->UpdateLabels();
}

void HeratRateScrollPickerCallback::CycleLabelsDown(OHOS::UIView *view)
{
    auto scrollPicker = dynamic_cast<HeratRateScrollPicker *>(view);
    if (!scrollPicker)
        return;

    scrollPicker->UpdateLabels();
}

#define FONT_SIZE 56

HeratRateScrollPicker::HeratRateScrollPicker()
{
    SetPosition(0, 0, 30, 60);
    // SetStyle(STYLE_BACKGROUND_COLOR, 0xffffffff);
    SetStyle(STYLE_BACKGROUND_OPA, 0x00);
    SetDraggable(false);

    for (size_t i = 0; i < 3; i++) {
        label[i].SetFont(TJD_DIN_MEDIUM_FONT_FILENAME, FONT_SIZE);
        label[i].SetText("0");
        // label[i].SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
        label[i].SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
        label[i].SetPosition(0, -60 + 60 * i, 30, 60);
        Add(&label[i]);
    }
}

HeratRateScrollPicker::~HeratRateScrollPicker() { RemoveAll(); }

void HeratRateScrollPicker::DateInit(uint8_t value)
{
    label[1].SetText(std::to_string(value).c_str());
    hrValues_ = value;
    preValues_ = value;
}

void HeratRateScrollPicker::UpdateLabels()
{
    label[0].SetText(std::to_string(hrValues_).c_str());
    label[1].SetText(std::to_string(hrValues_).c_str());
    label[2].SetText(std::to_string(hrValues_).c_str()); // 可预加载下一值
}

void HeratRateScrollPicker::ResetLabelPositions()
{
    label[0].SetY(-60);
    label[1].SetY(0);
    label[2].SetY(60);
}

static void DeleteViewChilden(UIViewGroup *viewGroup)
{
    if (viewGroup == nullptr) {
        return;
    }
    UIView *view = viewGroup->GetChildrenHead();
    while (view != nullptr) {
        UIView *tempView = view;
        view = view->GetNextSibling();
        if (tempView->GetParent()) {
            static_cast<UIViewGroup *>(tempView->GetParent())->Remove(tempView);
        }
        delete tempView;
        tempView = nullptr;
    }
}

void HrFlickerTimer::Start()
{
    if (!label_)
        return;
    label_->SetText("---");
    auto hrView = TjdUiAppHrView::GetInstance();
    OHOS::GraphicTimer::Start();
    TjdUiAppHrView::GetInstance()->SetScrollPickerVisible(false);
    uint8_t value = TjdUiAppHrModel::GetInstance().GetHrCurValue();
    hrView->ScrollPickerDataInit(value);
}
void HrFlickerTimer::Stop()
{
    if (!label_)
        return;
    if (label_->IsVisible())
        label_->SetVisible(false);
    OHOS::GraphicTimer::Stop();
}

bool HrOnClickedListener::OnClick(OHOS::UIView &view, const OHOS::ClickEvent &event)
{
    if (view.GetViewId() == "imageAbout") {
        TjdUiAppHrPresenter::GetInstance()->TimeTaskStop();
        TjdUiAppHrView::GetInstance()->ChangedView(HR_ABOUT_VIEW, HR_SWIPE_VIEW);
    } else if (view.GetViewId() == "aboutImgReturn") {
        TjdUiAppHrPresenter::GetInstance()->TimeTaskStart();
        TjdUiAppHrView::GetInstance()->ChangedView(HR_SWIPE_VIEW, HR_ABOUT_VIEW);
    } else if (view.GetViewId() == "unwearImgReturn") {
        TjdUiAppHrPresenter::GetInstance()->TimeTaskStart();
        TjdUiAppHrView::GetInstance()->ChangedView(HR_SWIPE_VIEW, HR_UNWEAR_VIEW);
    }
    return true;
}

TjdUiAppHrView::TjdUiAppHrView()
{
    static_print_info("TjdUiAppHrView::construct...");
    g_pv_AppHrView = this;
}
TjdUiAppHrView *TjdUiAppHrView::GetInstance(void) { return g_pv_AppHrView; }
TjdUiAppHrView::~TjdUiAppHrView()
{
    static_print_info("~TjdUiAppHrView::destruct...");
    g_pv_AppHrView = nullptr;

    if (leftCallback_ != nullptr) {
        delete leftCallback_;
        leftCallback_ = nullptr;
    }

    if (leftAnimator_ != nullptr) {
        leftAnimator_->Stop();
        delete leftAnimator_;
        leftAnimator_ = nullptr;
    }

    if (midCallback_ != nullptr) {
        delete midCallback_;
        midCallback_ = nullptr;
    }

    if (midAnimator_ != nullptr) {
        midAnimator_->Stop();
        delete midAnimator_;
        midAnimator_ = nullptr;
    }

    if (rightCallback_ != nullptr) {
        delete rightCallback_;
        rightCallback_ = nullptr;
    }

    if (rightAnimator_ != nullptr) {
        rightAnimator_->Stop();
        delete rightAnimator_;
        rightAnimator_ = nullptr;
    }

    if (dataSerial_ != nullptr) {
        uiChart1_->DeleteDataSerial(dataSerial_);
        delete dataSerial_;
        dataSerial_ = nullptr;
    }
    if (uiChart1_ != nullptr) {
        static_cast<UIViewGroup *>(uiChart1_->GetParent())->Remove(uiChart1_);
        delete uiChart1_;
        uiChart1_ = nullptr;
    }
    if (flickerTimer) {
        flickerTimer->Stop();
        delete flickerTimer;
        flickerTimer = nullptr;
    }

    if (containerAll_) {
        containerAll_->RemoveAll();
        delete containerAll_;
        containerAll_ = nullptr;
    }
    if (swipeContainer_) {
        swipeContainer_->RemoveAll();
        delete swipeContainer_;
        swipeContainer_ = nullptr;
    }
    if (container1_) {
        DeleteViewChilden(container1_);
        delete container1_;
        container1_ = nullptr;
    }
    if (container2_) {
        DeleteViewChilden(container2_);
        delete container2_;
        container2_ = nullptr;
    }
    if (AboutView_) {
        DeleteViewChilden(AboutView_);
        delete AboutView_;
        AboutView_ = nullptr;
    }
    if (UnwearView_) {
        DeleteViewChilden(UnwearView_);
        delete UnwearView_;
        UnwearView_ = nullptr;
    }

    if (aboutImageLister) {
        delete aboutImageLister;
        aboutImageLister = nullptr;
    }
    if (unwearImageLister) {
        delete unwearImageLister;
        unwearImageLister = nullptr;
    }
    if (swipe1ImageLister) {
        delete swipe1ImageLister;
        swipe1ImageLister = nullptr;
    }

    ImageCacheManager::GetInstance().UnloadAllInMultiRes(HR_IMAGE_BIN_PATH);
    ImageCacheManager::GetInstance().UnloadAllInMultiRes(IMAGE_RETURN_BIN_PATH);
}

void TjdUiAppHrView::OnStart()
{
    static_print_info("TjdUiAppHrView::OnStart...");
    // printf("fps: %lf\n",RenderManager::GetInstance().GetFPS());
    InitImageInfo();
    TjdUiAppHrModel::GetInstance().InitWeekHrViewInfo();
    TjdUiAppHrModel::GetInstance().HrPointArrayInit();
    presenter_->SetHrPointArray(TjdUiAppHrModel::GetInstance().GetHrArray());

    if (onSwipeListener_ == nullptr) {
        onSwipeListener_ = static_cast<UISwipeView::OnSwipeListener *>(TjdUiAppHrPresenter::GetInstance());
    }
    if (OnDragListener_ == nullptr) {
        OnDragListener_ = static_cast<UIView::OnDragListener *>(TjdUiAppHrPresenter::GetInstance());
    }

    if (swipeContainer_ == nullptr) {
        swipeContainer_ = new UISwipeViewNested(UISwipeView::VERTICAL);
        swipeContainer_->SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
        swipeContainer_->SetViewId(HR_SWIPEVIEW_ID);
        swipeContainer_->SetStyle(STYLE_BACKGROUND_OPA, 0);
        swipeContainer_->SetOnSwipeListener(onSwipeListener_);
        if (OHOS::PageTransitionMgr::GetInstance().GetTopSlideBackImage() == nullptr) {
            swipeContainer_->SetOnDragListener(OnDragListener_);
        }
    }

    if (containerAll_ == nullptr) {
        containerAll_ = new UIViewGroup();
        containerAll_->SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    }

    Container1Init();
    Container2Init();
    AboutViewInit();
    UnwearViewInit();

    groupList_[HrView::HR_SWIPE_VIEW] = swipeContainer_;
    groupList_[HrView::HR_ABOUT_VIEW] = AboutView_;
    groupList_[HrView::HR_UNWEAR_VIEW] = UnwearView_;

    for (int i = 0; i < HRMAX_VIEW; i++) {
        if (groupList_[i] != nullptr) {
            containerAll_->Add(groupList_[i]);
        }
    }
    curView = HR_SWIPE_VIEW;

    AddViewToRootContainer(containerAll_);
    GetRootContainer()->SetViewId("TjdHeartRateView");

    flickerTimer = new HrFlickerTimer(200, FlickerTimerCallback, (void *)hrCurValue_, true);
}

void TjdUiAppHrView::OnStop()
{
    static_print_info("TjdUiAppHrView::OnStop...");
    TjdUiAppHrPresenter::GetInstance()->TimeTaskStop();
}

void TjdUiAppHrView::InitImageInfo(void)
{
    ImageInfo *imgInfo =
        ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_HEARTRATE_HR_DT_01_03, HR_IMAGE_BIN_PATH);
    g_imageAnimator1Info[0].imageInfo = imgInfo;
    imgInfo = ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_HEARTRATE_HR_DT_02_03, HR_IMAGE_BIN_PATH);
    g_imageAnimator1Info[1].imageInfo = imgInfo;
    imgInfo = ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_HEARTRATE_HR_DT_03_03, HR_IMAGE_BIN_PATH);
    g_imageAnimator1Info[2].imageInfo = imgInfo;
}

void TjdUiAppHrView::Container1Init(void)
{
    if (container1_ == nullptr) {
        container1_ = new UIViewGroup();
        container1_->SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
        container1_->SetViewId("container1_");
        container1_->SetStyle(STYLE_BACKGROUND_OPA, 0);
    }

    /*-----------------------------Add dataSerial_ to App------------------------------*/
    if (dataSerial_ == nullptr) {
        dataSerial_ = new UIChartDataSerial();
    }
    dataSerial_->SetMaxDataCount(288);
    Point *hrPointArray = TjdUiAppHrPresenter::GetInstance()->GetHrPointArray();
    dataSerial_->AddPoints(hrPointArray, 288); // 5: number of data points
    dataSerial_->SetLineColor(Color::Red());
    dataSerial_->SetFillColor(Color::Red());
    dataSerial_->EnableGradient(true);
    dataSerial_->EnableSmooth(true);

    /*-----------------------------Add uiChart1_ to App------------------------------*/
    if (uiChart1_ == nullptr) {
        uiChart1_ = new UIChartPolyline();
    }
    uiChart1_->SetPosition(30, 147);
    uiChart1_->Resize(365, 155);
    uiChart1_->SetViewId("uiChart1");
    uiChart1_->SetStyle(STYLE_BACKGROUND_OPA, 0x00);
    UIXAxis &xAxis = uiChart1_->GetXAxis();
    UIYAxis &yAxis = uiChart1_->GetYAxis();
    xAxis.SetMarkNum(5);        // 5: number of scales
    xAxis.SetDataRange(0, 288); // 0: minimum value, 5: maximum value
    yAxis.SetDataRange(0, 200); // 0: minimum value, 3500: maximum value
    xAxis.SetVisible(false);
    yAxis.SetVisible(false);
    uiChart1_->SetGradientOpacity(25, 127); // 25: min opacity, 127: max opacity
    uiChart1_->AddDataSerial(dataSerial_);
    container1_->Add(uiChart1_);
    uiChart1_->SetVisible(true);

    /*-----------------------------Add image1_ to App------------------------------*/
    if (image1_ == nullptr) {
        image1_ = new UIImageView();
    }
    image1_->SetPosition(30, 137);
    image1_->SetViewId("image1");
    ImageInfo *imgInfo =
        ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_HEARTRATE_CHART_TIME, HR_IMAGE_BIN_PATH);
    if (imgInfo == nullptr) {
        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "load image error\n");
        return;
    }
    image1_->SetSrc(imgInfo);
    container1_->Add(image1_);

    /*-----------------------------Add image2_ to App------------------------------*/
    if (image2_ == nullptr) {
        image2_ = new UIImageView();
    }
    image2_->SetPosition(108, 376);
    image2_->SetViewId("image2");
    imgInfo = ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_HEARTRATE_HIGH, HR_IMAGE_BIN_PATH);
    image2_->SetSrc(imgInfo);
    container1_->Add(image2_);
    image2_->SetVisible(true);

    /*-----------------------------Add image3_ to App------------------------------*/
    if (image3_ == nullptr) {
        image3_ = new UIImageView();
    }
    image3_->SetPosition(264, 376);
    image3_->SetViewId("image3");
    imgInfo = ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_HEARTRATE_LOW, HR_IMAGE_BIN_PATH);
    image3_->SetSrc(imgInfo);
    container1_->Add(image3_);
    image3_->SetVisible(true);

    /*-----------------------------Add image4_ to App------------------------------*/
    if (image4_ == nullptr) {
        image4_ = new UIImageView();
    }
    image4_->SetPosition(214, 430);
    image4_->SetViewId("image4");
    imgInfo = ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_HEARTRATE_PULL_UP, HR_IMAGE_BIN_PATH);
    image4_->SetSrc(imgInfo);
    container1_->Add(image4_);
    image4_->SetVisible(true);

    /*-----------------------------Add imageAbout_ to App------------------------------*/
    if (imageAbout_ == nullptr) {
        imageAbout_ = new UIImageView();
    }
    imageAbout_->SetPosition(213 - 12, 0);
    imageAbout_->SetViewId("imageAbout");
    imgInfo = ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_HEARTRATE_ABOUT, HR_IMAGE_BIN_PATH);
    imageAbout_->SetSrc(imgInfo);
    imageAbout_->SetStyle(STYLE_BORDER_WIDTH, 12);
    imageAbout_->SetStyle(STYLE_BORDER_COLOR, 0xff000000);
    imageAbout_->SetTouchable(true);
    swipe1ImageLister = new HrOnClickedListener();
    imageAbout_->SetOnClickListener(swipe1ImageLister);
    container1_->Add(imageAbout_);
    imageAbout_->SetVisible(true);

    /*-----------------------------Add label1Num200_ to App------------------------------*/
    if (label1Num200_ == nullptr) {
        label1Num200_ = new UILabel();
    }
    label1Num200_->SetPosition(405, 137);
    label1Num200_->SetViewId("label1Num200");
    label1Num200_->SetText("200");
    label1Num200_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    label1Num200_->SetTextColor(Color::GetColorFromRGBA(0x6B, 0x6B, 0x6B, 0xff));
    label1Num200_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    label1Num200_->SetFont(TJD_VECTOR_FONT_FILENAME, TJD_FONT_SIZE_24);
    container1_->Add(label1Num200_);
    label1Num200_->SetVisible(true);

    /*-----------------------------Add label1Num150_ to App------------------------------*/
    if (label1Num150_ == nullptr) {
        label1Num150_ = new UILabel();
    }
    label1Num150_->SetPosition(405, 177);
    label1Num150_->SetViewId("label1Num150");
    label1Num150_->SetText("150");
    label1Num150_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    label1Num150_->SetTextColor(Color::GetColorFromRGBA(0x6B, 0x6B, 0x6B, 0xff));
    label1Num150_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    label1Num150_->SetFont(TJD_VECTOR_FONT_FILENAME, TJD_FONT_SIZE_24);
    container1_->Add(label1Num150_);
    label1Num150_->SetVisible(true);

    /*-----------------------------Add label1Num100_ to App------------------------------*/
    if (label1Num100_ == nullptr) {
        label1Num100_ = new UILabel();
    }
    label1Num100_->SetPosition(405, 216);
    label1Num100_->SetViewId("label1Num100");
    label1Num100_->SetText("100");
    label1Num100_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    label1Num100_->SetTextColor(Color::GetColorFromRGBA(0x6B, 0x6B, 0x6B, 0xff));
    label1Num100_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    label1Num100_->SetFont(TJD_VECTOR_FONT_FILENAME, TJD_FONT_SIZE_24);
    container1_->Add(label1Num100_);
    label1Num100_->SetVisible(true);

    /*-----------------------------Add label1Num50_ to App------------------------------*/
    if (label1Num50_ == nullptr) {
        label1Num50_ = new UILabel();
    }
    label1Num50_->SetPosition(405, 256);
    label1Num50_->SetViewId("label1Num50");
    label1Num50_->SetText("50");
    label1Num50_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    label1Num50_->SetTextColor(Color::GetColorFromRGBA(0x6B, 0x6B, 0x6B, 0xff));
    label1Num50_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    label1Num50_->SetFont(TJD_VECTOR_FONT_FILENAME, TJD_FONT_SIZE_24);
    container1_->Add(label1Num50_);
    label1Num50_->SetVisible(true);

    /*-----------------------------Add hrMax_ to App------------------------------*/
    if (hrMax_ == nullptr) {
        hrMax_ = new UILabel();
    }
    hrMax_->SetPosition(146, 360);
    hrMax_->SetViewId("hrMax");
    tjd_driver_rtc_get_ops()->get_rtc_time(&localTime);
    uint8_t max = sql_fit_get_hr_max(localTime.tm_wday);
    if (max == 0) {
        hrMax_->SetText("---");
    } else {
        hrMax_->SetText(std::to_string(max).c_str());
    }
    hrMax_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    hrMax_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    hrMax_->SetFont(TJD_VECTOR_FONT_FILENAME, 40);
    container1_->Add(hrMax_);
    hrMax_->SetVisible(true);

    /*-----------------------------Add hrMin_ to App------------------------------*/
    if (hrMin_ == nullptr) {
        hrMin_ = new UILabel();
    }
    hrMin_->SetPosition(300, 360);
    hrMin_->SetViewId("hrMin");
    uint8_t min = sql_fit_get_hr_min(localTime.tm_wday);
    if (min == 0 || min == 255) {
        hrMin_->SetText("---");
    } else {
        hrMin_->SetText(std::to_string(min).c_str());
    }
    hrMin_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    hrMin_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    hrMin_->SetFont(TJD_VECTOR_FONT_FILENAME, 40);
    container1_->Add(hrMin_);
    hrMin_->SetVisible(true);

    /*-----------------------------Add hrUnit_ to App------------------------------*/
    if (hrUnit_ == nullptr) {
        hrUnit_ = new UILabelExt();
    }
    hrUnit_->SetPosition(298, 74);
    hrUnit_->SetViewId("hrUnit");
    // hrUnit_->SetText("次/分");
    hrUnit_->SetTextId(STR_ID_110);
    hrUnit_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    hrUnit_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    hrUnit_->SetFont(TJD_VECTOR_FONT_FILENAME, 28);
    container1_->Add(hrUnit_);
    hrUnit_->SetVisible(true);

    /*-----------------------------Add hrCurValue_ to App------------------------------*/
    if (hrCurValue_ == nullptr) {
        hrCurValue_ = new UILabel();
    }
    hrCurValue_->SetPosition(194, 50);
    hrCurValue_->SetViewId("hrCur");
    hrCurValue_->SetText("---");
    hrCurValue_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    hrCurValue_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    hrCurValue_->SetFont(TJD_VECTOR_FONT_FILENAME, 56);
    container1_->Add(hrCurValue_);
    hrCurValue_->SetVisible(true);

    leftScrollPicker = new HeratRateScrollPicker();
    leftScrollPicker->SetPosition(194, 50);
    leftScrollPicker->SetVisible(false);
    container1_->Add(leftScrollPicker);
    leftCallback_ = new HeratRateScrollPickerCallback();
    leftAnimator_ = new OHOS::Animator(leftCallback_, leftScrollPicker, 1000, true);
    leftCallback_->SetAnimator(leftAnimator_);

    midScrollPicker = new HeratRateScrollPicker();
    midScrollPicker->SetPosition(194 + 30, 50);
    midScrollPicker->SetVisible(false);
    container1_->Add(midScrollPicker);
    midCallback_ = new HeratRateScrollPickerCallback();
    midAnimator_ = new OHOS::Animator(midCallback_, midScrollPicker, 1000, true);
    midCallback_->SetAnimator(midAnimator_);

    rightScrollPicker = new HeratRateScrollPicker();
    rightScrollPicker->SetPosition(194 + 60, 50);
    rightScrollPicker->SetVisible(false);
    container1_->Add(rightScrollPicker);
    rightCallback_ = new HeratRateScrollPickerCallback();
    rightAnimator_ = new OHOS::Animator(rightCallback_, rightScrollPicker, 1000, true);
    rightCallback_->SetAnimator(rightAnimator_);

    /*-----------------------------Add imageAnimator1_ to App------------------------------*/
    if (imageAnimator1_ == nullptr) {
        imageAnimator1_ = new UIImageAnimatorView();
    }
    imageAnimator1_->SetPosition(111, 62);
    imageAnimator1_->SetViewId("imageAnimator1");
    imageAnimator1_->SetStyle(STYLE_BACKGROUND_COLOR, 0xffffffff);
    imageAnimator1_->SetStyle(STYLE_BACKGROUND_OPA, 0);

    imageAnimator1_->SetImageAnimatorSrc(g_imageAnimator1Info, 3, 200);
    imageAnimator1_->SetTimeOfPause(200);
    imageAnimator1_->SetReverse(false);
    imageAnimator1_->SetTouchable(true);

    container1_->Add(imageAnimator1_);
    imageAnimator1_->SetVisible(true);

    swipeContainer_->Add(container1_);
}

void TjdUiAppHrView::Container2Init(void)
{
    if (container2_ == nullptr) {
        container2_ = new UIViewGroup();
        container2_->SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
        container2_->SetViewId("container2_");
        container2_->SetStyle(STYLE_BACKGROUND_OPA, 0);
    }

    /*-----------------------------Add image5_ to Container2_------------------------------*/
    if (image5_ == nullptr) {
        image5_ = new UIImageView();
    }
    image5_->SetPosition(214, 22);
    image5_->SetViewId("image5");
    ImageInfo *imgInfo = ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_HEARTRATE_PULL_DOWN, HR_IMAGE_BIN_PATH);
    image5_->SetSrc(imgInfo);
    container2_->Add(image5_);

    /*-----------------------------Add image6_ to Container2_------------------------------*/
    if (image6_ == nullptr) {
        image6_ = new UIImageView();
    }
    image6_->SetPosition(30, 137);
    image6_->SetViewId("image6");
    imgInfo = ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_HEARTRATE_CHART_WEEK, HR_IMAGE_BIN_PATH);
    image6_->SetSrc(imgInfo);
    container2_->Add(image6_);

    /*-----------------------------Add hrText1_ to container2_------------------------------*/
    if (hrText1_ == nullptr) {
        hrText1_ = new UILabelExt();
    }
    hrText1_->SetPosition(165, 70);
    hrText1_->SetViewId("hrText1");
    hrText1_->SetTextId(STR_ID_111);
    // hrText1_->SetText("平均心率");
    hrText1_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    hrText1_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    hrText1_->SetFont(TJD_VECTOR_FONT_FILENAME, 34);
    container2_->Add(hrText1_);
    hrText1_->SetVisible(true);

    /*-----------------------------Add hrText2_ to container2_------------------------------*/
    if (hrText2_ == nullptr) {
        hrText2_ = new UILabelExt();
    }
    hrText2_->SetPosition(0, 375, 466, 37);
    hrText2_->SetViewId("hrText2");
    hrText2_->SetTextId(STR_ID_112);
    // hrText2_->SetText("近7天数据显示");
    // hrText2_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    hrText2_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    hrText2_->SetFont(TJD_VECTOR_FONT_FILENAME, 28);
    // printf("height = %d\n", hrText2_->GetHeight());
    container2_->Add(hrText2_);
    hrText2_->SetVisible(true);

    /*-----------------------------Add label2Num200_ to container2_------------------------------*/
    if (label2Num200_ == nullptr) {
        label2Num200_ = new UILabel();
    }
    label2Num200_->SetPosition(405, 137);
    label2Num200_->SetViewId("label2Num200");
    label2Num200_->SetText("200");
    label2Num200_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    label2Num200_->SetTextColor(Color::GetColorFromRGBA(0x6B, 0x6B, 0x6B, 0xff));
    label2Num200_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    label2Num200_->SetFont(TJD_VECTOR_FONT_FILENAME, TJD_FONT_SIZE_24);
    container2_->Add(label2Num200_);
    label2Num200_->SetVisible(true);

    /*-----------------------------Add label2Num150_ to container2_------------------------------*/
    if (label2Num150_ == nullptr) {
        label2Num150_ = new UILabel();
    }
    label2Num150_->SetPosition(405, 177);
    label2Num150_->SetViewId("label2Num150");
    label2Num150_->SetText("150");
    label2Num150_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    label2Num150_->SetTextColor(Color::GetColorFromRGBA(0x6B, 0x6B, 0x6B, 0xff));
    label2Num150_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    label2Num150_->SetFont(TJD_VECTOR_FONT_FILENAME, TJD_FONT_SIZE_24);
    container2_->Add(label2Num150_);
    label2Num150_->SetVisible(true);

    /*-----------------------------Add label2Num100_ to container2_------------------------------*/
    if (label2Num100_ == nullptr) {
        label2Num100_ = new UILabel();
    }
    label2Num100_->SetPosition(405, 216);
    label2Num100_->SetViewId("label2Num100");
    label2Num100_->SetText("100");
    label2Num100_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    label2Num100_->SetTextColor(Color::GetColorFromRGBA(0x6B, 0x6B, 0x6B, 0xff));
    label2Num100_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    label2Num100_->SetFont(TJD_VECTOR_FONT_FILENAME, TJD_FONT_SIZE_24);
    container2_->Add(label2Num100_);
    label2Num100_->SetVisible(true);

    /*-----------------------------Add label2Num50_ to container2_------------------------------*/
    if (label2Num50_ == nullptr) {
        label2Num50_ = new UILabel();
    }
    label2Num50_->SetPosition(405, 256);
    label2Num50_->SetViewId("label2Num50");
    label2Num50_->SetText("50");
    label2Num50_->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    label2Num50_->SetTextColor(Color::GetColorFromRGBA(0x6B, 0x6B, 0x6B, 0xff));
    label2Num50_->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    label2Num50_->SetFont(TJD_VECTOR_FONT_FILENAME, TJD_FONT_SIZE_24);
    container2_->Add(label2Num50_);
    label2Num50_->SetVisible(true);

    /*-----------------------------Add rodViewGroup[7] to container2_------------------------------*/
    for (int i = 0; i < 7; i++) {
        rodViewGroup[i] = new UIView();
        if (i == 0) {
            rodViewGroup[i]->SetPosition(46 + (6 * 54), TjdUiAppHrModel::GetInstance().GetWeekHrViewHigh()[i]);
            rodViewGroup[i]->Resize(15, TjdUiAppHrModel::GetInstance().GetWeekHrViewLow()[i]);
        } else {
            rodViewGroup[i]->SetPosition(46 + ((i - 1) * 54), TjdUiAppHrModel::GetInstance().GetWeekHrViewHigh()[i]);
            rodViewGroup[i]->Resize(15, TjdUiAppHrModel::GetInstance().GetWeekHrViewLow()[i]);
        }

        rodViewGroup[i]->Resize(15, TjdUiAppHrModel::GetInstance().GetWeekHrViewLow()[i]);
        rodViewGroup[i]->SetStyle(STYLE_BORDER_RADIUS, 30);
        rodViewGroup[i]->SetStyle(STYLE_BACKGROUND_COLOR, 0xffff0000);
        container2_->Add(rodViewGroup[i]);
    }

    swipeContainer_->Add(container2_);
}

void TjdUiAppHrView::UpdateRodViewGroup(void)
{
    for (int i = 0; i < 7; i++) {
        if (i == 0) {
            rodViewGroup[i]->SetPosition(46 + (6 * 54), TjdUiAppHrModel::GetInstance().GetWeekHrViewHigh()[i]);
            rodViewGroup[i]->Resize(15, TjdUiAppHrModel::GetInstance().GetWeekHrViewLow()[i]);
        } else {
            rodViewGroup[i]->SetPosition(46 + ((i - 1) * 54), TjdUiAppHrModel::GetInstance().GetWeekHrViewHigh()[i]);
            rodViewGroup[i]->Resize(15, TjdUiAppHrModel::GetInstance().GetWeekHrViewLow()[i]);
        }

        rodViewGroup[i]->Invalidate();
    }
}

void TjdUiAppHrView::AboutViewInit(void)
{
    if (AboutView_ == nullptr) {
        AboutView_ = new UIViewGroup();
        AboutView_->SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
        AboutView_->SetVisible(false);
        AboutView_->SetStyle(STYLE_BACKGROUND_OPA, 0);
    }

    /*-----------------------------Add aboutText to AboutView_------------------------------*/
    if (aboutText == nullptr) {
        aboutText = new UILabelExt();
    }
    aboutText->SetViewId("aboutText");
    aboutText->SetTextId(STR_ID_115);
    // aboutText->SetText("手表仅显示5分钟内最新的心率数据，更多数据请前往APP连接后查看");
    aboutText->SetLineBreakMode(UILabel::LINE_BREAK_WRAP);
    aboutText->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    aboutText->SetFont(TJD_VECTOR_FONT_FILENAME, 34);
    if (TjdUiMultiLanguageExt::GetCurrentLanguage() == LANGUAGE_ID_CHS)
        aboutText->SetPosition(31, 152, 405, 128);
    else
        aboutText->SetPosition(31, 86, 405, 128);

    /*-----------------------------Add aboutImg to AboutView_------------------------------*/
    if (aboutImg == nullptr) {
        aboutImg = new UIImageView();
    }
    aboutImg->SetPosition(187, 352);
    aboutImg->SetViewId("aboutImgReturn");
    ImageInfo *imgInfo =
        ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_RETURN_IMG_RETURN, IMAGE_RETURN_BIN_PATH);
    if (imgInfo != nullptr) {
        aboutImg->SetSrc(imgInfo);
    }
    aboutImg->SetTouchable(true);
    aboutImageLister = new HrOnClickedListener();
    aboutImg->SetOnClickListener(aboutImageLister);

    AboutView_->Add(aboutText);
    AboutView_->Add(aboutImg);
}

void TjdUiAppHrView::UnwearViewInit(void)
{
    if (UnwearView_ == nullptr) {
        UnwearView_ = new UIViewGroup();
        UnwearView_->SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
        UnwearView_->SetVisible(false);
        UnwearView_->SetStyle(STYLE_BACKGROUND_OPA, 0);
    }

    /*-----------------------------Add unwearText1 to UnwearView_------------------------------*/
    if (unwearText1 == nullptr) {
        unwearText1 = new UILabelExt();
    }
    unwearText1->SetPosition(151, 224);
    unwearText1->SetViewId("unwearText1");
    // unwearText1->SetText("监测到脱腕");
    unwearText1->SetTextId(STR_ID_113);
    unwearText1->SetLineBreakMode(UILabel::LINE_BREAK_ADAPT);
    unwearText1->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    unwearText1->SetFont(TJD_VECTOR_FONT_FILENAME, 36);
    TjdUiUtils::AutoAlignHorizontalCenter(*unwearText1);
    /*-----------------------------Add unwearText2 to UnwearView_------------------------------*/
    if (unwearText2 == nullptr) {
        unwearText2 = new UILabelExt();
    }
    unwearText2->SetPosition(0, 272, 466, 47);
    unwearText2->SetViewId("unwearText2");
    unwearText2->SetTextId(STR_ID_114);
    // unwearText2->SetText("请偏紧佩戴手表测量！");
    unwearText2->SetLineBreakMode(UILabel::LINE_BREAK_MARQUEE);
    unwearText2->SetRollSpeed(30);
    unwearText2->SetAlign(TEXT_ALIGNMENT_CENTER, TEXT_ALIGNMENT_CENTER);
    unwearText2->SetFont(TJD_VECTOR_FONT_FILENAME, 36);
    unwearText2->SetStyle(STYLE_TEXT_OPA, 0xff * 0.3);
    TjdUiUtils::AutoAlignHorizontalCenter(*unwearText2);

    /*-----------------------------Add unwearImg1 to UnwearView_------------------------------*/
    if (unwearImg1 == nullptr) {
        unwearImg1 = new UIImageView();
    }
    unwearImg1->SetPosition(187, 352);
    unwearImg1->SetViewId("unwearImgReturn");
    ImageInfo *imgInfo =
        ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_RETURN_IMG_RETURN, IMAGE_RETURN_BIN_PATH);
    if (imgInfo != nullptr) {
        unwearImg1->SetSrc(imgInfo);
    }
    unwearImg1->SetTouchable(true);
    unwearImageLister = new HrOnClickedListener();
    unwearImg1->SetOnClickListener(unwearImageLister);

    /*-----------------------------Add unwearImg2 to UnwearView_------------------------------*/
    if (unwearImg2 == nullptr) {
        unwearImg2 = new UIImageView();
    }
    unwearImg2->SetPosition(155, 119);
    unwearImg2->SetViewId("unwearImg2");
    imgInfo = ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_HEARTRATE_REMIND, HR_IMAGE_BIN_PATH);
    if (imgInfo != nullptr) {
        unwearImg2->SetSrc(imgInfo);
    }

    UnwearView_->Add(unwearText1);
    UnwearView_->Add(unwearText2);
    UnwearView_->Add(unwearImg1);
    UnwearView_->Add(unwearImg2);
}

void TjdUiAppHrView::ChangedView(HrView view, HrView hideView)
{
    if (view >= HRMAX_VIEW) {
        return;
    }
    if (viewMapper_[view] == nullptr) {
        return;
    }

    (GetInstance()->*viewMapper_[view])(hideView);
}

bool TjdUiAppHrView::ShowSwipeView(HrView hideView)
{
    if (groupList_[hideView] == nullptr) {
        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "groupList_ is nullptr");
        return false;
    }
    groupList_[hideView]->SetVisible(false);

    if (swipeContainer_) {
        swipeContainer_->RequestFocus();
        swipeContainer_->SetRotateFactor(1.0);
    }

    if (groupList_[HrView::HR_SWIPE_VIEW] == nullptr) {
        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "groupList_ is nullptr");
        return false;
    }
    groupList_[HrView::HR_SWIPE_VIEW]->SetVisible(true);
    groupList_[HrView::HR_SWIPE_VIEW]->Invalidate();

    curView = HR_SWIPE_VIEW;
    return true;
}

bool TjdUiAppHrView::ShowAboutView(HrView hideView)
{
    if (groupList_[hideView] == nullptr) {
        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "groupList_ is nullptr");
        return false;
    }
    groupList_[hideView]->SetVisible(false);

    if (hideView == HR_SWIPE_VIEW && swipeContainer_) {
        swipeContainer_->ClearFocus();
    }

    if (groupList_[HrView::HR_ABOUT_VIEW] == nullptr) {
        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "groupList_ is nullptr");
        return false;
    }
    groupList_[HrView::HR_ABOUT_VIEW]->SetVisible(true);
    groupList_[HrView::HR_ABOUT_VIEW]->Invalidate();

    curView = HR_ABOUT_VIEW;
    return true;
}

bool TjdUiAppHrView::ShowUnwearView(HrView hideView)
{
    if (groupList_[hideView] == nullptr) {
        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "groupList_ is nullptr");
        return false;
    }
    groupList_[hideView]->SetVisible(false);

    if (hideView == HR_SWIPE_VIEW && swipeContainer_) {
        swipeContainer_->ClearFocus();
    }

    if (groupList_[HrView::HR_UNWEAR_VIEW] == nullptr) {
        WEARABLE_LOGE(WEARABLE_LOG_MODULE_APP, "groupList_ is nullptr");
        return false;
    }
    groupList_[HrView::HR_UNWEAR_VIEW]->SetVisible(true);
    groupList_[HrView::HR_UNWEAR_VIEW]->Invalidate();

    curView = HR_UNWEAR_VIEW;
    return true;
}

void TjdUiAppHrView::UpdateHrViewData(uint32_t index, uint8_t hrValue)
{
    Point curPoint = {index, hrValue};
    if (hrValue == 0) {
        SetScrollPickerVisible(false);
        hrCurValue_->SetText("---");
    } else {
        hrCurValue_->SetVisible(false);
        SetScrollPickerVisible(true);
        hrCurValue_->SetText(std::to_string(hrValue).c_str());
        if (!leftCallback_->GetState()) {
            uint8_t leftValue = hrValue / 100;
            if (leftScrollPicker->CheckValueChanges(leftValue)) {
                leftAnimator_->Start();
            }
        }

        if (!midCallback_->GetState()) {
            uint8_t midValue = hrValue / 10 % 10;
            if (midScrollPicker->CheckValueChanges(midValue)) {
                midAnimator_->Start();
            }
        }

        if (!rightCallback_->GetState()) {
            uint8_t rightValue = hrValue % 10;
            if (rightScrollPicker->CheckValueChanges(rightValue)) {
                rightAnimator_->Start();
            }

            rightAnimator_->Start();
        }

        dataSerial_->ModifyPoint(index, curPoint);
        uiChart1_->RefreshChart();
        // }

        if (hrMax_->GetText() != std::string("---")) {
            if (hrValue > std::stoi(hrMax_->GetText())) {
                hrMax_->SetText(std::to_string(hrValue).c_str());
                hrMax_->Invalidate();
            }
        } else {
            hrMax_->SetText(std::to_string(hrValue).c_str());
            hrMax_->Invalidate();
        }

        if (hrMin_->GetText() != std::string("---")) {
            if (hrValue < std::stoi(hrMin_->GetText())) {
                hrMin_->SetText(std::to_string(hrValue).c_str());
                hrMin_->Invalidate();
            }
        } else {
            hrMin_->SetText(std::to_string(hrValue).c_str());
            hrMin_->Invalidate();
        }
    }
}

UIImageAnimatorView *TjdUiAppHrView::GetAnimatorView(void) { return imageAnimator1_; }

void TjdUiAppHrView::InitViewData(void) {}

} // namespace TJD