TTW_Bot/randommanager.cpp

#include "randommanager.h"
#include <QTableWidget>
#include <QDebug>

RandomManager::RandomManager(QObject *parent)
    : QObject(parent)
    , m_database(nullptr)
{
}

RandomManager::~RandomManager()
{
    // Сохраняем данные при уничтожении
    if (m_database) {
        saveToDatabase();
    }
}

bool RandomManager::initialize(uDataBase *database)
{
    if (!database || !database->isConnected()) {
        qWarning() << "RandomManager: База данных не подключена";
        return false;
    }

    m_database = database;
    return loadFromDatabase();
}

bool RandomManager::addRange(const QString &name, int startValue, int endValue)
{
    // Проверка входных данных
    if (name.isEmpty()) {
        qWarning() << "RandomManager: Нельзя добавить диапазон с пустым именем";
        return false;
    }

    if (!isValidRange(startValue, endValue)) {
        qWarning() << "RandomManager: Некорректный диапазон:" << startValue << "-" << endValue;
        return false;
    }

    // Проверка на дубликат
    if (contains(name)) {
        qWarning() << "RandomManager: Диапазон с именем" << name << "уже существует";
        return false;
    }

    // Добавляем в список
    RandomStruct newRange(name, startValue, endValue);
    m_ranges.append(newRange);

    // Сохраняем в БД
    if (!saveToDatabase()) {
        m_ranges.removeLast(); // Откатываем если не удалось сохранить
        return false;
    }

    emit rangeAdded(name, startValue, endValue);
    emit dataChanged();

    qDebug() << "RandomManager: Добавлен диапазон" << name << startValue << "-" << endValue;
    return true;
}

bool RandomManager::removeRange(const QString &name)
{
    int index = findIndex(name);
    if (index == -1) {
        qWarning() << "RandomManager: Диапазон" << name << "не найден";
        return false;
    }

    // Сохраняем данные для сигнала
    RandomStruct removedRange = m_ranges.at(index);

    // Удаляем из списка
    m_ranges.removeAt(index);

    // Сохраняем в БД
    if (!saveToDatabase()) {
        // Откатываем изменения
        m_ranges.insert(index, removedRange);
        return false;
    }

    emit rangeRemoved(name);
    emit dataChanged();

    qDebug() << "RandomManager: Удален диапазон" << name;
    return true;
}

bool RandomManager::updateRange(const QString &oldName, const QString &newName,
                                int startValue, int endValue)
{
    int index = findIndex(oldName);
    if (index == -1) {
        qWarning() << "RandomManager: Диапазон" << oldName << "не найден";
        return false;
    }

    if (!isValidRange(startValue, endValue)) {
        qWarning() << "RandomManager: Некорректный диапазон:" << startValue << "-" << endValue;
        return false;
    }

    // Проверяем, не занято ли новое имя другим диапазоном (если имя изменилось)
    if (oldName != newName && contains(newName)) {
        qWarning() << "RandomManager: Имя" << newName << "уже занято";
        return false;
    }

    // Сохраняем старые данные для отката
    RandomStruct oldRange = m_ranges.at(index);

    // Обновляем
    m_ranges[index].name = newName;
    m_ranges[index].startValue = startValue;
    m_ranges[index].endValue = endValue;

    // Сохраняем в БД
    if (!saveToDatabase()) {
        // Откатываем изменения
        m_ranges[index] = oldRange;
        return false;
    }

    emit rangeUpdated(oldName, newName);
    emit dataChanged();

    qDebug() << "RandomManager: Обновлен диапазон" << oldName << "->" << newName
             << startValue << "-" << endValue;
    return true;
}

bool RandomManager::contains(const QString &name) const
{
    return findIndex(name) != -1;
}

int RandomManager::getRandomValue(const QString &name) const
{
    int index = findIndex(name);
    if (index == -1) {
        qWarning() << "RandomManager: Диапазон" << name << "не найден";
        return 0;
    }

    const RandomStruct &range = m_ranges.at(index);
    if (range.startValue == range.endValue) {
        return range.startValue;
    }

    int min = qMin(range.startValue, range.endValue);
    int max = qMax(range.startValue, range.endValue);

    return QRandomGenerator::global()->bounded(min, max + 1);
}

QPair<int, int> RandomManager::getRange(const QString &name) const
{
    int index = findIndex(name);
    if (index == -1) {
        return qMakePair(0, 0);
    }

    const RandomStruct &range = m_ranges.at(index);
    return qMakePair(range.startValue, range.endValue);
}

bool RandomManager::saveToDatabase()
{
    if (!m_database) {
        qWarning() << "RandomManager: База данных не установлена";
        return false;
    }

    // Создаем временную таблицу для сохранения
    QTableWidget tempTable;

    // Настраиваем таблицу
    QStringList headers;
    headers << "Имя" << "От" << "До";
    tempTable.setColumnCount(headers.size());
    tempTable.setHorizontalHeaderLabels(headers);

    // Заполняем таблицу данными
    tempTable.setRowCount(m_ranges.size());

    for (int i = 0; i < m_ranges.size(); ++i) {
        const RandomStruct &range = m_ranges.at(i);

        // Имя
        QTableWidgetItem *nameItem = new QTableWidgetItem(range.name);
        tempTable.setItem(i, 0, nameItem);

        // Начальное значение
        QTableWidgetItem *startItem = new QTableWidgetItem(QString::number(range.startValue));
        startItem->setTextAlignment(Qt::AlignCenter);
        tempTable.setItem(i, 1, startItem);

        // Конечное значение
        QTableWidgetItem *endItem = new QTableWidgetItem(QString::number(range.endValue));
        endItem->setTextAlignment(Qt::AlignCenter);
        tempTable.setItem(i, 2, endItem);
    }

    // Сохраняем в БД
    // Используем метод SaveTableWidget, который сохраняет данные в соответствующую таблицу
    m_database->SaveTableWidget(&tempTable);

    qDebug() << "RandomManager: Сохранено" << m_ranges.size() << "диапазонов в БД";
    return true;
}

bool RandomManager::loadFromDatabase()
{
    if (!m_database) {
        qWarning() << "RandomManager: База данных не установлена";
        return false;
    }

    // Создаем временную таблицу для загрузки
    QTableWidget tempTable;

    // Настраиваем таблицу
    QStringList headers;
    headers << "Имя" << "От" << "До";
    tempTable.setColumnCount(headers.size());
    tempTable.setHorizontalHeaderLabels(headers);

    // Загружаем данные из БД
    m_database->LoadTableWidget(&tempTable);

    // Очищаем текущий список
    m_ranges.clear();

    // Заполняем список из таблицы
    for (int row = 0; row < tempTable.rowCount(); ++row) {
        QTableWidgetItem *nameItem = tempTable.item(row, 0);
        QTableWidgetItem *startItem = tempTable.item(row, 1);
        QTableWidgetItem *endItem = tempTable.item(row, 2);

        if (!nameItem || !startItem || !endItem) {
            qWarning() << "RandomManager: Пропущена строка" << row << "из-за отсутствия данных";
            continue;
        }

        QString name = nameItem->text().trimmed();
        if (name.isEmpty()) {
            qWarning() << "RandomManager: Пропущена строка" << row << "с пустым именем";
            continue;
        }

        bool okStart, okEnd;
        int startValue = startItem->text().toInt(&okStart);
        int endValue = endItem->text().toInt(&okEnd);

        if (!okStart || !okEnd) {
            qWarning() << "RandomManager: Некорректные числовые значения в строке" << row;
            continue;
        }

        if (!isValidRange(startValue, endValue)) {
            qWarning() << "RandomManager: Некорректный диапазон в строке" << row
                       << startValue << "-" << endValue;
            continue;
        }

        m_ranges.append(RandomStruct(name, startValue, endValue));
    }

    qDebug() << "RandomManager: Загружено" << m_ranges.size() << "диапазонов из БД";
    emit dataChanged();
    return true;
}

bool RandomManager::isValidRange(int start, int end) const
{
    // Допускаются любые целые числа, даже если start > end
    // Мы будем использовать qMin и qMax при генерации случайного числа
    return true;
}

int RandomManager::findIndex(const QString &name) const
{
    for (int i = 0; i < m_ranges.size(); ++i) {
        if (m_ranges.at(i).name == name) {
            return i;
        }
    }
    return -1;
}