/* **************************************************************************************
 *    Author: Scott Mudge
 *    MAIL@SCOTTMUDGE.COM
 *
 *                                  MIT License
 *                                  -----------
 *                               MAIL@SCOTTMUDGE.COM
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 *
 * **************************************************************************************/
 // File Name: imgui_tabs.cpp
 // File Description: Custom ImGui tab system module


#include "imgui_tabs.h"

ImGui::ImGuiUserStyle::ImGuiUserStyle() {
    Colors[ImGuiUserCol_TabNormal] = ImVec4(0.65f, 0.65f, 0.68f, 1.00f);
    Colors[ImGuiUserCol_TabTitleTextNormal] = ImVec4(0.0f, 0.0f, 0.0f, 0.5f);
    Colors[ImGuiUserCol_TabTitleTextSelected] = ImVec4(1.0f, 1.0f, 1.0f, 1.00f);
    Colors[ImGuiUserCol_TabBorder] = Colors[ImGuiUserCol_TabNormal] * ImVec4(1.15f, 1.15f, 1.15f, 1.0f);
    Colors[ImGuiUserCol_TabBorderShadow] = Colors[ImGuiUserCol_TabNormal] * ImVec4(0.65f, 0.65f, 0.65f, 1.0f);
    Colors[ImGuiUserCol_TabHover] = Colors[ImGuiUserCol_TabNormal] * ImVec4(1.15f, 1.15f, 1.15f, 1.0f);
}

const ImU32 ImGui::GetColorU32(ImGuiUserCol_ idx, float alpha_mul) {
    ImVec4 c = UserStyle.Colors[idx];
    if (alpha_mul > 0.0f)
        c.w *= GImGui->Style.Alpha * alpha_mul;
    return ColorConvertFloat4ToU32(c);
}

void ImGui::_drawPartialRect(const ImVec2 a, const ImVec2 b, const float rounding, const int rounding_corners,
    ImDrawList* dl, const _EdgeType edges, const ImU32 color, const bool shadow,
    const _EdgeType shadow_edges, const float shadow_offset, const float shadow_alpha) {
    float r = rounding;
    r = ImMin(r, fabsf(b.x - a.x) * (((rounding_corners & (1 | 2)) == (1 | 2)) || ((rounding_corners & (4 | 8)) == (4 | 8)) ? 0.5f : 1.0f) - 1.0f);
    r = ImMin(r, fabsf(b.y - a.y) * (((rounding_corners & (1 | 8)) == (1 | 8)) || ((rounding_corners & (2 | 4)) == (2 | 4)) ? 0.5f : 1.0f) - 1.0f);

    if (r <= 0.0f || rounding_corners == 0)
    {
        if (edges & EDGE_TOP) {
            dl->PathLineTo(a);
            dl->PathLineTo(ImVec2(b.x, a.y));
            dl->PathStroke(color, false, 1.0f);
        } if (edges & EDGE_RIGHT) {
            dl->PathLineTo(ImVec2(b.x, a.y));
            dl->PathStroke(color, false, 1.0f);
            dl->PathLineTo(b);
        } if (edges & EDGE_BOTTOM) {
            dl->PathLineTo(b);
            dl->PathLineTo(ImVec2(a.x, b.y));
            dl->PathStroke(color, false, 1.0f);
        } if (edges & EDGE_LEFT) {
            dl->PathLineTo(ImVec2(a.x, b.y));
            dl->PathLineTo(a);
            dl->PathStroke(color, false, 1.0f);
        }
    }
    else
    {
        const float r0 = (rounding_corners & 1) ? r : 0.0f;
        const float r1 = (rounding_corners & 2) ? r : 0.0f;
        const float r2 = (rounding_corners & 4) ? r : 0.0f;
        const float r3 = (rounding_corners & 8) ? r : 0.0f;
        if (edges & EDGE_TOP) {
            dl->PathArcToFast(ImVec2(a.x + r0, a.y + r0), r0, 6, 9);
            dl->PathArcToFast(ImVec2(b.x - r1, a.y + r1), r1, 9, 12);
            dl->PathStroke(color, false, 1.0f);
        } if (edges & EDGE_RIGHT) {
            dl->PathArcToFast(ImVec2(b.x - r1, a.y + r1), r1, 9, 12);
            dl->PathArcToFast(ImVec2(b.x - r2, b.y - r2), r2, 0, 3);
            dl->PathStroke(color, false, 1.0f);
        } if (edges & EDGE_BOTTOM) {
            dl->PathArcToFast(ImVec2(b.x - r2, b.y - r2), r2, 0, 3);
            dl->PathArcToFast(ImVec2(a.x + r3, b.y - r3), r3, 3, 6);
            dl->PathStroke(color, false, 1.0f);
        } if (edges & EDGE_LEFT) {
            dl->PathArcToFast(ImVec2(a.x + r3, b.y - r3), r3, 3, 6);
            dl->PathArcToFast(ImVec2(a.x + r0, a.y + r0), r0, 6, 9);
            dl->PathStroke(color, false, 1.0f);
        }
        if (shadow) {
            const ImColor col = ImColor(0.0f, 0.0f, 0.0f, shadow_alpha);
            if (shadow_edges & EDGE_LEFT) {
                dl->PathArcToFast(ImVec2(a.x + r3 - shadow_offset, b.y - r3), r3, 3, 6);
                dl->PathArcToFast(ImVec2(a.x + r0 - shadow_offset, a.y + r0), r0, 6, 9);
                dl->PathLineTo(ImVec2(a.x, b.y));
                dl->PathFill(col);
            } if (shadow_edges & EDGE_RIGHT) {
                dl->PathArcToFast(ImVec2(b.x - r1 + shadow_offset, a.y + r1), r1, 9, 12);
                dl->PathArcToFast(ImVec2(b.x - r2 + shadow_offset, b.y - r2), r2, 0, 3);
                dl->PathLineTo(ImVec2(b.x, b.y));
                dl->PathFill(col);
            }
        }
    }
}

ImGui::TabBar::TabBar(const char* label, const ImVec2 tab_bar_size) {
    hash = ImHash(label, 0);
    size = tab_bar_size;
}

void ImGui::TabBar::setActiveTab(const unsigned idx) {
    activeTab = (int)idx; // This get's checked at the beginning of
}

const int ImGui::TabBar::getActiveTab() {
    return activeTab;
}

void ImGui::TabBar::_drawTabBarTop(const char* label) {
    if (!hasBeenInitialized)
        return;
    // Gather pointers and references
    ImGuiWindow* wind = ImGui::GetCurrentWindow();
    ImDrawList* dl = wind->DrawList;
    ImGuiDrawContext& dc = wind->DC;
    ImGuiStyle& style = ImGui::GetStyle();
    std::string str = label;

    barTitle = str.substr(0, str.find_first_of("#"));
    if (barTitle.length() > 0)
        ImGui::Text(std::string("\t" + barTitle).c_str(), "%s");

    // Get some geometric data
    const ImVec2 padding = style.WindowPadding;
    const ImVec2 frame_padding = style.FramePadding;
    ImVec2 pos = dc.CursorPos;
    const float division = ((wind->Size.x - 2 * padding.x) / (float)tabCount);

    // Compile-time constants
    static constexpr const float rounding = 6.0f;
    // This is the border shrink in px. Not sure why it needs to be 1, but it works. Adjust to your border size
    static constexpr const float shrink = 1.0f;

    const float tab_height = CalcTextSize(tabTitles[0]).y + (frame_padding.y * 2);

    float selected_offset = 0;
    _TabType selected_tab_type;
    ImVec2 selected_expands;
    _EdgeType selected_shadow_edges = EDGE_NONE;
    int selected_idx = 0;
    // Store maximum/minimum x value for clipping rect.
    const float max_x = wind->Pos.x + wind->Size.x - padding.x; // Used for clipping rect adjustment.
    const float min_x = wind->Pos.x + padding.x;

    if (activeTab > tabCount - 1)
        activeTab = tabCount - 1;

    // Idx of the selected tab
    newSelected = -1;

    // Draw the tabs
    for (int i = 0; i < tabCount; i++) {


        // Calculate offset
        const float offs = i * division;
        const bool selected = (activeTab == i);
        ImVec2 expands;
        if (!selected) {
            if (i == 0) {
                expands = ImVec2(0, 2);
            }
            else if (i == tabCount - 1) {
                expands = ImVec2(1, 0);
            }
            else {
                expands = ImVec2(1, 2);
            }

            const float xl = offs - expands.x + shrink;
            const float xr = offs + division - shrink + expands.y;
            const ImRect bb = ImRect(ImVec2(pos + ImVec2(xl, 0)), ImVec2(pos + ImVec2(xr, tab_height)));

            bool hovered, held;
            bool pressed = ButtonBehavior(bb, tabHashes[i], &hovered, &held);
            if (held)
                newSelected = i;


            ImU32 col;
            hovered ? col = GetColorU32(ImGuiUserCol_TabHover) : col = GetColorU32(ImGuiUserCol_TabNormal);

            // Draw background rect
            dl->AddRectFilled(bb.Min, bb.Max, col, rounding,
                ImGuiCorner_TopLeft | ImGuiCorner_TopRight);
            // Draw the border
            _drawPartialRect(bb.Min, bb.Max, rounding, ImGuiCorner_TopLeft | ImGuiCorner_TopRight, dl,
                (_EdgeType)(EDGE_LEFT | EDGE_RIGHT | EDGE_TOP), GetColorU32(ImGuiUserCol_TabBorderShadow));
            // Draw the text
            const ImVec2 text_size = CalcTextSize(tabTitles[i]);
            const ImVec2 text_pos = pos + ImVec2(offs + ((xr - xl) - text_size.x) / 2.0f, ((text_size.y - frame_padding.y * 2.0f) / 2.0f));
            dl->AddText(text_pos, GetColorU32(ImGuiUserCol_TabTitleTextNormal), tabTitles[i]);


        }
        else {
            selected_offset = offs;
            selected_idx = i;
            if (i == 0) {
                selected_expands = ImVec2(0, rounding);
                selected_shadow_edges = EDGE_RIGHT;
            }
            else if (i == tabCount - 1) {
                selected_expands = ImVec2(rounding, 0);
                selected_shadow_edges = EDGE_LEFT;
            }
            else {
                selected_expands = ImVec2(rounding, rounding);
                selected_shadow_edges = (_EdgeType)(EDGE_RIGHT | EDGE_LEFT);
            }

        }
    }
    const float xl = selected_offset - selected_expands.x + shrink;
    const float xr = selected_offset + division - shrink + selected_expands.y;
    const ImRect bb = ImRect(ImVec2(pos + ImVec2(xl, 0)), ImVec2(pos + ImVec2(xr, tab_height)));
    // Draw the selected tab on top of everything else
    dl->AddRectFilled(bb.Min, bb.Max, GetColorU32(ImGuiUserCol_TabNormal), rounding, ImGuiCorner_TopLeft | ImGuiCorner_TopRight);

    dl->AddRectFilled(bb.Min, bb.Max, ImColor(1.0f, 1.0f, 1.0f, 0.35f), rounding, ImGuiCorner_TopLeft | ImGuiCorner_TopRight);
    // Draw the border
    _drawPartialRect(bb.Min, bb.Max, rounding, ImGuiCorner_TopLeft | ImGuiCorner_TopRight, dl,
        (_EdgeType)(EDGE_LEFT | EDGE_RIGHT | EDGE_TOP), GetColorU32(ImGuiUserCol_TabBorderShadow),
        true, selected_shadow_edges);
    // Draw the text
    const ImVec2 text_size = CalcTextSize(tabTitles[selected_idx]);
    const ImVec2 text_pos = pos + ImVec2(selected_offset + ((xr - xl) - text_size.x) / 2.0f - selected_expands.x, ((text_size.y - frame_padding.y * 2.0f) / 2.0f));
    dl->AddText(text_pos + ImVec2(1, 1), GetColorU32(ImGuiUserCol_TabTitleTextNormal), tabTitles[selected_idx]); // Shadow
    dl->AddText(text_pos, GetColorU32(ImGuiUserCol_TabTitleTextSelected), tabTitles[selected_idx]);

    dc.CursorPos += ImVec2(0, tab_height + padding.y); // Add all the extra height used above.
    upperLeft = dc.CursorPos - ImVec2(0, padding.y);
    Indent(padding.x);
    corner_rounding = rounding;
    ImGui::PushClipRect(ImVec2(min_x, bb.Max.y), ImVec2(max_x, wind->ClipRect.Max.y), false);
}

void ImGui::TabBar::_drawTabBarBottom() {
    ImGuiWindow* wind = ImGui::GetCurrentWindow();
    ImDrawList* dl = wind->DrawList;
    ImGuiStyle& style = ImGui::GetStyle();
    ImGuiDrawContext& dc = wind->DC;

    const ImVec2 padding = style.WindowPadding;

    // dc.CursorPos.y = bottom of tabs + padding.y
    // wind->Size.y gives the full window height
    // the zero below the tabs is dc.CursorPos.y - padding.y
    // and if we wnt to add the tab height, we'll have to remove a constant
    // (= all the additional offsets used for the layout). FIXME : use the real name(s) instead
    const float height = dc.CursorPos.y - padding.y + wind->Size.y - 92.0f;
    const ImVec2 pos = ImVec2(wind->Pos.x + wind->Size.x - padding.x, height);

    // Draw the background in a given color + alpha
    dl->AddRectFilled(upperLeft, pos, ImColor(1.0f, 1.0f, 1.0f, 0.15f), corner_rounding, ImGuiCorner_BottomLeft | ImGuiCorner_BottomRight);
    // Draw the border in a given color + alpha
    dl->AddRect(upperLeft, pos, ImColor(1.0f, 1.0f, 1.0f, 0.35f), corner_rounding, ImGuiCorner_BottomLeft | ImGuiCorner_TopRight);

    dc.CursorPos += ImVec2(0, corner_rounding + 2.0f); // Add all the extra height used above.
    ImGui::PopClipRect();
}

void ImGui::TabBar::_setTabCount() {
    if (newSelected >= 0) {
        activeTab = newSelected;
    }

    // If the tab count changes, reinitialize the list.
    if (hasBeenInitialized && tabCount != idxCounter) {
        hasBeenInitialized = false;
        tabTitles.clear();
        tabHashes.clear();
        return;
    }
    tabCount = idxCounter;
    hasBeenInitialized = true;
}

ImGui::TabBar* ImGui::TabBarStack::getCurrentTabBar() {
    if (CurrentTabBar > TabBarCount) {
        std::cerr << "TabBar (Error @getCurrentTabBar()) -- CurrentTabBar > TabBarCount" << std::endl;
        return NULL;
    }
    return &TabBars[CurrentTabBar];
}

void ImGui::TabBarStack::clearIdxCountCurrentTabBar() {
    TabBars[CurrentTabBar].idxCounter = 0;
}

const bool ImGui::TabBarStack::doesTabBarExist(const ImU32 hash, unsigned int* const idx) {
    for (unsigned i = 0; i < TabBarCount; i++)
        if (hash == TabBars[i].hash) {
            if (idx)
                *idx = i;
            return true;
        }
    return false;
}

const bool ImGui::TabBarStack::doesTabBarExist(const char* id, unsigned int* const idx) {
    const ImU32 hash = ImHash(id, 0);
    for (unsigned i = 0; i < TabBarCount; i++)
        if (hash == TabBars[i].hash) {
            if (idx)
                *idx = i;
            return true;
        }

    *idx = 0;
    return false;
}

void ImGui::BeginTabBar(const char* label, const ImVec2 size) {
    // Pass this to doesTabBarExist() to get the index of the started TabBar
    unsigned idx;
    // If a tab bar doesn't exist, let's create one.
    if (!TabStack.doesTabBarExist(label, &idx)) {
        TabBar bar = TabBar(label, size);
        TabStack.TabBars.push_back(bar);
        TabStack.CurrentTabBar = TabStack.TabBarCount;
        TabStack.TabBarCount++;
    }
    else { // Set the current active tab bar
        TabStack.CurrentTabBar = idx;
        TabStack.clearIdxCountCurrentTabBar();
    }
    TabStack.getCurrentTabBar()->_drawTabBarTop(label);
}

const bool ImGui::AddTab(const char* title) {
    // Get current TabBar;
    TabBar* bar = TabStack.getCurrentTabBar();
    // Check to make sure there aren't any null pointers
    assert(bar != NULL);

    bar->idxCounter++; // Always increase the counter;

    if (bar->idxCounter > bar->tabCount)
        bar->hasBeenInitialized = false;

    if (!bar->hasBeenInitialized) {
        bar->tabTitles.push_back(title);
        bar->tabHashes.push_back(ImHash(std::string(title + std::to_string(bar->idxCounter)).c_str(), 0));
    }

    if (bar->activeTab != (bar->idxCounter - 1))
        return false;

    return bar->hasBeenInitialized;
}

void ImGui::DrawTabsBackground()
{
    TabBar* bar = TabStack.getCurrentTabBar();
    if (bar->hasBeenInitialized)
        bar->_drawTabBarBottom();
}

void ImGui::EndTabBar() {
    TabBar* bar = TabStack.getCurrentTabBar();
    bar->_setTabCount();
}

/* FIXME : unused ?
void ImGui::SetActiveTabOfCurrentTabBar(const unsigned idx) {
    TabStack.getCurrentTabBar()->setActiveTab(idx);
}
*/