#include "TjdUiAppLefunAiView.h"
#include "TjdUiAppLefunAiModel.h"
#include "TjdUiImageIds.h"
#include "TjdUiMemManage.h"
#include "TjdUiMultiLanguageExt.h"
#include "animator/animator_manager.h"
#include "common/image_cache_manager.h"
#include "graphic_service.h"
#include "sys_config.h"

namespace TJD {

#define ENABLE_PRINT_INFO 1
#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__) // 错误信息打印一般常开
#define static_print_debug(...) sys_ui_log_d(__VA_ARGS__) // 调试信息打印一般常开
#else
#define static_print_info(...)
#define static_print_warn(...)
#define static_print_error(...)
#define static_print_debug(...)
#endif

using namespace OHOS;

osThreadId_t resend_audio_data_id = nullptr;
static OHOS::GraphicTimer *waitTimer_ = nullptr;
#define IMAGE_BIN_PATH TJD_IMAGE_PATH "img_lefun_ai.bin"
#define LOADING_IMAGE_BIN_PATH TJD_IMAGE_PATH "img_loading.bin"
TjdUiAppLefunAiView *g_pv_LefunAiView = nullptr;
LefunAiAnswerView *g_pv_LefunAiAnswerView = nullptr;
static LefunAiRecordingView *g_LefunAiRecordingView = nullptr;
LefunAiView TjdUiAppLefunAiView::currentViewIndex_ = LEFUN_AI_VIEW_COUNT;
static LefunAiAnalysisView *g_LefunAiAnalysisView = nullptr;
// clang-format off

static inline int16_t HorizontalCenter(int16_t width, int16_t parentWidth) { return (parentWidth - width) / 2; }

static inline int16_t VerticalCenter(int16_t height, int16_t parentHeight) { return (parentHeight - height) / 2; }

static inline void InitLabel(OHOS::UILabel &label, uint8_t size, int16_t x, int16_t y, const char *text)
{
    label.SetFont(TJD_VECTOR_FONT_FILENAME, size);
    label.SetText(text);
    label.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    label.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    label.SetPosition(x, y);
}

static inline void InitLabelHorCenter(OHOS::UILabel &label, uint8_t size, int16_t y, int16_t target, const char *text)
{
    label.SetFont(TJD_VECTOR_FONT_FILENAME, size);
    label.SetText(text);
    label.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    label.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    label.SetPosition(HorizontalCenter(label.GetWidth(), target), y);
}

static inline void InitLabelVerCenter(OHOS::UILabel &label, uint8_t size, int16_t x, int16_t target, const char *text)
{
    label.SetFont(TJD_VECTOR_FONT_FILENAME, size);
    label.SetText(text);
    label.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    label.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    label.SetPosition(x, VerticalCenter(label.GetHeight(), target));
}

static inline void InitLabelCenter(OHOS::UILabel &label, uint8_t size, int16_t parentWidth, int16_t parentHeight, const char *text)
{
    label.SetFont(TJD_VECTOR_FONT_FILENAME, size);
    label.SetText(text);
    label.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    label.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    label.SetPosition(HorizontalCenter(label.GetWidth(), parentWidth), VerticalCenter(label.GetHeight(), parentHeight));
}
// clang-format on
bool LefunAiUIScrollView::OnDragStartEvent(const OHOS::DragEvent &event)
{
    if (TjdUiAppLefunAiView::currentViewIndex_ != LefunAiView::LEFUN_AI_VIEW_MAIN) {
        return true;
    }

    isOnStart_ = true;
    return OHOS::UIScrollViewNested::OnDragStartEvent(event);
}

bool LefunAiUIScrollView::OnDragEvent(const OHOS::DragEvent &event)
{
    if (!isOnStart_) {
        return true;
    }

    if (TjdUiAppLefunAiView::currentViewIndex_ != LefunAiView::LEFUN_AI_VIEW_MAIN) {
        return true;
    }
    return OHOS::UIScrollViewNested::OnDragEvent(event);
}

bool LefunAiUIScrollView::OnDragEndEvent(const OHOS::DragEvent &event)
{
    if (!isOnStart_) {
        return true;
    }
    isOnStart_ = false;

    if (TjdUiAppLefunAiView::currentViewIndex_ != LefunAiView::LEFUN_AI_VIEW_MAIN) {
        return true;
    }
    return OHOS::UIScrollViewNested::OnDragEndEvent(event);
}

TjdUiAppLefunAiView::TjdUiAppLefunAiView() { g_pv_LefunAiView = this; }

TjdUiAppLefunAiView::~TjdUiAppLefunAiView() { g_pv_LefunAiView = nullptr; }

TjdUiAppLefunAiView *TjdUiAppLefunAiView::GetInstance(void) { return g_pv_LefunAiView; }

void TjdUiAppLefunAiView::OnStart()
{
    static_print_info("TjdUiAppLefunAiView::OnStart");
    View<TjdUiAppLefunAiPresenter>::OnStart();

    TjdUiAppLefunAiModel::GetInstance().AudioInit();
    OHOS::ImageCacheManager::GetInstance().LoadAllInMultiRes(IMAGE_BIN_PATH);
    InitHistoryListResource();

    if (mainView_ == nullptr) {
        mainView_ = new LefunAiUIScrollView();
    }
    mainView_->SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    // mainView_->SetOnDragListener(TjdUiAppLefunAiPresenter::GetInstance());

    AddViewToRootContainer(mainView_);

    ShowView(LEFUN_AI_VIEW_MAIN);
}

void TjdUiAppLefunAiView::OnStop()
{
    TjdUiAppLefunAiModel::GetInstance().LefunAiRequestExitLefunAi();
    OHOS::RootView::GetInstance()->Remove(mainView_);

    // if(historyItemList_ != nullptr){
    //     mainView_->Remove(historyItemList_);
    //     delete mainView_;
    //     historyItemList_ = nullptr;
    // }

    if (mainView_ != nullptr) {
        mainView_->RemoveAll();
        delete mainView_;
        mainView_ = nullptr;
    }
    OHOS::ImageCacheManager::GetInstance().UnloadAllInMultiRes(IMAGE_BIN_PATH);
}

void TjdUiAppLefunAiView::InitTargetView(LefunAiView index)
{
    if (viewManager_[index] != nullptr) {
        return;
    }

    // clang-format off
    switch (index) {
    case LEFUN_AI_VIEW_MAIN:                        viewManager_[index] = new TjdUiAppLefunAiMainView(); break;
    case LEFUN_AI_VIEW_NO_CONNECT_VIEW:             viewManager_[index] = new LefunAiNoConnectView(); break;
    case LEFUN_AI_VIEW_RECORDING_VIEW:              viewManager_[index] = new LefunAiRecordingView(); break;
    case LEFUN_AI_VIEW_ANALYSIS_VIEW:               viewManager_[index] = new LefunAiAnalysisView(); break;
    case LEFUN_AI_VIEW_TIME_OUT_VIEW:               viewManager_[index] = new LefunAiTiemOutView(); break;
    case LEFUN_AI_VIEW_ANSWER_VIEW:                 viewManager_[index] = new LefunAiAnswerView(); break;
    case LEFUN_AI_VIEW_NO_CONTENT_VIEW:             viewManager_[index] = new LefunAiNoContentInputView(); break;
    case LEFUN_AI_VIEW_HISTORY_VIEW:                viewManager_[index] = new LefunAiHistoryRecordView(); break;
    default: break;
    }
    // clang-format on

    if (viewManager_[index] == nullptr) {
        return;
    }

    viewManager_[index]->SetPosition(0, 0);
    viewManager_[index]->SetVisible(false);
    mainView_->Add(viewManager_[index]);
}

void TjdUiAppLefunAiView::ShowView(LefunAiView showIndex)
{
    if (showIndex < 0 || showIndex >= LEFUN_AI_VIEW_COUNT) {
        return;
    }

    InitTargetView(showIndex);

    if (currentViewIndex_ >= 0 && currentViewIndex_ < LEFUN_AI_VIEW_COUNT &&
        viewManager_[currentViewIndex_] != nullptr) {
        viewManager_[currentViewIndex_]->HideView();
    }

    if (viewManager_[showIndex] != nullptr) {
        viewManager_[showIndex]->ShowView();
    }

    currentViewIndex_ = showIndex;
}

void TjdUiAppLefunAiView::InitHistoryListResource()
{
    History lefunAiHistory;
    TjdUiAppLefunAiModel::GetInstance().loadFromJson(&lefunAiHistory);

    if (historyItemList_ == nullptr) {
        historyItemList_ = new std::list<HistoryItemInfo>();
    }
    historyItemList_->clear();

    for (int i = 0; i < lefunAiHistory.total_records; ++i) {
        historyItemList_->push_back({lefunAiHistory.records[i].question, lefunAiHistory.records[i].answer});
    }
}

#pragma endregion

#pragma region TjdUiAppLefunAiMainView
TjdUiAppLefunAiMainView::TjdUiAppLefunAiMainView()
{
    SetPosition(0, 0, 466, 466);
    if (OHOS::PageTransitionMgr::GetInstance().GetTopSlideBackImage() == nullptr) {
        SetOnDragListener(TjdUiAppLefunAiPresenter::GetInstance());
    }

    auto imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_LEFUN_AI_BJ, IMAGE_BIN_PATH);
    imgBg_.SetPosition(0, 0);
    if (imgInfo != nullptr) {
        imgBg_.SetSrc(imgInfo);
    }

    imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_LEFUN_AI_HISTORY, IMAGE_BIN_PATH);
    imgHistory_.SetPosition(191, 20);
    if (imgInfo != nullptr) {
        imgHistory_.SetSrc(imgInfo);
    }
    imgHistory_.SetViewId(MAIN_VIEW_HISTORY_BTN_ID);
    imgHistory_.SetTouchable(true);
    imgHistory_.SetOnClickListener(TjdUiAppLefunAiPresenter::GetInstance());

    InitLabelHorCenter(lefunAi_, 34, 126, 466, "Lefun AI");
    // InitLabelHorCenter(brief_, 28, 172, 466, "全职全解的AI百科");
    brief_.SetFont(TJD_VECTOR_FONT_FILENAME, 34);
    brief_.SetTextId(STR_ID_578);
    brief_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_MARQUEE);
    brief_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    brief_.SetPosition(0, 172, 466, 47);

    // InitLabelHorCenter(guideLabel_, 32, 249, 466, "戳下方体验");
    guideLabel_.SetFont(TJD_VECTOR_FONT_FILENAME, 34);
    guideLabel_.SetTextId(STR_ID_369);
    guideLabel_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_MARQUEE);
    guideLabel_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    guideLabel_.SetPosition(0, 249, 466, 47);

    imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_LEFUN_AI_PULL_UP, IMAGE_BIN_PATH);
    guideImg_.SetPosition(218, 305);
    if (imgInfo != nullptr) {
        guideImg_.SetSrc(imgInfo);
    }

    imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_LEFUN_AI_FORWARD, IMAGE_BIN_PATH);
    imgConfirm_.SetPosition(187, 352);
    if (imgInfo != nullptr) {
        imgConfirm_.SetSrc(imgInfo);
    }
    imgConfirm_.SetViewId(MAIN_VIEW_ID);
    imgConfirm_.SetTouchable(true);
    imgConfirm_.SetOnClickListener(TjdUiAppLefunAiPresenter::GetInstance());

    Add(&imgBg_);
    Add(&imgHistory_);
    Add(&lefunAi_);
    Add(&brief_);
    Add(&guideLabel_);
    Add(&guideImg_);
    Add(&imgConfirm_);
}

void TjdUiAppLefunAiMainView::ShowView()
{
    TjdUiAppLefunAiModel::GetInstance().RequestIntoLefunAi();
    SetVisible(true);
}
void TjdUiAppLefunAiMainView::HideView() { SetVisible(false); }

#pragma endregion

#pragma region TjdUiAppLefunAiRecordingView
LefunAiNoConnectView::LefunAiNoConnectView()
{
    SetPosition(0, 0, 466, 466);
    if (OHOS::PageTransitionMgr::GetInstance().GetTopSlideBackImage() == nullptr) {
        SetOnDragListener(TjdUiAppLefunAiPresenter::GetInstance());
    }

    auto imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_LEFUN_AI_NO_CONNECT, IMAGE_BIN_PATH);
    imgNoConnect_.SetPosition(67, 155);
    if (imgInfo != nullptr) {
        imgNoConnect_.SetSrc(imgInfo);
    }

    // InitLabelHorCenter(lbNoConnect_, 28, 305, 466, "请连接APP");
    lbNoConnect_.SetPosition(80, 308, 291, 47);
    lbNoConnect_.SetFont(TJD_VECTOR_FONT_FILENAME, 36);
    lbNoConnect_.SetTextId(STR_ID_557);
    lbNoConnect_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_WRAP);
    lbNoConnect_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);

    Add(&imgNoConnect_);
    Add(&lbNoConnect_);
}
#pragma endregion

#pragma region LefunAiRecordingView
static void RecordingTimerCallBack(void *arg)
{
    GraphicService::GetInstance()->PostGraphicEvent(
        std::bind([](void *arg) { LefunAiRecordingView::GetInstance()->UpdateRecordingTime(); }, arg));
}

LefunAiRecordingView::LefunAiRecordingView()
{
    g_LefunAiRecordingView = this;
    const int recordingAnimatorId[] = {IMG_LEFUN_AI_LEFUNAI_DT_01_03, IMG_LEFUN_AI_LEFUNAI_DT_02_03,
                                       IMG_LEFUN_AI_LEFUNAI_DT_03_03, IMG_LEFUN_AI_LEFUNAI_DT_04_03,
                                       IMG_LEFUN_AI_LEFUNAI_DT_05_03, IMG_LEFUN_AI_LEFUNAI_DT_06_03};

    SetPosition(0, 0, 466, 466);
    SetOnDragListener(TjdUiAppLefunAiPresenter::GetInstance());

    auto imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_LEFUN_AI_BJ, IMAGE_BIN_PATH);
    imgBg_.SetPosition(0, 0);
    if (imgInfo != nullptr) {
        imgBg_.SetSrc(imgInfo);
    }
    imgBg_.SetStyle(STYLE_IMAGE_OPA, 127);

    InitLabel(recordingGoal_, 40, 125, 60, "00:00");
    InitLabel(targetGoal_, 40, 233, 60, "/00:30");

    imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_LEFUN_AI_CONFIRM, IMAGE_BIN_PATH);
    imgConfirm_.SetPosition(187, 352);
    if (imgInfo != nullptr) {
        imgConfirm_.SetSrc(imgInfo);
    }
    imgConfirm_.SetViewId(RECORDING_VIEW_ID);
    imgConfirm_.SetTouchable(true);
    imgConfirm_.SetOnClickListener(TjdUiAppLefunAiPresenter::GetInstance());

    auto &imgManager = OHOS::ImageCacheManager::GetInstance();
    for (int i = 0; i < 6; i++) {
        animatorRecordingInfo_[i].imageInfo = imgManager.LoadOneInMultiRes(recordingAnimatorId[i], IMAGE_BIN_PATH);
        animatorRecordingInfo_[i].pos = {76, 139};
        animatorRecordingInfo_[i].width = 316;
        animatorRecordingInfo_[i].height = 95;
        animatorRecordingInfo_[i].imageType = OHOS::IMG_SRC_IMAGE_INFO;
    }
    // /* 动画页面不允许滑动 */
    // SetIntercept(true);
    // SetTouchable(false);
    animator_.SetPosition(76, 139, 316, 95);
    animator_.SetImageAnimatorSrc(animatorRecordingInfo_, 6, 100);

    // InitLabel(guideLabel_, 28, 104, 271, "试试对我说\n“中国有多少个省份”");
    guideLabel_.SetPosition(0, 271, 466, 47);
    guideLabel_.SetFont(TJD_VECTOR_FONT_FILENAME, 28);
    guideLabel_.SetTextId(STR_ID_371);
    guideLabel_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_WRAP);
    guideLabel_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);

    if (recordingTimer_ == nullptr) {
        recordingTimer_ = new OHOS::GraphicTimer(1000, RecordingTimerCallBack, nullptr, true);
    }

    Add(&imgBg_);
    Add(&recordingGoal_);
    Add(&targetGoal_);
    Add(&imgConfirm_);
    Add(&guideLabel_);
    Add(&animator_);
}

LefunAiRecordingView::~LefunAiRecordingView()
{
    g_LefunAiRecordingView = nullptr;

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

    RemoveAll();
};

void LefunAiRecordingView::UpdateRecordingTime()
{
    char timeStr[10] = {0};
    recordingTime++;
    memset(timeStr, 0, sizeof(timeStr));
    sprintf(timeStr, "%02d:%02d", 0, recordingTime);
    InitLabel(recordingGoal_, 40, 125, 60, timeStr);
    if (recordingTime > 30) {
        recordingTime = 0;
        recordingTimer_->Stop();
        TjdUiAppLefunAiView::GetInstance()->ShowView(LEFUN_AI_VIEW_ANALYSIS_VIEW);
    }
}

LefunAiRecordingView *LefunAiRecordingView::GetInstance(void) { return g_LefunAiRecordingView; }

void LefunAiRecordingView::ShowView()
{
    recordingGoal_.SetText("00:00");
    TjdUiAppLefunAiModel::GetInstance().CloseAutoScreenOff();
    recordingTime = 0;
    animator_.Start();
    recordingTimer_->Start();
    TjdUiAppLefunAiModel::GetInstance().RecordStart();
    SetVisible(true);
}

void LefunAiRecordingView::HideView()
{
    TjdUiAppLefunAiModel::GetInstance().OpenAutoScreenOff();
    TjdUiAppLefunAiModel::GetInstance().RecordStop();
    animator_.Stop();
    recordingTimer_->Stop();
    SetVisible(false);
}
#pragma endregion

#pragma region LefunAiAnalysisView
static uint8_t analysisCount = 0;
static uint8_t delayCount = 0;
static void AnalysisTimerCallBack(void *arg)
{
    analysisCount++;
    delayCount++;
    GraphicService::GetInstance()->PostGraphicEvent(std::bind(
        [](void *arg) {
            if (delayCount >= 10) {
                delayCount = 0;
                if (!TjdUiAppLefunAiModel::GetInstance().GetAiAudioTransFlag()) {
                    TjdUiAppLefunAiView::GetInstance()->ShowView(LEFUN_AI_VIEW_NO_CONTENT_VIEW);
                } else {
                    if (analysisCount >= 30) {
                        TjdUiAppLefunAiView::GetInstance()->ShowView(LEFUN_AI_VIEW_TIME_OUT_VIEW);
                    }
                }
            }
        },
        arg));
}
LefunAiAnalysisView::LefunAiAnalysisView()
{
    g_LefunAiAnalysisView = this;
    SetPosition(0, 0, 466, 466);
    SetOnDragListener(TjdUiAppLefunAiPresenter::GetInstance());

    const int analysisAnimatorId[] = {
        IMG_LOADING_LOADING_01_06, IMG_LOADING_LOADING_02_06, IMG_LOADING_LOADING_03_06, IMG_LOADING_LOADING_04_06,
        IMG_LOADING_LOADING_05_06, IMG_LOADING_LOADING_06_06, IMG_LOADING_LOADING_07_06, IMG_LOADING_LOADING_08_06,
        IMG_LOADING_LOADING_09_06, IMG_LOADING_LOADING_10_06, IMG_LOADING_LOADING_11_06,
    };

    auto &imgManager = OHOS::ImageCacheManager::GetInstance();
    for (int i = 0; i < 11; i++) {
        animatorAnalysisInfo_[i].imageInfo =
            imgManager.LoadOneInMultiRes(analysisAnimatorId[i], LOADING_IMAGE_BIN_PATH);
        animatorAnalysisInfo_[i].pos = {172, 131};
        animatorAnalysisInfo_[i].width = 121;
        animatorAnalysisInfo_[i].height = 121;
        animatorAnalysisInfo_[i].imageType = OHOS::IMG_SRC_IMAGE_INFO;
    }
    /* 动画页面不允许滑动 */
    SetIntercept(true);
    SetTouchable(false);
    animator_.SetPosition(172, 131, 121, 121);
    animator_.SetImageAnimatorSrc(animatorAnalysisInfo_, 11, 100);

    lbAnalysis_.SetPosition(0, 327, 466, 47);
    lbAnalysis_.SetFont(TJD_VECTOR_FONT_FILENAME, 28);
    lbAnalysis_.SetTextId(STR_ID_372);
    lbAnalysis_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_WRAP);
    lbAnalysis_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);

    if (analysisTimer_ == nullptr) {
        analysisTimer_ = new OHOS::GraphicTimer(1000, AnalysisTimerCallBack, nullptr, true);
    }

    Add(&animator_);
    Add(&lbAnalysis_);
}

LefunAiAnalysisView::~LefunAiAnalysisView()
{
    g_LefunAiAnalysisView = nullptr;

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

void LefunAiAnalysisView::ShowView()
{
    TjdUiAppLefunAiModel::GetInstance().CloseAutoScreenOff();
    analysisCount = 0;
    analysisTimer_->Start();
    animator_.Start();
    SetVisible(true);
}

void LefunAiAnalysisView::HideView()
{
    TjdUiAppLefunAiModel::GetInstance().OpenAutoScreenOff();
    analysisTimer_->Stop();
    animator_.Stop();
    SetVisible(false);
}

void LefunAiAnalysisView::ViewExitEvent()
{
    TjdUiAppLefunAiModel::GetInstance().OpenAutoScreenOff();
    analysisTimer_->Stop();
    animator_.Stop();
}

LefunAiAnalysisView *LefunAiAnalysisView::GetInstance(void) { return g_LefunAiAnalysisView; }

#pragma endregion

#pragma region LefunAiTiemOutView
LefunAiTiemOutView::LefunAiTiemOutView()
{
    SetPosition(0, 0, 466, 466);
    SetOnDragListener(TjdUiAppLefunAiPresenter::GetInstance());

    auto imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_LEFUN_AI_PROMPT_FAIL, IMAGE_BIN_PATH);
    imgTimeOutBg_.SetPosition(134, 92);
    if (imgInfo != nullptr) {
        imgTimeOutBg_.SetSrc(imgInfo);
    }

    // InitLabelHorCenter(lbfail_, 36, 257, 466, "分析失败，请重试");
    lbfail_.SetPosition(0, 257, 466, 47);
    lbfail_.SetFont(TJD_VECTOR_FONT_FILENAME, 36);
    lbfail_.SetTextId(STR_ID_374);
    lbfail_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_WRAP);
    lbfail_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);

    imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_LEFUN_AI_CANCEL, IMAGE_BIN_PATH);
    imgCancel_.SetPosition(103, 326);
    if (imgInfo != nullptr) {
        imgCancel_.SetSrc(imgInfo);
    }
    imgCancel_.SetViewId(TIMEOUT_VIEW_CANCEL_ID);
    imgCancel_.SetTouchable(true);
    imgCancel_.SetOnClickListener(TjdUiAppLefunAiPresenter::GetInstance());

    imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_LEFUN_AI_PLAY, IMAGE_BIN_PATH);
    imgRetry_.SetPosition(271, 326);
    if (imgInfo != nullptr) {
        imgRetry_.SetSrc(imgInfo);
    }
    imgRetry_.SetViewId(TIMEOUT_VIEW_RETRY_ID);
    imgRetry_.SetTouchable(true);
    imgRetry_.SetOnClickListener(TjdUiAppLefunAiPresenter::GetInstance());

    Add(&imgTimeOutBg_);
    Add(&lbfail_);
    Add(&imgCancel_);
    Add(&imgRetry_);
}
#pragma endregion

#pragma region LefunAiAnswerView
static void waitTimerCallBack(void *arg)
{
    GraphicService::GetInstance()->PostGraphicEvent(
        std::bind([](void *arg) { LefunAiAnswerView::GetInstance()->SetDraggable(true); }, arg));
}

AnswerView::AnswerView()
{
    Resize(400, 157);
    // SetStyle(OHOS::STYLE_BACKGROUND_COLOR, 0xff262626);
    lbAnswer_.SetFont(TJD_VECTOR_FONT_FILENAME, 24);
    lbAnswer_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_WRAP);
    lbAnswer_.SetText("此处为AI模板反馈信息内容");
    lbAnswer_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    lbAnswer_.SetPosition(94, 30, 306, 150);

    Add(&lbAnswer_);
}

static uint16_t last_height = 0;
LefunAiAnswerView::LefunAiAnswerView()
{
    g_pv_LefunAiAnswerView = this;
    SetPosition(0, 0, 466, 466);
    SetOnDragListener(TjdUiAppLefunAiPresenter::GetInstance());

    lbQuestionBg_.SetPosition(58, 58, 350, 100);
    lbQuestionBg_.SetStyle(STYLE_BACKGROUND_COLOR, 0xff262626);
    lbQuestionBg_.SetStyle(STYLE_BORDER_RADIUS, 50);

    auto imgInfo =
        OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_LEFUN_AI_ASKING_QUESTIONS, IMAGE_BIN_PATH);
    imgQuestion_.SetPosition(78, 78);
    if (imgInfo != nullptr) {
        imgQuestion_.SetSrc(imgInfo);
    }

    lbQuestion_.SetFont(TJD_VECTOR_FONT_FILENAME, 30);
    lbQuestion_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_OSCILLATION);
    lbQuestion_.SetText("此处为用户询问内容、此处为用户询问内容");
    lbQuestion_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    lbQuestion_.SetPosition(152, 80, 215, 55);

    answerView_.SetPosition(33, 157);

    imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_LEFUN_AI_AI, IMAGE_BIN_PATH);
    imgAnswer_.SetPosition(18, 167);
    if (imgInfo != nullptr) {
        imgAnswer_.SetSrc(imgInfo);
    }

    imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_LEFUN_AI_FORWARD, IMAGE_BIN_PATH);
    imgConfirm_.SetPosition(187, 352);
    if (imgInfo != nullptr) {
        imgConfirm_.SetSrc(imgInfo);
    }
    imgConfirm_.SetViewId(ANSWER_VIEW_ID);
    imgConfirm_.SetTouchable(true);
    imgConfirm_.SetOnClickListener(TjdUiAppLefunAiPresenter::GetInstance());

    if (waitTimer_ == nullptr) {
        waitTimer_ = new OHOS::GraphicTimer(500, waitTimerCallBack, nullptr, false);
    }

    Add(&answerView_);
    Add(&lbQuestionBg_);
    Add(&imgQuestion_);
    Add(&lbQuestion_);
    Add(&imgAnswer_);
    Add(&imgConfirm_);
}

void LefunAiAnswerView::RefreshAnswerView()
{
    extern std::string question;
    extern std::string answer;

    lbQuestionBg_.SetY(58);
    imgQuestion_.SetY(78);
    // imgAnswer_.SetY(173);
    lbQuestion_.SetY(81);
    // lbAnswer_.SetY(175);
    // InitLabel(lbQuestion_, 24, 156, 81, question.c_str());
    lbQuestion_.SetText(question.c_str());
    answerView_.SetAnswer(answer);
}

void LefunAiAnswerView::ShowView()
{
    // SetDraggable(false);
    ScrollBy(0, 966);
    // answerView_.ScrollBy(0,answerView_.GetRect().GetBottom());
    RefreshAnswerView();
    // waitTimer_->Start();
    SetVisible(true);
}

void LefunAiAnswerView::HideView()
{
    if (waitTimer_ != nullptr) {
        waitTimer_->Stop();
    }

    SetVisible(false);
}

LefunAiAnswerView *LefunAiAnswerView::GetInstance(void) { return g_pv_LefunAiAnswerView; }

LefunAiAnswerView::~LefunAiAnswerView()
{
    g_pv_LefunAiAnswerView = nullptr;

    if (waitTimer_ != nullptr) {
        waitTimer_->Stop();
        delete waitTimer_;
        waitTimer_ = nullptr;
    }
    RemoveAll();
};
#pragma endregion

#pragma region LefunAiNoContentInputView
LefunAiNoContentInputView::LefunAiNoContentInputView()
{
    SetPosition(0, 0, 466, 466);
    SetOnDragListener(TjdUiAppLefunAiPresenter::GetInstance());

    auto imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_LEFUN_AI_FAIL, IMAGE_BIN_PATH);
    imgNoContent_.SetPosition(129, 76);
    if (imgInfo != nullptr) {
        imgNoContent_.SetSrc(imgInfo);
    }

    // InitLabelHorCenter(lbNoContent_, 36, 274, 466, "无内容输入，请重试");
    lbNoContent_.SetPosition(0, 274, 466, 47);
    lbNoContent_.SetFont(TJD_VECTOR_FONT_FILENAME, 36);
    lbNoContent_.SetTextId(STR_ID_375);
    lbNoContent_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_WRAP);
    lbNoContent_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);

    imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_LEFUN_AI_RETURN, IMAGE_BIN_PATH);
    imgReturn_.SetPosition(187, 352);
    if (imgInfo != nullptr) {
        imgReturn_.SetSrc(imgInfo);
    }
    imgReturn_.SetViewId(NO_CONTENT_VIEW_ID);
    imgReturn_.SetTouchable(true);
    imgReturn_.SetOnClickListener(TjdUiAppLefunAiPresenter::GetInstance());

    Add(&imgNoContent_);
    Add(&lbNoContent_);
    Add(&imgReturn_);
}
#pragma endregion

#pragma region LefunAiHistoryRecordView
LefunAiHistoryRecordView::LefunAiHistoryRecordView()
{
    SetPosition(0, 0, 466, 466);
    SetOnDragListener(TjdUiAppLefunAiPresenter::GetInstance());

    // InitLabelHorCenter(lbTitle_, 28, 17, 466, "历史记录");
    lbTitle_.SetFont(TJD_VECTOR_FONT_FILENAME, 28);
    lbTitle_.SetTextId(STR_ID_370);
    lbTitle_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    lbTitle_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    lbTitle_.SetPosition(HorizontalCenter(lbTitle_.GetWidth(), 466), 17);

    auto imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_LEFUN_AI_NO_DATA, IMAGE_BIN_PATH);
    imgNoRecord_.SetPosition(170, 106);
    if (imgInfo != nullptr) {
        imgNoRecord_.SetSrc(imgInfo);
    }
    imgNoRecord_.SetVisible(false);

    // InitLabelHorCenter(lbNoRecord_, 28, 294, 466, "暂无记录！");
    lbNoRecord_.SetFont(TJD_VECTOR_FONT_FILENAME, 28);
    lbNoRecord_.SetTextId(STR_ID_579);
    lbNoRecord_.SetLineBreakMode(OHOS::UILabel::LINE_BREAK_ADAPT);
    lbNoRecord_.SetAlign(OHOS::TEXT_ALIGNMENT_CENTER, OHOS::TEXT_ALIGNMENT_CENTER);
    lbNoRecord_.SetPosition(HorizontalCenter(lbNoRecord_.GetWidth(), 466), 294);
    lbNoRecord_.SetVisible(false);

    imgInfo = OHOS::ImageCacheManager::GetInstance().LoadOneInMultiRes(IMG_LEFUN_AI_RETURN, IMAGE_BIN_PATH);
    imgReturn_.SetPosition(187, 352);
    if (imgInfo != nullptr) {
        imgReturn_.SetSrc(imgInfo);
    }
    imgReturn_.SetViewId(HISTORT_VIEW_ID);
    imgReturn_.SetTouchable(true);
    imgReturn_.SetOnClickListener(TjdUiAppLefunAiPresenter::GetInstance());

    listAdapter_ = new TjdUiAppLefunAiAdapter();

    historyList_ = new UIList(UIList::VERTICAL);
    historyList_->SetPosition(0, 68);
    historyList_->Resize(HORIZONTAL_RESOLUTION, 312);
    historyList_->SetThrowDrag(true);
    historyList_->EnableAutoAlign(true);
    historyList_->SetElastic(true);
    historyList_->SetAdapter(listAdapter_);
    historyList_->SetYScrollBarVisible(true);

    Add(&lbTitle_);
    Add(&lbNoRecord_);
    Add(&imgNoRecord_);
    Add(historyList_);
    Add(&imgReturn_);
}

LefunAiHistoryRecordView::~LefunAiHistoryRecordView()
{
    if (historyList_ != nullptr) {
        delete historyList_;
        historyList_ = nullptr;
    }

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

    RemoveAll();
}

void LefunAiHistoryRecordView::ShowView()
{
    printf("656 total_records = %d\n", TjdUiAppLefunAiModel::GetInstance().get_total_records_from_json());
    if (TjdUiAppLefunAiModel::GetInstance().get_total_records_from_json()) {
        TjdUiAppLefunAiView::GetInstance()->InitHistoryListResource();
        historyList_->SetVisible(true);
        historyList_->RefreshList();
        imgNoRecord_.SetVisible(false);
        lbNoRecord_.SetVisible(false);
    } else {
        historyList_->SetVisible(false);
        imgNoRecord_.SetVisible(true);
        lbNoRecord_.SetVisible(true);
    }
    SetVisible(true);
}

void LefunAiHistoryRecordView::HideView() { SetVisible(false); }

#pragma endregion

} // namespace TJD