calculatorwidget.cpp

#include "calculatorwidget.h"
#include "database.h"
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QGridLayout>
#include <QFormLayout>
#include <QScrollArea>
#include <QHeaderView>
#include <QMessageBox>
#include <QSplitter>
#include <QFrame>
#include <QCompleter>

static void makeSearchable(QComboBox* combo) {
    combo->setEditable(true);
    combo->setInsertPolicy(QComboBox::NoInsert);
    auto* c = new QCompleter(combo->model(), combo);
    c->setFilterMode(Qt::MatchContains);
    c->setCaseSensitivity(Qt::CaseInsensitive);
    combo->setCompleter(c);
}

static QString secondsToHMSCalc(double secs) {
    int h = (int)secs / 3600;
    int m = ((int)secs % 3600) / 60;
    double s = secs - h*3600 - m*60;
    return QString("%1h %2m %3s").arg(h).arg(m).arg(s, 0, 'f', 1);
}

CalculatorWidget::CalculatorWidget(QWidget* parent) : QWidget(parent) {
    auto* layout = new QVBoxLayout(this);

    // Top: technique selector + button
    auto* top = new QHBoxLayout;
    top->addWidget(new QLabel("Technique:"));
    m_technique = new QComboBox;
    makeSearchable(m_technique);
    top->addWidget(m_technique, 1);
    m_btn_calc = new QPushButton("Calculate");
    m_btn_calc->setStyleSheet("font-weight: bold;");
    top->addWidget(m_btn_calc);
    m_btn_save_own = new QPushButton("Save own prices");
    m_btn_save_own->setToolTip("Saves the calculated price of each income item as 'own price'.\n"
                               "Useful when your technique produces inputs used in other techniques.");
    m_btn_save_own->setEnabled(false);
    top->addWidget(m_btn_save_own);
    layout->addLayout(top);

    // Splitter: left = average session, right = results
    auto* splitter = new QSplitter(Qt::Horizontal);
    layout->addWidget(splitter, 1);

    // ---- Left: average session ----
    auto* left_widget = new QWidget;
    auto* left_layout = new QVBoxLayout(left_widget);
    left_layout->addWidget(new QLabel("<b>Average Session</b>"));

    m_lbl_sessions = new QLabel("Sessions: -");
    m_lbl_avg_time = new QLabel("Average time: -");
    left_layout->addWidget(m_lbl_sessions);
    left_layout->addWidget(m_lbl_avg_time);

    left_layout->addWidget(new QLabel("Average items:"));
    m_avg_items_table = new QTableWidget(0, 4);
    m_avg_items_table->setHorizontalHeaderLabels({"Item", "Avg Qty", "Type", "Effective Price"});
    m_avg_items_table->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
    m_avg_items_table->setEditTriggers(QAbstractItemView::NoEditTriggers);
    m_avg_items_table->setAlternatingRowColors(true);
    left_layout->addWidget(m_avg_items_table);

    left_layout->addWidget(new QLabel("Equipment depreciation:"));
    m_avg_equip_table = new QTableWidget(0, 4);
    m_avg_equip_table->setHorizontalHeaderLabels({"Equipment", "Avg Uses", "Price/Use", "Avg Cost"});
    m_avg_equip_table->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
    m_avg_equip_table->setEditTriggers(QAbstractItemView::NoEditTriggers);
    m_avg_equip_table->setAlternatingRowColors(true);
    left_layout->addWidget(m_avg_equip_table);

    splitter->addWidget(left_widget);

    // ---- Right: results ----
    auto* right_widget = new QWidget;
    auto* right_layout = new QVBoxLayout(right_widget);
    right_layout->addWidget(new QLabel("<b>Price Results</b>"));

    auto* summary_group = new QGroupBox("Financial Summary");
    auto* sg_layout = new QFormLayout(summary_group);
    m_lbl_total_value   = new QLabel("-");
    m_lbl_expense_cost  = new QLabel("-");
    m_lbl_depreciation  = new QLabel("-");
    m_lbl_remaining     = new QLabel("-");
    m_lbl_remaining->setStyleSheet("font-weight: bold; font-size: 14px;");
    sg_layout->addRow("Total value (time × melt):", m_lbl_total_value);
    sg_layout->addRow("(-) Expense cost:", m_lbl_expense_cost);
    sg_layout->addRow("(-) Equipment depreciation:", m_lbl_depreciation);
    sg_layout->addRow("(=) Remaining value to distribute:", m_lbl_remaining);
    right_layout->addWidget(summary_group);

    right_layout->addWidget(new QLabel("Expenses (cost per item):"));
    m_expense_result_table = new QTableWidget(0, 4);
    m_expense_result_table->setHorizontalHeaderLabels({"Item", "Avg Qty", "Price/Unit", "Total"});
    m_expense_result_table->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
    m_expense_result_table->setEditTriggers(QAbstractItemView::NoEditTriggers);
    m_expense_result_table->setAlternatingRowColors(true);
    right_layout->addWidget(m_expense_result_table);

    right_layout->addWidget(new QLabel("Income (suggested price per item via proportional allocation):"));
    m_income_result_table = new QTableWidget(0, 5);
    m_income_result_table->setHorizontalHeaderLabels({"Item", "Avg Qty", "Price/Unit", "Total", "Capped?"});
    m_income_result_table->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
    m_income_result_table->setEditTriggers(QAbstractItemView::NoEditTriggers);
    m_income_result_table->setAlternatingRowColors(true);
    right_layout->addWidget(m_income_result_table);

    splitter->addWidget(right_widget);
    splitter->setStretchFactor(0, 1);
    splitter->setStretchFactor(1, 2);

    connect(m_btn_calc,     &QPushButton::clicked, this, &CalculatorWidget::calculate);
    connect(m_btn_save_own, &QPushButton::clicked, this, &CalculatorWidget::saveOwnPrices);

    refreshTechniques();
}

void CalculatorWidget::refreshTechniques() {
    m_technique->clear();
    for (const auto& t : Database::instance().getTechniques())
        m_technique->addItem(t.name, t.id);
}

void CalculatorWidget::calculate() {
    int tech_id = m_technique->currentData().toInt();
    if (tech_id <= 0) {
        QMessageBox::warning(this, "Warning", "Select a technique.");
        return;
    }

    m_last_avg    = Database::instance().calculateAverageSession(tech_id);
    if (m_last_avg.session_count == 0) {
        QMessageBox::warning(this, "Warning", "No sessions registered for this technique.");
        return;
    }

    m_last_result = Database::instance().calculatePrice(m_last_avg);
    showAverageSession(m_last_avg);
    showPriceResult(m_last_result, m_last_avg);
    m_btn_save_own->setEnabled(true);
}

void CalculatorWidget::showAverageSession(const AverageSession& avg) {
    m_lbl_sessions->setText(QString("Sessions: %1").arg(avg.session_count));
    m_lbl_avg_time->setText(QString("Average time: %1").arg(secondsToHMSCalc(avg.avg_duration_sec)));

    m_avg_items_table->setRowCount(0);
    for (const auto& asi : avg.items) {
        double eff_price = Database::instance().getEffectivePrice(asi.item_id, avg.technique_id);
        int row = m_avg_items_table->rowCount();
        m_avg_items_table->insertRow(row);
        m_avg_items_table->setItem(row, 0, new QTableWidgetItem(asi.item_name));
        m_avg_items_table->setItem(row, 1, new QTableWidgetItem(
            QString::number(asi.avg_quantity, 'f', 3)));
        m_avg_items_table->setItem(row, 2, new QTableWidgetItem(
            asi.is_expense ? "Expense" : "Income"));
        m_avg_items_table->setItem(row, 3, new QTableWidgetItem(
            eff_price >= 0 ? QString::number(eff_price, 'f', 4) : "no price"));

        if (asi.is_expense)
            m_avg_items_table->item(row, 2)->setBackground(QColor(255, 220, 220));
        else
            m_avg_items_table->item(row, 2)->setBackground(QColor(220, 255, 220));
    }

    m_avg_equip_table->setRowCount(0);
    for (const auto& aeu : avg.equipment_uses) {
        double eq_price = -1.0;
        double depr_per_use = 0.0;
        double depr_avg = 0.0;
        if (aeu.equipment_item_id >= 0) {
            eq_price = Database::instance().getEffectivePrice(aeu.equipment_item_id, avg.technique_id);
        }

        // Get total_uses
        int total_uses = 1;
        for (const auto& eq : Database::instance().getEquipmentTypes()) {
            if (eq.id == aeu.equipment_type_id) { total_uses = eq.total_uses; break; }
        }
        if (eq_price >= 0 && total_uses > 0) {
            depr_per_use = eq_price / total_uses;
            depr_avg     = depr_per_use * aeu.avg_uses;
        }

        int row = m_avg_equip_table->rowCount();
        m_avg_equip_table->insertRow(row);
        m_avg_equip_table->setItem(row, 0, new QTableWidgetItem(aeu.equipment_name));
        m_avg_equip_table->setItem(row, 1, new QTableWidgetItem(
            QString::number(aeu.avg_uses, 'f', 2)));
        m_avg_equip_table->setItem(row, 2, new QTableWidgetItem(
            depr_per_use > 0 ? QString::number(depr_per_use, 'f', 4) : "no price"));
        m_avg_equip_table->setItem(row, 3, new QTableWidgetItem(
            depr_avg > 0 ? QString::number(depr_avg, 'f', 4) : "no price"));
    }
}

void CalculatorWidget::showPriceResult(const PriceCalculationResult& result, const AverageSession& avg) {
    m_lbl_total_value->setText(QString::number(result.total_value, 'f', 4));
    m_lbl_expense_cost->setText(QString::number(result.total_expense_cost, 'f', 4));
    m_lbl_depreciation->setText(QString::number(result.depreciation_cost, 'f', 4));

    double check = result.total_value - result.total_expense_cost - result.depreciation_cost;
    QString remaining_str = QString::number(result.remaining_value, 'f', 4);
    if (result.remaining_value < 0)
        m_lbl_remaining->setStyleSheet("font-weight:bold;font-size:14px;color:red;");
    else
        m_lbl_remaining->setStyleSheet("font-weight:bold;font-size:14px;color:green;");
    m_lbl_remaining->setText(remaining_str);

    // Expense items
    m_expense_result_table->setRowCount(0);
    for (const auto& ipr : result.expense_items) {
        int row = m_expense_result_table->rowCount();
        m_expense_result_table->insertRow(row);
        m_expense_result_table->setItem(row, 0, new QTableWidgetItem(ipr.item_name));
        m_expense_result_table->setItem(row, 1, new QTableWidgetItem(
            QString::number(ipr.quantity, 'f', 3)));
        m_expense_result_table->setItem(row, 2, new QTableWidgetItem(
            QString::number(ipr.price_per_unit, 'f', 4)));
        m_expense_result_table->setItem(row, 3, new QTableWidgetItem(
            QString::number(ipr.total_price, 'f', 4)));
    }

    // Income items
    m_income_result_table->setRowCount(0);
    for (const auto& ipr : result.income_items) {
        int row = m_income_result_table->rowCount();
        m_income_result_table->insertRow(row);
        m_income_result_table->setItem(row, 0, new QTableWidgetItem(ipr.item_name));
        m_income_result_table->setItem(row, 1, new QTableWidgetItem(
            QString::number(ipr.quantity, 'f', 3)));
        m_income_result_table->setItem(row, 2, new QTableWidgetItem(
            QString::number(ipr.price_per_unit, 'f', 4)));
        m_income_result_table->setItem(row, 3, new QTableWidgetItem(
            QString::number(ipr.total_price, 'f', 4)));
        auto* saturado_item = new QTableWidgetItem(ipr.capped_at_market ? "Yes (market cap)" : "");
        if (ipr.capped_at_market)
            saturado_item->setBackground(QColor(255, 255, 180));
        m_income_result_table->setItem(row, 4, saturado_item);
    }
}

void CalculatorWidget::saveOwnPrices() {
    if (m_last_avg.technique_id < 0) return;
    int tech_id = m_last_avg.technique_id;

    // Remove old prices for this technique to avoid stale values
    Database::instance().deleteOwnPricesByTechnique(tech_id);

    if (!m_last_result.can_produce) return;

    int count = 0;
    for (const auto& ipr : m_last_result.income_items) {
        if (ipr.price_per_unit > 0) {
            Database::instance().setOwnPrice(ipr.item_id, tech_id, ipr.price_per_unit);
            // Mark item to use own price as cost in other techniques
            Item it = Database::instance().getItem(ipr.item_id);
            if (it.id >= 0 && it.preferred_price_source != PriceSource::Own) {
                it.preferred_price_source = PriceSource::Own;
                Database::instance().updateItem(it);
            }
            ++count;
        }
    }
    QMessageBox::information(this, "Saved",
        QString("Own prices saved for %1 item(s).\n"
                "These items now use the production price as cost in other techniques.")
        .arg(count));
    emit pricesSaved();
}