//  SPDX-License-Identifier: MIT
//
//  EmulationStation Desktop Edition
//  DateTimeEditComponent.cpp
//
//  Date and time edit component.
//

#include "components/DateTimeEditComponent.h"

#include "resources/Font.h"
#include "utils/StringUtil.h"

DateTimeEditComponent::DateTimeEditComponent(
        Window* window,
        DisplayMode dispMode)
        : GuiComponent(window),
        mEditing(false),
        mEditIndex(0),
        mDisplayMode(dispMode),
        mRelativeUpdateAccumulator(0),
        mColor(0x777777FF),
        mFont(Font::get(FONT_SIZE_SMALL, FONT_PATH_LIGHT)),
        mUppercase(false),
        mAutoSize(true)
{
    updateTextCache();
}

void DateTimeEditComponent::setDisplayMode(DisplayMode mode)
{
    mDisplayMode = mode;
    updateTextCache();
}

bool DateTimeEditComponent::input(InputConfig* config, Input input)
{
    if (input.value == 0)
        return false;

    if (config->isMappedTo("a", input)) {
        if (mDisplayMode != DISP_RELATIVE_TO_NOW) // Don't allow editing for relative times.
            mEditing = !mEditing;

        // Change the color of the text to reflect the changes.
        if (mTime == mOriginalValue)
            setColor(mColorOriginalValue);
        else
            setColor(mColorChangedValue);

        if (mEditing) {
            // Started editing.
            mTimeBeforeEdit = mTime;

            // Initialize to now if unset.
            if (mTime.getTime() == Utils::Time::DEFAULT_TIMEVALUE) {
                mTime = Utils::Time::now();
                updateTextCache();
            }
        }

        return true;
    }

    if (mEditing) {

        if (config->isMappedLike("lefttrigger", input) ||
                config->isMappedLike("righttrigger", input))
            return true;

        if (config->isMappedTo("b", input)) {
            mEditing = false;
            mTime = mTimeBeforeEdit;
            updateTextCache();
            return true;
        }

        int incDir = 0;
        if (config->isMappedLike("up", input) || config->isMappedLike("rightshoulder", input))
            incDir = 1;
        else if (config->isMappedLike("down", input) || config->isMappedLike("leftshoulder", input))
            incDir = -1;

        if (incDir != 0) {
            tm new_tm = mTime;

            // ISO 8601 date format.
            if (mEditIndex == 0) {
                new_tm.tm_year += incDir;

                if (new_tm.tm_year < 0)
                    new_tm.tm_year = 0;
            }
            else if (mEditIndex == 1) {
                new_tm.tm_mon += incDir;

                if (new_tm.tm_mon > 11)
                    new_tm.tm_mon = 0;
                else if (new_tm.tm_mon < 0)
                    new_tm.tm_mon = 11;

            }
            else if (mEditIndex == 2) {
                const int days_in_month =
                        Utils::Time::daysInMonth(new_tm.tm_year + 1900, new_tm.tm_mon + 1);
                new_tm.tm_mday += incDir;

                if (new_tm.tm_mday > days_in_month)
                    new_tm.tm_mday = 1;
                else if (new_tm.tm_mday < 1)
                    new_tm.tm_mday = days_in_month;

            }

            // Validate day.
            const int days_in_month =
                    Utils::Time::daysInMonth(new_tm.tm_year + 1900, new_tm.tm_mon + 1);
            if (new_tm.tm_mday > days_in_month)
                new_tm.tm_mday = days_in_month;

            mTime = new_tm;

            updateTextCache();
            return true;
        }

        if (config->isMappedLike("right", input)) {
            mEditIndex++;
            if (mEditIndex >= (int)mCursorBoxes.size())
                mEditIndex--;
            return true;
        }

        if (config->isMappedLike("left", input)) {
            mEditIndex--;
            if (mEditIndex < 0)
                mEditIndex++;
            return true;
        }
    }

    return GuiComponent::input(config, input);
}

void DateTimeEditComponent::update(int deltaTime)
{
    if (mDisplayMode == DISP_RELATIVE_TO_NOW) {
        mRelativeUpdateAccumulator += deltaTime;
        if (mRelativeUpdateAccumulator > 1000) {
            mRelativeUpdateAccumulator = 0;
            updateTextCache();
        }
    }

    GuiComponent::update(deltaTime);
}

void DateTimeEditComponent::render(const Transform4x4f& parentTrans)
{
    Transform4x4f trans = parentTrans * getTransform();

    if (mTextCache) {
        // Vertically center.
        Vector3f off(0, (mSize.y() - mTextCache->metrics.size.y()) / 2, 0);
        trans.translate(off);

        Renderer::setMatrix(trans);

        std::shared_ptr<Font> font = getFont();

        mTextCache->setColor((mColor & 0xFFFFFF00) | getOpacity());
        font->renderTextCache(mTextCache.get());

        if (mEditing) {
            if (mEditIndex >= 0 && (unsigned int)mEditIndex < mCursorBoxes.size())
                Renderer::drawRect(mCursorBoxes[mEditIndex][0], mCursorBoxes[mEditIndex][1],
                    mCursorBoxes[mEditIndex][2], mCursorBoxes[mEditIndex][3],
                    0x00000022, 0x00000022);
        }
    }
}

void DateTimeEditComponent::setValue(const std::string& val)
{
    mTime = val;
    mOriginalValue = val;
    updateTextCache();
}

std::string DateTimeEditComponent::getValue() const
{
    return mTime;
}

DateTimeEditComponent::DisplayMode DateTimeEditComponent::getCurrentDisplayMode() const
{
//	if (mEditing) {
//		if (mDisplayMode == DISP_RELATIVE_TO_NOW) {
//			// TODO: if time component == 00:00:00, return DISP_DATE, else return DISP_DATE_TIME.
//			return DISP_DATE;
//		}
//	}

    return mDisplayMode;
}

std::string DateTimeEditComponent::getDisplayString(DisplayMode mode) const
{
    // ISO 8601 date format.
    std::string fmt;
    switch (mode) {
    case DISP_DATE: {
        if (mTime.getTime() == 0)
            // The extra blankspaces are for visual alignment.
            return "unknown   ";
        fmt = "%Y-%m-%d";
        break;
    }
    case DISP_DATE_TIME: {
        if (mTime.getTime() == 0)
            // The extra blankspaces are for visual alignment.
            return "unknown   ";
        fmt = "%Y-%m-%d %H:%M:%S";
        break;
    }
    case DISP_RELATIVE_TO_NOW: {
            // Relative time.
            if (mTime.getTime() == 0)
                return "never";

            Utils::Time::DateTime now(Utils::Time::now());
            Utils::Time::Duration dur(now.getTime() - mTime.getTime());

            char buf[64];

            if (dur.getDays() > 0)
                sprintf(buf, "%d day%s ago", dur.getDays(), (dur.getDays() > 1) ? "s" : "");
            else if (dur.getHours() > 0)
                sprintf(buf, "%d hour%s ago", dur.getHours(), (dur.getHours() > 1) ? "s" : "");
            else if (dur.getMinutes() > 0)
                sprintf(buf, "%d minute%s ago", dur.getMinutes(),
                        (dur.getMinutes() > 1) ? "s" : "");
            else
                sprintf(buf, "%d second%s ago", dur.getSeconds(),
                        (dur.getSeconds() > 1) ? "s" : "");

            return std::string(buf);
        }
        break;
    }

    return Utils::Time::timeToString(mTime, fmt);
}

std::shared_ptr<Font> DateTimeEditComponent::getFont() const
{
    if (mFont)
        return mFont;

    return Font::get(FONT_SIZE_MEDIUM);
}

void DateTimeEditComponent::updateTextCache()
{
    DisplayMode mode = getCurrentDisplayMode();

    std::string dispString;

    // Hack to set date string to blank instead of 'unknown'.
    // The calling function simply needs to set this string using setValue().
    if (mTime.getIsoString() == "19700101T010101") {
        dispString = "";
    }
    else {
        dispString = mUppercase ? Utils::String::toUpper(getDisplayString(mode)) :
                getDisplayString(mode);
    }
    std::shared_ptr<Font> font = getFont();
    mTextCache = std::unique_ptr<TextCache>(font->buildTextCache(dispString, 0, 0, mColor));

    if (mAutoSize) {
        mSize = mTextCache->metrics.size;

        mAutoSize = false;
        if (getParent())
            getParent()->onSizeChanged();
    }

    if (dispString == "unknown   " || dispString == "")
        return;

    // Set up cursor positions.
    mCursorBoxes.clear();

    if (dispString.empty() || mode == DISP_RELATIVE_TO_NOW)
        return;

    // Year.
    Vector2f start(0, 0);
    Vector2f end = font->sizeText(dispString.substr(0, 4));
    Vector2f diff = end - start;
    mCursorBoxes.push_back(Vector4f(start[0], start[1], diff[0], diff[1]));

    // Month.
    start[0] = font->sizeText(dispString.substr(0, 5)).x();
    end = font->sizeText(dispString.substr(0, 7));
    diff = end - start;
    mCursorBoxes.push_back(Vector4f(start[0], start[1], diff[0], diff[1]));

    // Day.
    start[0] = font->sizeText(dispString.substr(0, 8)).x();
    end = font->sizeText(dispString.substr(0, 10));
    diff = end - start;
    mCursorBoxes.push_back(Vector4f(start[0], start[1], diff[0], diff[1]));

    // The logic for handling time for 'mode = DISP_DATE_TIME' is missing, but
    // nobody will use it anyway so it's not worthwhile implementing.
}

void DateTimeEditComponent::setColor(unsigned int color)
{
    mColor = color;
    if (mTextCache)
        mTextCache->setColor(color);
}

void DateTimeEditComponent::setFont(std::shared_ptr<Font> font)
{
    mFont = font;
    updateTextCache();
}

void DateTimeEditComponent::onSizeChanged()
{
    mAutoSize = false;
    updateTextCache();
}

void DateTimeEditComponent::setUppercase(bool uppercase)
{
    mUppercase = uppercase;
    updateTextCache();
}

void DateTimeEditComponent::applyTheme(const std::shared_ptr<ThemeData>& theme,
        const std::string& view, const std::string& element, unsigned int properties)
{
    const ThemeData::ThemeElement* elem = theme->getElement(view, element, "datetime");

    if (!elem)
        return;

    // We set mAutoSize BEFORE calling GuiComponent::applyTheme because it calls
    // setSize(), which will call updateTextCache(), which will reset mSize if
    // mAutoSize == true, ignoring the theme's value.
    if (properties & ThemeFlags::SIZE)
        mAutoSize = !elem->has("size");

    GuiComponent::applyTheme(theme, view, element, properties);

    using namespace ThemeFlags;

    if (properties & COLOR && elem->has("color"))
        setColor(elem->get<unsigned int>("color"));

    if (properties & FORCE_UPPERCASE && elem->has("forceUppercase"))
        setUppercase(elem->get<bool>("forceUppercase"));

    setFont(Font::getFromTheme(elem, properties, mFont));
}

std::vector<HelpPrompt> DateTimeEditComponent::getHelpPrompts()
{
    std::vector<HelpPrompt> prompts;
    prompts.push_back(HelpPrompt("a", "edit date"));
    return prompts;
}