#include "TjdUiAppCalculatorView.h"
#include "TjdUiImageIds.h"
#include "TjdUiMemManage.h"
#include "TjdUiMultiLanguageExt.h"
#include "animator/animator_manager.h"
#include "color.h"
#include "common/image_cache_manager.h"
#include "gfx_utils/color.h"
#include "gfx_utils/mem_check.h"
#include "graphic_service.h"
#include "rtc_api.h"
#include "sys_config.h"
#include "ui_view.h"
#include <stdio.h>
#include <string.h>

using namespace OHOS;

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

static TjdUiAppCalculatorView *g_pv_CalculatorMainView = nullptr;
static CalculatorView *g_pv_CalculatorView = nullptr;
struct UiCalculator *__calculator = nullptr;
uint8_t last_mode = 0;
int count = 0;
#define CALCULATOR_IMAGE_BIN_PATH TJD_IMAGE_PATH "img_calculator.bin"
#define BUTTON_START_X 27
#define BUTTON_START_Y 177
#define BUTTON_WIDTH 78
#define BUTTON_HIGH 58
#define BUTTON_GAP 5
#define RESULT_COUNT 8
#define FONT_LEVEL 4
#define FONT_SIZE 54

// clang-format off
typedef enum
{
    CALC_7,
    CALC_8,
    CALC_9,
    CALC_AC,
    CALC_DEL,
    CALC_4,
    CALC_5,
    CALC_6,
    CALC_SUB,
    CALC_MUL,
    CALC_1,
    CALC_2,
    CALC_3,
    CALC_ADD,
    CALC_DIV,
    CALC_0,
    CALC_P,
    CALC_EQU,
} calc_button_type_t;

char *CalculatorMode[] = {
    "\0", "+", "-", "x", "÷",
};

static const int g_pv_Calculator[][2] = {
    { IMG_CALCULATOR_DEFAULT_07      ,	IMG_CALCULATOR_DEFAULT_07     },
	{ IMG_CALCULATOR_DEFAULT_08      ,	IMG_CALCULATOR_DEFAULT_08     },
	{ IMG_CALCULATOR_DEFAULT_09      ,	IMG_CALCULATOR_DEFAULT_09     },
	{ IMG_CALCULATOR_DEFAULT_AC      ,	IMG_CALCULATOR_HIGHLIGHT_AC     },
    { IMG_CALCULATOR_DEFAULT_DELETE  ,	IMG_CALCULATOR_HIGHLIGHT_DELETE },
    { IMG_CALCULATOR_DEFAULT_04      ,	IMG_CALCULATOR_DEFAULT_04     },
	{ IMG_CALCULATOR_DEFAULT_05      ,	IMG_CALCULATOR_DEFAULT_05     },
	{ IMG_CALCULATOR_DEFAULT_06     ,	IMG_CALCULATOR_DEFAULT_06     },
    { IMG_CALCULATOR_DEFAULT_JIAN    ,	IMG_CALCULATOR_HIGHLIGHT_JIAN   },
    { IMG_CALCULATOR_DEFAULT_CHENG   ,	IMG_CALCULATOR_HIGHLIGHT_CHENG  },
    { IMG_CALCULATOR_DEFAULT_01     ,	IMG_CALCULATOR_DEFAULT_01     },
	{ IMG_CALCULATOR_DEFAULT_02     ,	IMG_CALCULATOR_DEFAULT_02     },
	{ IMG_CALCULATOR_DEFAULT_03     ,	IMG_CALCULATOR_DEFAULT_03     },
	{ IMG_CALCULATOR_DEFAULT_JIA    ,	IMG_CALCULATOR_HIGHLIGHT_JIA    },
    { IMG_CALCULATOR_DEFAULT_CHU     ,	IMG_CALCULATOR_HIGHLIGHT_CHU    },
    { IMG_CALCULATOR_DEFAULT_00     ,	IMG_CALCULATOR_DEFAULT_00     },
    { IMG_CALCULATOR_DEFAULT_DOT    ,	IMG_CALCULATOR_DEFAULT_DOT    },
    { IMG_CALCULATOR_DEFAULT_DENG   ,	IMG_CALCULATOR_HIGHLIGHT_DENG   },
};

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 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));
}

// clang-format on

bool ButtonOnClickListener::OnClick(UIView &view, const ClickEvent &event)
{
    ButtonOnClickCallBack(view, event);
    CalculatorView::GetInstance()->CalculatorViewRefresh();
    return true;
}
// clang-format off
void ButtonOnClickListener::ButtonOnClickCallBack(UIView &view, const ClickEvent &event)
{
    auto calculatorModel = TjdUiAppCalculatorModel::GetInstance();
    switch (view.GetViewIndex()) {

    case CALC_0: count++; calculatorModel->StringInput('0'); break;
    case CALC_1: count++; calculatorModel->StringInput('1'); break;
    case CALC_2: count++; calculatorModel->StringInput('2'); break;
    case CALC_3: count++; calculatorModel->StringInput('3'); break;
    case CALC_4: count++; calculatorModel->StringInput('4'); break;
    case CALC_5: count++; calculatorModel->StringInput('5'); break;
    case CALC_6: count++; calculatorModel->StringInput('6'); break;
    case CALC_7: count++; calculatorModel->StringInput('7'); break;
    case CALC_8: count++; calculatorModel->StringInput('8'); break;
    case CALC_9: count++; calculatorModel->StringInput('9'); break;
    case CALC_P: count++; calculatorModel->StringInput('.'); break;
    case CALC_ADD: count++; calculatorModel->CalculationModeSet(ADD); break;
    case CALC_SUB:
        count++;
        if (count == 1)
            calculatorModel->StringInput('-');
        else
            calculatorModel->CalculationModeSet(SUB);
        break;
    case CALC_MUL: count++; calculatorModel->CalculationModeSet(MUL); break;
    case CALC_DIV: count++; calculatorModel->CalculationModeSet(DIV); break;
    case CALC_EQU:count++;calculatorModel->CalculationModeSet(EQUAL); break;
    case CALC_DEL: calculatorModel->CalculationBack(); break;
    case CALC_AC: count = 0; calculatorModel->CalculationClear(); break;
    default: break;
    }
}
// clang-format on
TjdUiAppCalculatorView::TjdUiAppCalculatorView()
{
    OHOS::MemCheck::GetInstance()->EnableLeakCheck(true);
    g_pv_CalculatorMainView = this;
}

TjdUiAppCalculatorView::~TjdUiAppCalculatorView()
{
    printf("TjdUiAppCalculatorView::~TjdUiAppCalculatorView\n");
    g_pv_CalculatorMainView = nullptr;
    OHOS::MemCheck::GetInstance()->EnableLeakCheck(false);
}

TjdUiAppCalculatorView *TjdUiAppCalculatorView::GetInstance(void) { return g_pv_CalculatorMainView; }

void TjdUiAppCalculatorView::OnStart()
{
    static_print_info("TjdUiAppCalculatorView::OnStart");

    __calculator = (struct UiCalculator *)malloc(sizeof_this);
    if (__calculator == nullptr)
        printf("malloc failed\n");

    View<TjdUiAppCalculatorPresenter>::OnStart();

    OHOS::ImageCacheManager::GetInstance().LoadAllInMultiRes(CALCULATOR_IMAGE_BIN_PATH);

    if (mainView_ == nullptr) {
        mainView_ = new UIScrollView();
    }

    if (calculatorView_ == nullptr) {
        calculatorView_ = new CalculatorView();
    }

    mainView_->Add(calculatorView_);
    mainView_->SetPosition(0, 0, OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    if (OHOS::PageTransitionMgr::GetInstance().GetTopSlideBackImage() == nullptr) {
        mainView_->SetOnDragListener(&TjdUiAppCalculatorPresenter::GetInstance());
    }

    AddViewToRootContainer(mainView_);
}

void TjdUiAppCalculatorView::OnStop()
{
    if (mainView_ != nullptr) {
        OHOS::RootView::GetInstance()->Remove(mainView_);
        mainView_->RemoveAll();
        delete mainView_;
        mainView_ = nullptr;
    }

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

    if (__this) {
        free(__this);
        __this = NULL;
    }
    OHOS::ImageCacheManager::GetInstance().UnloadAllInMultiRes(CALCULATOR_IMAGE_BIN_PATH);
}

CalculatorView::CalculatorView()
{
    printf("CalculatorView::CalculatorView\n");
    g_pv_CalculatorView = this;
    uint8_t column = 0;
    Resize(OHOS::HORIZONTAL_RESOLUTION, OHOS::VERTICAL_RESOLUTION);
    SetStyle(STYLE_BACKGROUND_OPA, 0);

    reultLabel.SetText("0");
    reultLabel.SetPosition(RESULT_LABEL_X, 100);
    reultLabel.Resize(313, 60);
    reultLabel.SetStyle(STYLE_TEXT_FONT, FONT_SIZE);
    reultLabel.SetLineBreakMode(UILabel::LINE_BREAK_WRAP);
    reultLabel.SetAlign(TEXT_ALIGNMENT_RIGHT, TEXT_ALIGNMENT_RIGHT);
    reultLabel.SetRollSpeed(0);
    reultLabel.SetFont(TJD_DIN_MEDIUM_FONT_FILENAME, FONT_SIZE);

    reultLabel1.SetText("");
    reultLabel1.SetPosition(RESULT_LABEL_X, 45);
    reultLabel1.Resize(313, 60);
    reultLabel1.SetStyle(STYLE_TEXT_FONT, FONT_SIZE);
    reultLabel1.SetLineBreakMode(UILabel::LINE_BREAK_WRAP);
    reultLabel1.SetAlign(TEXT_ALIGNMENT_RIGHT, TEXT_ALIGNMENT_RIGHT);
    reultLabel1.SetRollSpeed(0);
    reultLabel1.SetFont(TJD_DIN_MEDIUM_FONT_FILENAME, FONT_SIZE);

    for (uint8_t i = 0; i < CALCULATOR_MAX_BUTTON; i++) {
        imgButtonInfo[i].defaultInfo =
            ImageCacheManager::GetInstance().LoadOneInMultiRes(g_pv_Calculator[i][0], CALCULATOR_IMAGE_BIN_PATH);
        imgButtonInfo[i].highlightInfo =
            ImageCacheManager::GetInstance().LoadOneInMultiRes(g_pv_Calculator[i][1], CALCULATOR_IMAGE_BIN_PATH);

        if (i % 5 == 0 && i != 0) {
            column++;
        }

        if (column < 3) {
            button_[i].SetPosition(BUTTON_START_X + BUTTON_WIDTH * (i % 5) + BUTTON_GAP * (i % 5),
                                   BUTTON_START_Y + BUTTON_HIGH * column + BUTTON_GAP * column);
            button_[i].Resize(BUTTON_WIDTH, BUTTON_HIGH);
            button_[i].SetImageSrc(imgButtonInfo[i].defaultInfo, imgButtonInfo[i].highlightInfo);
            button_[i].SetStyleForState(STYLE_BORDER_COLOR, 0xff000000, UIButton::PRESSED);
            button_[i].SetOnClickListener(&buttonOnClickListener[i]);
            button_[i].SetViewIndex(i);
        } else {
            if (i == 15) {
                button_[i].SetPosition(110, 366);
                button_[i].Resize(78, 58);
            } else if (i == 16) {
                button_[i].SetPosition(193, 366);
                button_[i].Resize(78, 58);
            } else {
                button_[i].SetPosition(276, 366);
                button_[i].Resize(78, 58);
            }
            button_[i].SetImageSrc(imgButtonInfo[i].defaultInfo, imgButtonInfo[i].highlightInfo);
            button_[i].SetStyleForState(STYLE_BORDER_COLOR, 0xff000000, UIButton::PRESSED);
            button_[i].SetOnClickListener(&buttonOnClickListener[i]);
            button_[i].SetViewIndex(i);
        }

        Add(&button_[i]);
    }

    Add(&reultLabel);
    Add(&reultLabel1);
    TjdUiAppCalculatorModel::GetInstance()->CalculatorReset();
}

CalculatorView::~CalculatorView()
{
    g_pv_CalculatorView = nullptr;
    RemoveAll();
};

CalculatorView *CalculatorView::GetInstance() { return g_pv_CalculatorView; }

void CalculatorView::CalculatorViewRefresh()
{
    char num_str[30] = {0};
    std::string tempStrr;
    auto calculatorModel = TjdUiAppCalculatorModel::GetInstance();
    uint8_t len = strlen(__this->str);
    switch (last_mode) {
    case NONE:
        if (len > RESULT_COUNT) {
            reultLabel.SetFont(TJD_DIN_MEDIUM_FONT_FILENAME, FONT_SIZE - (len - RESULT_COUNT) * 3 < 34
                                                                 ? 34
                                                                 : FONT_SIZE - (len - RESULT_COUNT) * FONT_LEVEL);
        }
        reultLabel.SetText(__this->str);
        break;
    case EQUAL:
        memset(num_str, 0, strlen(num_str));
        calculatorModel->DoubleToString(num_str, __this->num_1);
        reultLabel1.SetText("");
        if (strchr(num_str, '.') == NULL) {
            if (__this->num_1 > 9999999999999999 || __this->num_1 < -9999999999999999) {
                __this->num_1 = 0;
                // reultLabel.SetPosition(RESULT_LABEL_X, 32);
                reultLabel.SetText("ERROR");
                calculatorModel->CalculationClear();
            } else {
                // reultLabel.SetPosition(RESULT_LABEL_X + 5, 42);
                reultLabel.SetText(num_str);
            }
        } else {
            // reultLabel.SetPosition(RESULT_LABEL_X, 32);
            reultLabel.SetText(num_str);
        }
        break;
    case ADD ... DIV:
        calculatorModel->DoubleToString(num_str, __this->num_1);
        if (strchr(num_str, '.') == NULL) {
            if (__this->num_1 > 9999999999999999 || __this->num_1 < -9999999999999999) {
                __this->num_1 = 0;
                last_mode = 0;
                // reultLabel.SetPosition(RESULT_LABEL_X, 32);
                reultLabel.SetText("ERROR");
                calculatorModel->CalculationClear();
            } else {
                tempStrr = std::string(CalculatorMode[last_mode]) + std::string(__this->str);
                len = strlen(num_str);
                if (len > RESULT_COUNT) {
                    reultLabel1.SetFont(TJD_DIN_MEDIUM_FONT_FILENAME,
                                        FONT_SIZE - (len - RESULT_COUNT) * FONT_LEVEL < 34
                                            ? 34
                                            : FONT_SIZE - (len - RESULT_COUNT) * FONT_LEVEL);
                }

                len = strlen(tempStrr.c_str());
                if (len > RESULT_COUNT) {
                    reultLabel.SetFont(TJD_DIN_MEDIUM_FONT_FILENAME,
                                       FONT_SIZE - (len - RESULT_COUNT) * FONT_LEVEL < 42
                                           ? 42
                                           : FONT_SIZE - (len - RESULT_COUNT) * FONT_LEVEL);
                }
                reultLabel1.SetText(num_str);
                // reultLabel.SetPosition(RESULT_LABEL_X, 100);
                reultLabel.SetText(tempStrr.c_str());
            }
        } else {
            tempStrr = std::string(CalculatorMode[last_mode]) + std::string(__this->str);
            if (len > RESULT_COUNT) {
                reultLabel1.SetFont(TJD_DIN_MEDIUM_FONT_FILENAME, FONT_SIZE - (len - RESULT_COUNT) * FONT_LEVEL < 34
                                                                      ? 34
                                                                      : FONT_SIZE - (len - RESULT_COUNT) * FONT_LEVEL);
            }
            reultLabel1.SetText(num_str);
            // reultLabel.SetPosition(RESULT_LABEL_X, 100);
            reultLabel.SetText(tempStrr.c_str());
        }
        break;

    default:
        break;
    }

    g_pv_CalculatorView->Invalidate();
    TjdUiAppCalculatorView::GetInstance()->GetMainView()->Invalidate();
}

} // namespace TJD