//+------------------------------------------------------------------+
//|                                                          UIManager.mqh |
//|                                    Universal Buffer Reader EA v2.0 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025"
#property link      ""
#property version   "1.00"
#property strict

//+------------------------------------------------------------------+
//| CUIManager - Manages chart labels and manual mode UI              |
//+------------------------------------------------------------------+
class CUIManager
{
private:
    long                m_chart_id;
    bool                m_manual_mode;
    int                 m_magic_number;
    string              m_symbol;
    double              m_accumulated_loss;
    double              m_loss_percent;
    double              m_high_loss_threshold;

    // Logging
    bool                m_enable_debug;

public:
    //+------------------------------------------------------------------+
    //| Constructor                                                      |
    //+------------------------------------------------------------------+
    CUIManager()
    {
        m_chart_id = 0;
        m_manual_mode = false;
        m_magic_number = 0;
        m_symbol = "";
        m_accumulated_loss = 0;
        m_loss_percent = 0;
        m_high_loss_threshold = 0;
        m_enable_debug = false;
    }

    //+------------------------------------------------------------------+
    //| Destructor                                                       |
    //+------------------------------------------------------------------+
    ~CUIManager()
    {
        DeleteUI();
    }

    //+------------------------------------------------------------------+
    //| Set parameters                                                   |
    //+------------------------------------------------------------------+
    void SetParameters(
        long chart_id,
        bool manual_mode,
        int magic_number,
        string symbol,
        double high_loss_threshold,
        bool enable_debug = false
    )
    {
        // Validate parameters
        if(chart_id == 0)
        {
            Print("[ERROR] Invalid chart ID: 0");
        }
        m_chart_id = chart_id;

        if(magic_number <= 0)
        {
            Print("[ERROR] Invalid magic number: ", magic_number, ". Using default 24680");
            m_magic_number = 24680;
        }
        else
        {
            m_magic_number = magic_number;
        }

        if(symbol == "")
        {
            Print("[ERROR] Invalid symbol: empty string");
        }
        m_symbol = symbol;

        if(high_loss_threshold < 0)
        {
            Print("[ERROR] Invalid high loss threshold: ", high_loss_threshold, ". Using 0");
            m_high_loss_threshold = 0;
        }
        else
        {
            m_high_loss_threshold = high_loss_threshold;
        }

        m_manual_mode = manual_mode;
        m_enable_debug = enable_debug;

        if(m_enable_debug)
        {
            Print("[UIManager] Parameters set:");
            Print("  Chart ID: ", m_chart_id);
            Print("  Manual mode: ", m_manual_mode);
            Print("  Magic number: ", m_magic_number);
            Print("  Symbol: ", m_symbol);
            Print("  High loss threshold: ", m_high_loss_threshold, "%");
        }
    }

    //+------------------------------------------------------------------+
    //| Set debug mode                                                   |
    //+------------------------------------------------------------------+
    void SetDebugMode(bool enable_debug)
    {
        m_enable_debug = enable_debug;
    }

    //+------------------------------------------------------------------+
    //| Create UI elements                                              |
    //+------------------------------------------------------------------+
    void CreateUI()
    {
        if(m_enable_debug)
        {
            Print("[UIManager] Creating UI elements...");
        }

        if(m_chart_id == 0)
        {
            Print("[ERROR] Cannot create UI: Chart ID is 0");
            return;
        }

        CreateLossLabels();

        if(m_manual_mode)
        {
            CreateManualModeControls();
        }

        if(m_enable_debug)
        {
            Print("[UIManager] UI elements created successfully");
        }
    }

    //+------------------------------------------------------------------+
    //| Delete UI elements                                              |
    //+------------------------------------------------------------------+
    void DeleteUI()
    {
        if(m_enable_debug)
        {
            Print("[UIManager] Deleting UI elements...");
        }

        int deleted_count = 0;

        if(ObjectDelete(m_chart_id, "AccumLossLabel")) deleted_count++;
        if(ObjectDelete(m_chart_id, "AccumLossPercentLabel")) deleted_count++;

        if(m_manual_mode)
        {
            if(ObjectDelete(m_chart_id, "ManualTPLabel")) deleted_count++;
            if(ObjectDelete(m_chart_id, "ManualTPEdit")) deleted_count++;
            if(ObjectDelete(m_chart_id, "ManualSLLabel")) deleted_count++;
            if(ObjectDelete(m_chart_id, "ManualSLEdit")) deleted_count++;
            if(ObjectDelete(m_chart_id, "ManualTradeButton")) deleted_count++;
        }

        if(m_enable_debug)
        {
            Print("[UIManager] Deleted ", deleted_count, " UI elements");
        }
    }

    //+------------------------------------------------------------------+
    //| Update loss display                                             |
    //+------------------------------------------------------------------+
    void UpdateLossDisplay(double accumulated_loss, double loss_percent)
    {
        m_accumulated_loss = accumulated_loss;
        m_loss_percent = loss_percent;

        // Validate inputs
        if(accumulated_loss < 0)
        {
            Print("[WARNING] Invalid accumulated loss: ", accumulated_loss, ". Using 0");
            accumulated_loss = 0;
        }

        if(loss_percent < 0)
        {
            Print("[WARNING] Invalid loss percent: ", loss_percent, "%. Using 0%");
            loss_percent = 0;
        }

        string loss_text = "Accum. Loss: " + DoubleToString(accumulated_loss, 2);
        string percent_text = "Loss % of Bal: " + DoubleToString(loss_percent, 2) + "%";

        color label_color = clrWhite;
        bool is_high_loss = false;

        if(m_high_loss_threshold > 0 && loss_percent >= m_high_loss_threshold)
        {
            label_color = clrOrangeRed;
            is_high_loss = true;
        }

        // Update labels
        ObjectSetString(m_chart_id, "AccumLossLabel", OBJPROP_TEXT, loss_text);
        ObjectSetInteger(m_chart_id, "AccumLossLabel", OBJPROP_COLOR, label_color);

        ObjectSetString(m_chart_id, "AccumLossPercentLabel", OBJPROP_TEXT, percent_text);
        ObjectSetInteger(m_chart_id, "AccumLossPercentLabel", OBJPROP_COLOR, label_color);

        if(m_enable_debug)
        {
            Print("[UIManager] Loss display updated: ", loss_text, ", ", percent_text,
                  (is_high_loss ? " [HIGH LOSS WARNING]" : ""));
        }
    }

    //+------------------------------------------------------------------+
    //| Update manual mode UI                                           |
    //+------------------------------------------------------------------+
    void UpdateManualModeUI()
    {
        // Update any dynamic manual mode elements if needed
    }

    //+------------------------------------------------------------------+
    //| Get manual TP from UI                                           |
    //+------------------------------------------------------------------+
    double GetManualTP()
    {
        if(!m_manual_mode)
        {
            if(m_enable_debug)
            {
                Print("[UIManager] Manual mode not enabled, returning TP = 0");
            }
            return 0;
        }

        string tp_str = ObjectGetString(m_chart_id, "ManualTPEdit", OBJPROP_TEXT);
        double tp_value = StringToDouble(tp_str);

        if(m_enable_debug)
        {
            Print("[UIManager] Manual TP: ", tp_value);
        }

        return tp_value;
    }

    //+------------------------------------------------------------------+
    //| Get manual SL from UI                                           |
    //+------------------------------------------------------------------+
    double GetManualSL()
    {
        if(!m_manual_mode)
        {
            if(m_enable_debug)
            {
                Print("[UIManager] Manual mode not enabled, returning SL = 0");
            }
            return 0;
        }

        string sl_str = ObjectGetString(m_chart_id, "ManualSLEdit", OBJPROP_TEXT);
        double sl_value = StringToDouble(sl_str);

        if(m_enable_debug)
        {
            Print("[UIManager] Manual SL: ", sl_value);
        }

        return sl_value;
    }

    //+------------------------------------------------------------------+
    //| Check if manual trade button was clicked                        |
    //+------------------------------------------------------------------+
    bool IsManualTradeButtonClicked()
    {
        if(!m_manual_mode) return false;

        // This will be checked in OnChartEvent
        return false;
    }

private:
    //+------------------------------------------------------------------+
    //| Create loss display labels                                      |
    //+------------------------------------------------------------------+
    void CreateLossLabels()
    {
        if(m_enable_debug)
        {
            Print("[UIManager] Creating loss display labels...");
        }

        // Accumulated Loss Label
        if(!ObjectCreate(m_chart_id, "AccumLossLabel", OBJ_LABEL, 0, 0, 0))
        {
            Print("[ERROR] Failed to create AccumLossLabel. Error: ", GetLastError());
        }
        else
        {
            ObjectSetString(m_chart_id, "AccumLossLabel", OBJPROP_TEXT, "Accum. Loss: Loading...");
            ObjectSetInteger(m_chart_id, "AccumLossLabel", OBJPROP_CORNER, CORNER_LEFT_LOWER);
            ObjectSetInteger(m_chart_id, "AccumLossLabel", OBJPROP_XDISTANCE, 10);
            ObjectSetInteger(m_chart_id, "AccumLossLabel", OBJPROP_YDISTANCE, 40);
            ObjectSetInteger(m_chart_id, "AccumLossLabel", OBJPROP_FONTSIZE, 10);
            ObjectSetInteger(m_chart_id, "AccumLossLabel", OBJPROP_COLOR, clrWhite);
        }

        // Loss Percent Label
        if(!ObjectCreate(m_chart_id, "AccumLossPercentLabel", OBJ_LABEL, 0, 0, 0))
        {
            Print("[ERROR] Failed to create AccumLossPercentLabel. Error: ", GetLastError());
        }
        else
        {
            ObjectSetString(m_chart_id, "AccumLossPercentLabel", OBJPROP_TEXT, "Loss % of Bal: Loading...");
            ObjectSetInteger(m_chart_id, "AccumLossPercentLabel", OBJPROP_CORNER, CORNER_LEFT_LOWER);
            ObjectSetInteger(m_chart_id, "AccumLossPercentLabel", OBJPROP_XDISTANCE, 10);
            ObjectSetInteger(m_chart_id, "AccumLossPercentLabel", OBJPROP_YDISTANCE, 20);
            ObjectSetInteger(m_chart_id, "AccumLossPercentLabel", OBJPROP_FONTSIZE, 10);
            ObjectSetInteger(m_chart_id, "AccumLossPercentLabel", OBJPROP_COLOR, clrWhite);
        }

        if(m_enable_debug)
        {
            Print("[UIManager] Loss display labels created");
        }
    }

    //+------------------------------------------------------------------+
    //| Create manual mode controls                                     |
    //+------------------------------------------------------------------+
    void CreateManualModeControls()
    {
        if(m_enable_debug)
        {
            Print("[UIManager] Creating manual mode controls...");
        }

        int created_count = 0;

        // Manual TP Label
        if(ObjectCreate(m_chart_id, "ManualTPLabel", OBJ_LABEL, 0, 0, 0))
        {
            ObjectSetString(m_chart_id, "ManualTPLabel", OBJPROP_TEXT, "Take Profit:");
            ObjectSetInteger(m_chart_id, "ManualTPLabel", OBJPROP_CORNER, CORNER_RIGHT_UPPER);
            ObjectSetInteger(m_chart_id, "ManualTPLabel", OBJPROP_XDISTANCE, 180);
            ObjectSetInteger(m_chart_id, "ManualTPLabel", OBJPROP_YDISTANCE, 50);
            created_count++;
        }
        else
        {
            Print("[ERROR] Failed to create ManualTPLabel. Error: ", GetLastError());
        }

        // Manual TP Edit
        if(ObjectCreate(m_chart_id, "ManualTPEdit", OBJ_EDIT, 0, 0, 0))
        {
            ObjectSetInteger(m_chart_id, "ManualTPEdit", OBJPROP_CORNER, CORNER_RIGHT_UPPER);
            ObjectSetInteger(m_chart_id, "ManualTPEdit", OBJPROP_XDISTANCE, 110);
            ObjectSetInteger(m_chart_id, "ManualTPEdit", OBJPROP_YDISTANCE, 50);
            ObjectSetInteger(m_chart_id, "ManualTPEdit", OBJPROP_XSIZE, 60);
            created_count++;
        }
        else
        {
            Print("[ERROR] Failed to create ManualTPEdit. Error: ", GetLastError());
        }

        // Manual SL Label
        if(ObjectCreate(m_chart_id, "ManualSLLabel", OBJ_LABEL, 0, 0, 0))
        {
            ObjectSetString(m_chart_id, "ManualSLLabel", OBJPROP_TEXT, "Stop Loss:");
            ObjectSetInteger(m_chart_id, "ManualSLLabel", OBJPROP_CORNER, CORNER_RIGHT_UPPER);
            ObjectSetInteger(m_chart_id, "ManualSLLabel", OBJPROP_XDISTANCE, 180);
            ObjectSetInteger(m_chart_id, "ManualSLLabel", OBJPROP_YDISTANCE, 70);
            created_count++;
        }
        else
        {
            Print("[ERROR] Failed to create ManualSLLabel. Error: ", GetLastError());
        }

        // Manual SL Edit
        if(ObjectCreate(m_chart_id, "ManualSLEdit", OBJ_EDIT, 0, 0, 0))
        {
            ObjectSetInteger(m_chart_id, "ManualSLEdit", OBJPROP_CORNER, CORNER_RIGHT_UPPER);
            ObjectSetInteger(m_chart_id, "ManualSLEdit", OBJPROP_XDISTANCE, 110);
            ObjectSetInteger(m_chart_id, "ManualSLEdit", OBJPROP_YDISTANCE, 70);
            ObjectSetInteger(m_chart_id, "ManualSLEdit", OBJPROP_XSIZE, 60);
            created_count++;
        }
        else
        {
            Print("[ERROR] Failed to create ManualSLEdit. Error: ", GetLastError());
        }

        // Manual Trade Button
        if(ObjectCreate(m_chart_id, "ManualTradeButton", OBJ_BUTTON, 0, 0, 0))
        {
            ObjectSetString(m_chart_id, "ManualTradeButton", OBJPROP_TEXT, "Open Market Order");
            ObjectSetInteger(m_chart_id, "ManualTradeButton", OBJPROP_CORNER, CORNER_RIGHT_UPPER);
            ObjectSetInteger(m_chart_id, "ManualTradeButton", OBJPROP_XDISTANCE, 110);
            ObjectSetInteger(m_chart_id, "ManualTradeButton", OBJPROP_YDISTANCE, 95);
            ObjectSetInteger(m_chart_id, "ManualTradeButton", OBJPROP_XSIZE, 130);
            ObjectSetInteger(m_chart_id, "ManualTradeButton", OBJPROP_YSIZE, 25);
            created_count++;
        }
        else
        {
            Print("[ERROR] Failed to create ManualTradeButton. Error: ", GetLastError());
        }

        if(m_enable_debug)
        {
            Print("[UIManager] Created ", created_count, " manual mode controls");
        }
    }
};
//+------------------------------------------------------------------+