sessionswidget.cpp

#include "sessionswidget.h"
#include "database.h"
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QFormLayout>
#include <QGroupBox>
#include <QHeaderView>
#include <QMessageBox>
#include <QScrollArea>
#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);
}

// ---- SessionDialog ----

SessionDialog::SessionDialog(QWidget* parent, int edit_id, int default_technique_id)
    : QDialog(parent), m_edit_id(edit_id)
{
    setWindowTitle(edit_id < 0 ? "New Session" : "Edit Session");
    setMinimumSize(700, 600);

    auto* scroll_content = new QWidget;
    auto* main_form = new QVBoxLayout(scroll_content);

    // Technique
    auto* form = new QFormLayout;
    m_technique = new QComboBox;
    for (const auto& t : Database::instance().getTechniques())
        m_technique->addItem(t.name, t.id);
    makeSearchable(m_technique);
    if (default_technique_id >= 0) {
        int idx = m_technique->findData(default_technique_id);
        if (idx >= 0) m_technique->setCurrentIndex(idx);
    }
    form->addRow("Technique:", m_technique);

    // Duration
    auto* dur_layout = new QHBoxLayout;
    m_hours   = new QSpinBox; m_hours->setMinimum(0);   m_hours->setMaximum(999);
    m_minutes = new QSpinBox; m_minutes->setMinimum(0); m_minutes->setMaximum(59);
    m_seconds = new QSpinBox; m_seconds->setMinimum(0); m_seconds->setMaximum(59);
    dur_layout->addWidget(m_hours);   dur_layout->addWidget(new QLabel("h"));
    dur_layout->addWidget(m_minutes); dur_layout->addWidget(new QLabel("m"));
    dur_layout->addWidget(m_seconds); dur_layout->addWidget(new QLabel("s"));
    dur_layout->addStretch();
    form->addRow("Duration:", dur_layout);

    m_date = new QDateTimeEdit(QDateTime::currentDateTime());
    m_date->setDisplayFormat("dd/MM/yyyy HH:mm");
    form->addRow("Date/time:", m_date);

    m_notes = new QTextEdit;
    m_notes->setMaximumHeight(50);
    form->addRow("Notes:", m_notes);

    main_form->addLayout(form);

    // Items table
    auto* items_group = new QGroupBox("Session Items");
    auto* items_layout = new QVBoxLayout(items_group);
    auto* items_hint = new QLabel("<b>Expense</b> = consumed item (ingredient, fuel). "
                                   "<b>Income</b> = obtained item (product).");
    items_hint->setWordWrap(true);
    items_layout->addWidget(items_hint);

    m_items_table = new QTableWidget(0, 4);
    m_items_table->setHorizontalHeaderLabels({"Item", "Quantity", "Type", ""});
    m_items_table->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
    m_items_table->setMinimumHeight(160);
    items_layout->addWidget(m_items_table);

    auto* item_btns = new QHBoxLayout;
    auto* add_expense = new QPushButton("+ Expense");
    auto* add_income  = new QPushButton("+ Income");
    item_btns->addWidget(add_expense);
    item_btns->addWidget(add_income);
    item_btns->addStretch();
    items_layout->addLayout(item_btns);
    main_form->addWidget(items_group);

    // Equipment table
    auto* equip_group = new QGroupBox("Equipment Used (depreciation)");
    auto* equip_layout = new QVBoxLayout(equip_group);
    m_equip_table = new QTableWidget(0, 3);
    m_equip_table->setHorizontalHeaderLabels({"Equipment", "Uses", ""});
    m_equip_table->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
    m_equip_table->setMinimumHeight(100);
    equip_layout->addWidget(m_equip_table);
    auto* add_equip = new QPushButton("+ Equipment");
    equip_layout->addWidget(add_equip);
    main_form->addWidget(equip_group);

    // Scroll area
    auto* scroll = new QScrollArea;
    scroll->setWidget(scroll_content);
    scroll->setWidgetResizable(true);
    scroll->setFrameShape(QFrame::NoFrame);

    auto* btns = new QHBoxLayout;
    auto* ok  = new QPushButton("Save");
    auto* can = new QPushButton("Cancel");
    btns->addStretch();
    btns->addWidget(ok);
    btns->addWidget(can);

    auto* outer = new QVBoxLayout(this);
    outer->addWidget(scroll);
    outer->addLayout(btns);

    connect(add_expense, &QPushButton::clicked, this, [this]{ addItemRow(-1, 1.0, true); });
    connect(add_income,  &QPushButton::clicked, this, [this]{ addItemRow(-1, 1.0, false); });
    connect(add_equip,   &QPushButton::clicked, this, [this]{ addEquipmentRow(); });
    connect(ok,  &QPushButton::clicked, this, &QDialog::accept);
    connect(can, &QPushButton::clicked, this, &QDialog::reject);

    // Load existing data
    if (edit_id >= 0) {
        Session s = Database::instance().getSession(edit_id);
        int idx = m_technique->findData(s.technique_id);
        if (idx >= 0) m_technique->setCurrentIndex(idx);
        int total = s.duration_seconds;
        m_hours->setValue(total / 3600);
        m_minutes->setValue((total % 3600) / 60);
        m_seconds->setValue(total % 60);
        m_date->setDateTime(QDateTime::fromString(s.session_date, "yyyy-MM-dd HH:mm:ss"));
        m_notes->setPlainText(s.notes);

        for (const auto& si : Database::instance().getSessionItems(edit_id))
            addItemRow(si.item_id, si.quantity, si.is_expense);
        for (const auto& se : Database::instance().getSessionEquipment(edit_id))
            addEquipmentRow(se.equipment_type_id, se.uses);
    }
}

void SessionDialog::addItemRow(int item_id, double qty, bool is_expense) {
    int row = m_items_table->rowCount();
    m_items_table->insertRow(row);

    auto* combo = new QComboBox;
    for (const auto& it : Database::instance().getItems())
        combo->addItem(it.name, it.id);
    makeSearchable(combo);
    if (item_id >= 0) {
        int idx = combo->findData(item_id);
        if (idx >= 0) combo->setCurrentIndex(idx);
    }
    m_items_table->setCellWidget(row, 0, combo);

    auto* spin = new QDoubleSpinBox;
    spin->setMinimum(0.0001);
    spin->setMaximum(999999);
    spin->setDecimals(3);
    spin->setValue(qty);
    m_items_table->setCellWidget(row, 1, spin);

    auto* type_combo = new QComboBox;
    type_combo->addItem("Expense", true);
    type_combo->addItem("Income", false);
    type_combo->setCurrentIndex(is_expense ? 0 : 1);
    m_items_table->setCellWidget(row, 2, type_combo);

    auto* del_btn = new QPushButton("X");
    del_btn->setMaximumWidth(30);
    connect(del_btn, &QPushButton::clicked, this, [this, del_btn]{
        for (int r = 0; r < m_items_table->rowCount(); ++r) {
            if (m_items_table->cellWidget(r, 3) == del_btn) {
                m_items_table->removeRow(r);
                break;
            }
        }
    });
    m_items_table->setCellWidget(row, 3, del_btn);
}

void SessionDialog::addEquipmentRow(int eq_id, int uses) {
    auto equip_types = Database::instance().getEquipmentTypes();
    if (equip_types.isEmpty()) {
        QMessageBox::information(this, "Info",
            "No equipment registered. Register in the Equipment tab first.");
        return;
    }

    int row = m_equip_table->rowCount();
    m_equip_table->insertRow(row);

    auto* combo = new QComboBox;
    for (const auto& eq : equip_types)
        combo->addItem(eq.name, eq.id);
    makeSearchable(combo);
    if (eq_id >= 0) {
        int idx = combo->findData(eq_id);
        if (idx >= 0) combo->setCurrentIndex(idx);
    }
    m_equip_table->setCellWidget(row, 0, combo);

    auto* spin = new QSpinBox;
    spin->setMinimum(1);
    spin->setMaximum(99999);
    spin->setValue(uses);
    m_equip_table->setCellWidget(row, 1, spin);

    auto* del_btn = new QPushButton("X");
    del_btn->setMaximumWidth(30);
    connect(del_btn, &QPushButton::clicked, this, [this, del_btn]{
        for (int r = 0; r < m_equip_table->rowCount(); ++r) {
            if (m_equip_table->cellWidget(r, 2) == del_btn) {
                m_equip_table->removeRow(r);
                break;
            }
        }
    });
    m_equip_table->setCellWidget(row, 2, del_btn);
}

Session SessionDialog::session() const {
    Session s;
    s.id               = m_edit_id;
    s.technique_id     = m_technique->currentData().toInt();
    s.duration_seconds = m_hours->value() * 3600
                       + m_minutes->value() * 60
                       + m_seconds->value();
    s.session_date     = m_date->dateTime().toString("yyyy-MM-dd HH:mm:ss");
    s.notes            = m_notes->toPlainText().trimmed();
    return s;
}

QList<SessionItem> SessionDialog::sessionItems() const {
    QList<SessionItem> list;
    for (int r = 0; r < m_items_table->rowCount(); ++r) {
        auto* combo      = qobject_cast<QComboBox*>(m_items_table->cellWidget(r, 0));
        auto* spin       = qobject_cast<QDoubleSpinBox*>(m_items_table->cellWidget(r, 1));
        auto* type_combo = qobject_cast<QComboBox*>(m_items_table->cellWidget(r, 2));
        if (!combo || !spin || !type_combo) continue;
        SessionItem si;
        si.item_id    = combo->currentData().toInt();
        si.quantity   = spin->value();
        si.is_expense = type_combo->currentData().toBool();
        list << si;
    }
    return list;
}

QList<SessionEquipment> SessionDialog::sessionEquipment() const {
    QList<SessionEquipment> list;
    for (int r = 0; r < m_equip_table->rowCount(); ++r) {
        auto* combo = qobject_cast<QComboBox*>(m_equip_table->cellWidget(r, 0));
        auto* spin  = qobject_cast<QSpinBox*>(m_equip_table->cellWidget(r, 1));
        if (!combo || !spin) continue;
        SessionEquipment se;
        se.equipment_type_id = combo->currentData().toInt();
        se.uses              = spin->value();
        list << se;
    }
    return list;
}

// ---- SessionsWidget ----

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

    auto* filter_layout = new QHBoxLayout;
    filter_layout->addWidget(new QLabel("Filter by technique:"));
    m_filter_technique = new QComboBox;
    m_filter_technique->addItem("(all)", -1);
    for (const auto& t : Database::instance().getTechniques())
        m_filter_technique->addItem(t.name, t.id);
    makeSearchable(m_filter_technique);
    filter_layout->addWidget(m_filter_technique);
    filter_layout->addStretch();

    m_btn_add  = new QPushButton("New Session");
    m_btn_edit = new QPushButton("Edit");
    m_btn_del  = new QPushButton("Delete");
    filter_layout->addWidget(m_btn_add);
    filter_layout->addWidget(m_btn_edit);
    filter_layout->addWidget(m_btn_del);
    layout->addLayout(filter_layout);

    m_table = new QTableWidget;
    m_table->setColumnCount(6);
    m_table->setHorizontalHeaderLabels({"ID", "Technique", "Duration", "Date", "Items (income)", "Notes"});
    m_table->horizontalHeader()->setSectionResizeMode(1, QHeaderView::Stretch);
    m_table->horizontalHeader()->setSectionResizeMode(4, QHeaderView::Stretch);
    m_table->setSelectionBehavior(QAbstractItemView::SelectRows);
    m_table->setEditTriggers(QAbstractItemView::NoEditTriggers);
    m_table->setAlternatingRowColors(true);
    layout->addWidget(m_table);

    connect(m_btn_add,  &QPushButton::clicked, this, &SessionsWidget::addSession);
    connect(m_btn_edit, &QPushButton::clicked, this, &SessionsWidget::editSession);
    connect(m_btn_del,  &QPushButton::clicked, this, &SessionsWidget::deleteSession);
    connect(m_table, &QTableWidget::doubleClicked, this, &SessionsWidget::editSession);
    connect(m_filter_technique, QOverload<int>::of(&QComboBox::currentIndexChanged),
            this, &SessionsWidget::onTechniqueFilterChanged);

    refresh();
}

static QString secondsToHMS(int secs) {
    int h = secs / 3600, m = (secs % 3600) / 60, s = secs % 60;
    return QString("%1h %2m %3s").arg(h).arg(m, 2, 10, QChar('0')).arg(s, 2, 10, QChar('0'));
}

void SessionsWidget::refresh() {
    int tech_id = m_filter_technique->currentData().toInt();

    m_table->setRowCount(0);
    auto techniques = Database::instance().getTechniques();
    QMap<int,QString> tech_names;
    for (const auto& t : techniques) tech_names[t.id] = t.name;

    for (const auto& s : Database::instance().getSessions(tech_id)) {
        // Summary of income items
        QStringList income_items;
        for (const auto& si : Database::instance().getSessionItems(s.id)) {
            if (!si.is_expense) {
                Item it = Database::instance().getItem(si.item_id);
                income_items << QString("%1×%2").arg(si.quantity, 0, 'f', 1).arg(it.name);
            }
        }

        int row = m_table->rowCount();
        m_table->insertRow(row);
        m_table->setItem(row, 0, new QTableWidgetItem(QString::number(s.id)));
        m_table->setItem(row, 1, new QTableWidgetItem(tech_names.value(s.technique_id, "?")));
        m_table->setItem(row, 2, new QTableWidgetItem(secondsToHMS(s.duration_seconds)));
        m_table->setItem(row, 3, new QTableWidgetItem(s.session_date));
        m_table->setItem(row, 4, new QTableWidgetItem(income_items.join(", ")));
        m_table->setItem(row, 5, new QTableWidgetItem(s.notes));
    }
}

void SessionsWidget::onTechniqueFilterChanged() {
    refresh();
}

void SessionsWidget::addSession() {
    int tech_id = m_filter_technique->currentData().toInt();
    SessionDialog dlg(this, -1, tech_id);
    if (dlg.exec() != QDialog::Accepted) return;

    Session s = dlg.session();
    if (s.duration_seconds <= 0) {
        QMessageBox::warning(this, "Error", "Duration must be greater than zero.");
        return;
    }

    int id = Database::instance().addSession(s);
    if (id < 0) {
        QMessageBox::critical(this, "Error", Database::instance().lastError());
        return;
    }
    Database::instance().setSessionItems(id, dlg.sessionItems());
    Database::instance().setSessionEquipment(id, dlg.sessionEquipment());
    refresh();
}

void SessionsWidget::editSession() {
    int row = m_table->currentRow();
    if (row < 0) return;
    int id = m_table->item(row, 0)->text().toInt();

    SessionDialog dlg(this, id);
    if (dlg.exec() != QDialog::Accepted) return;

    Session s = dlg.session();
    if (!Database::instance().updateSession(s)) {
        QMessageBox::critical(this, "Error", Database::instance().lastError());
        return;
    }
    Database::instance().setSessionItems(id, dlg.sessionItems());
    Database::instance().setSessionEquipment(id, dlg.sessionEquipment());
    refresh();
}

void SessionsWidget::deleteSession() {
    int row = m_table->currentRow();
    if (row < 0) return;
    int id = m_table->item(row, 0)->text().toInt();
    if (QMessageBox::question(this, "Confirm", "Delete session?") != QMessageBox::Yes) return;
    if (!Database::instance().deleteSession(id)) {
        QMessageBox::critical(this, "Error", Database::instance().lastError());
        return;
    }
    refresh();
}