#include "urldatabase.h".h"
#include <QSqlQuery>
#include <QSqlError>
#include <QDebug>

ImageManager* ImageManager::m_instance = nullptr;
QMutex ImageManager::m_mutex;

ImageManager::ImageManager(QObject *parent) : QObject(parent)
{

}

ImageManager::~ImageManager()
{
    if (m_db.isOpen()) {
        m_db.close();
    }
}

ImageManager* ImageManager::instance()
{
    QMutexLocker locker(&m_mutex);
    if (!m_instance) {
        m_instance = new ImageManager();
    }
    return m_instance;
}

bool ImageManager::initialize(const QString &dbPath)
{
    m_db = QSqlDatabase::addDatabase("QSQLITE", "image_manager_connection");
    m_db.setDatabaseName(dbPath);

    if (!m_db.open()) {
        qWarning() << "Failed to open database:" << m_db.lastError().text();
        return false;
    }

    return createTables();
}

bool ImageManager::createTables()
{
    QSqlQuery query(m_db);

    // 创建域名表
    if (!query.exec("CREATE TABLE IF NOT EXISTS domains ("
                    "domain_id INTEGER PRIMARY KEY AUTOINCREMENT, "
                    "domain TEXT NOT NULL UNIQUE)")) {
        qWarning() << "Failed to create domains table:" << query.lastError().text();
        return false;
    }

    // 创建用户表
    if (!query.exec("CREATE TABLE IF NOT EXISTS users ("
                    "user_id INTEGER PRIMARY KEY AUTOINCREMENT, "
                    "username TEXT NOT NULL UNIQUE)")) {
        qWarning() << "Failed to create users table:" << query.lastError().text();
        return false;
    }

    // 创建域名-用户关联表（确保唯一）
    if (!query.exec("CREATE TABLE IF NOT EXISTS domain_users ("
                    "id INTEGER PRIMARY KEY AUTOINCREMENT, "
                    "domain_id INTEGER NOT NULL, "
                    "user_id INTEGER NOT NULL, "
                    "UNIQUE(domain_id, user_id), "
                    "FOREIGN KEY(domain_id) REFERENCES domains(domain_id), "
                    "FOREIGN KEY(user_id) REFERENCES users(user_id))")) {
        qWarning() << "Failed to create domain_users table:" << query.lastError().text();
        return false;
    }

    // 创建图片URL表
    if (!query.exec("CREATE TABLE IF NOT EXISTS image_urls ("
                    "url_id INTEGER PRIMARY KEY AUTOINCREMENT, "
                    "domain_user_id INTEGER NOT NULL, "
                    "image_url TEXT NOT NULL, "
                    "upload_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP, "
                    "FOREIGN KEY(domain_user_id) REFERENCES domain_users(id), "
                    "UNIQUE(domain_user_id, image_url))")) {
        qWarning() << "Failed to create image_urls table:" << query.lastError().text();
        return false;
    }

    return true;
}

bool ImageManager::addDomain(const QString &domain)
{
    QSqlQuery query(m_db);
    query.prepare("INSERT OR IGNORE INTO domains (domain) VALUES (?)");
    query.addBindValue(domain);
    return query.exec();
}

bool ImageManager::addUser(const QString &user)
{
    QSqlQuery query(m_db);
    query.prepare("INSERT OR IGNORE INTO users (username) VALUES (?)");
    query.addBindValue(user);
    return query.exec();
}

int ImageManager::getDomainId(const QString &domain)
{
    QSqlQuery query(m_db);
    query.prepare("SELECT domain_id FROM domains WHERE domain = ?");
    query.addBindValue(domain);
    if (query.exec() && query.next()) {
        return query.value(0).toInt();
    }
    return -1;
}

int ImageManager::getUserId(const QString &user)
{
    QSqlQuery query(m_db);
    query.prepare("SELECT user_id FROM users WHERE username = ?");
    query.addBindValue(user);
    if (query.exec() && query.next()) {
        return query.value(0).toInt();
    }
    return -1;
}

bool ImageManager::addDomainUser(const QString &domain, const QString &user)
{
    if (!addDomain(domain) || !addUser(user)) {
        return false;
    }

    int domainId = getDomainId(domain);
    int userId = getUserId(user);

    if (domainId == -1 || userId == -1) {
        return false;
    }

    QSqlQuery query(m_db);
    query.prepare("INSERT OR IGNORE INTO domain_users (domain_id, user_id) VALUES (?, ?)");
    query.addBindValue(domainId);
    query.addBindValue(userId);
    return query.exec();
}

bool ImageManager::addImageUrl(const QString &domain, const QString &user, const QUrl &imageUrl)
{
    int domainId = getDomainId(domain);
    int userId = getUserId(user);

    if (domainId == -1 || userId == -1) {
        return false;
    }

    QSqlQuery query(m_db);
    query.prepare("SELECT id FROM domain_users WHERE domain_id = ? AND user_id = ?");
    query.addBindValue(domainId);
    query.addBindValue(userId);

    if (!query.exec() || !query.next()) {
        return false;
    }

    int domainUserId = query.value(0).toInt();

    query.prepare("INSERT OR IGNORE INTO image_urls (domain_user_id, image_url) VALUES (?, ?)");
    query.addBindValue(domainUserId);
    query.addBindValue(imageUrl.toString());
    return query.exec();
}

QList<QUrl> ImageManager::getImageUrls(const QString &domain, const QString &user)
{
    QList<QUrl> urls;

    int domainId = getDomainId(domain);
    int userId = getUserId(user);

    if (domainId == -1 || userId == -1) {
        return urls;
    }

    QSqlQuery query(m_db);
    query.prepare("SELECT i.image_url FROM image_urls i "
                  "JOIN domain_users du ON i.domain_user_id = du.id "
                  "WHERE du.domain_id = ? AND du.user_id = ? "
                  "ORDER BY i.upload_time DESC");
    query.addBindValue(domainId);
    query.addBindValue(userId);

    if (query.exec()) {
        while (query.next()) {
            urls.append(QUrl(query.value(0).toString()));
        }
    }

    return urls;
}

bool ImageManager::containsDomainUser(const QString &domain, const QString &user)
{
    int domainId = getDomainId(domain);
    int userId = getUserId(user);

    if (domainId == -1 || userId == -1) {
        return false;
    }

    QSqlQuery query(m_db);
    query.prepare("SELECT 1 FROM domain_users WHERE domain_id = ? AND user_id = ?");
    query.addBindValue(domainId);
    query.addBindValue(userId);

    return query.exec() && query.next();
}