#include "uft3table.h"
#include "utils/logmanager.h"
#include "utils/Constants.h"
#include "utils/Constants.h"
#include <QFile>
#include <QDir>
#include <QXmlStreamReader>
#include <QJsonObject>
#include <QJsonArray>

Uft3Table::Uft3Table(QObject *parent) : QObject(parent)
{
}

QMap<QString, QMap<QString, QVariant>> Uft3Table::loadData(const QString& dirPath)
{
    QMap<QString, QMap<QString, QVariant>> resultMap;
    
    QString scanPath = PathUtils::normPath(dirPath);
    scanPath += Constants::MetaPaths::Uft3StructDir;
    
    LogManager::instance()->log(QString("加载UFT3表结构目录: %1").arg(scanPath));
    
    QDir dir(scanPath);
    if (!dir.exists()) {
        LogManager::instance()->logError(QString("表结构目录不存在: %1").arg(scanPath));
        return resultMap;
    }
    
    scanDirectory(scanPath, resultMap);
    
    for (const QString& filePath : _fileList) {
        if (filePath.contains(Constants::MetaPaths::Uft3StructExt)) {
            parseTableFile(filePath, resultMap);
        }
    }
    
    LogManager::instance()->log(QString("UFT3表结构加载完成，共 %1 条").arg(resultMap.size()));
    
    return resultMap;
}

void Uft3Table::scanDirectory(const QString& dirPath, QMap<QString, QMap<QString, QVariant>>& resultMap)
{
    QDir dir(dirPath);
    
    QFileInfoList fileList = dir.entryInfoList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);
    
    for (const QFileInfo& fileInfo : fileList) {
        if (fileInfo.isDir()) {
            scanDirectory(fileInfo.absoluteFilePath(), resultMap);
        }
        else if (fileInfo.isFile()) {
            _fileList.append(fileInfo.absoluteFilePath());
        }
    }
}

void Uft3Table::parseTableFile(const QString& filePath, QMap<QString, QMap<QString, QVariant>>& resultMap)
{
    QString sFilePath = PathUtils::normPath(filePath);
    
    QFile file(sFilePath);
    if (!file.open(QIODevice::ReadOnly)) {
        LogManager::instance()->logError(QString("无法打开表结构文件: %1").arg(sFilePath));
        return;
    }
    
    QByteArray data = file.readAll();
    file.close();
    
    QXmlStreamReader xml(data);
    
    QString tableEngName = "";
    QString tablePath = "";
    QString chineseName = "";
    QString objectId = "";
    QString spaceName = "";
    QStringList fieldList;
    QMap<QString, QStringList> indexMap;
    QMap<QString, QStringList> uniqueIndexMap;
    QMap<QString, QStringList> globalIndexMap;
    
    int lastSlash = sFilePath.lastIndexOf('/');
    if (lastSlash != -1) {
        tableEngName = sFilePath.mid(lastSlash + 1);
        tableEngName = tableEngName.left(tableEngName.indexOf(Constants::MetaPaths::Uft3StructExt));
    }
    
    int uftstructurePos = sFilePath.indexOf("uftstructure");
    if (uftstructurePos != -1) {
        tablePath = sFilePath.mid(uftstructurePos);
    }
    
    while (!xml.atEnd() && !xml.hasError()) {
        QXmlStreamReader::TokenType token = xml.readNext();
        
        if (token == QXmlStreamReader::StartElement) {
            QString elementName = xml.name().toString();
            QXmlStreamAttributes attrs = xml.attributes();
            
            if (elementName == "Structure") {          
                if (attrs.hasAttribute("chineseName")) {
                    chineseName = attrs.value("chineseName").toString();
                }

                if (attrs.hasAttribute("objectId")) {
                    objectId = attrs.value("objectId").toString();
                }
                
                if (attrs.hasAttribute("space")) {
                    spaceName = attrs.value("space").toString();
                }                           
            }
            else if (elementName == "properties") {
                QString fieldId = attrs.value("id").toString();
                if (!fieldId.isEmpty()) {
                    fieldList.append(fieldId);
                }
            }
            else if (elementName == "indexs") {
                QString indexName = attrs.value("name").toString();
                QStringList indexFieldList;
                bool isUnique = !attrs.hasAttribute("containerType");
                bool isGlobal = false;
                
                if (attrs.hasAttribute("global") && attrs.value("global").toString() == "true") {
                    isGlobal = true;
                }
                
                while (!xml.atEnd() && !xml.hasError()) {
                    token = xml.readNext();
                    
                    if (token == QXmlStreamReader::StartElement && xml.name().toString() == "items") {
                        QString fieldAttr = xml.attributes().value("attrname").toString();
                        if (!fieldAttr.isEmpty()) {
                            indexFieldList.append(fieldAttr);
                        }
                    }
                    else if (token == QXmlStreamReader::EndElement && xml.name().toString() == "indexs") {
                        break;
                    }
                }
                
                if (!indexName.isEmpty() && !indexFieldList.isEmpty()) {
                    indexMap[indexName] = indexFieldList;
                    if (isUnique) {
                        uniqueIndexMap[indexName] = indexFieldList;
                    }
                    if (isGlobal) {
                        globalIndexMap[indexName] = indexFieldList;
                    }
                }
            }
        }
    }
    
    QString sUser = "";
    if (spaceName == "HS_UFT_DATA") {
        sUser = "hs_uft";
    }
    else if (spaceName == "HS_UARG_DATA") {
        sUser = "hs_uarg";
    }
    else if (spaceName == "HS_USMS_DATA") {
        sUser = "hs_usms";
    }
    
    QMap<QString, QVariant> tableInfoDetail;
    tableInfoDetail["tableEngName"] = tableEngName;
    tableInfoDetail["tablePath"] = tablePath;
    tableInfoDetail["chineseName"] = chineseName;
    tableInfoDetail["objectId"] = objectId;
    tableInfoDetail["fieldList"] = fieldList;
    tableInfoDetail["user"] = sUser;
    
    QJsonObject indexMapJson;
    for (const QString& key : indexMap.keys()) {
        indexMapJson[key] = QJsonArray::fromStringList(indexMap[key]);
    }
    tableInfoDetail["indexMap"] = indexMapJson;
    
    QJsonObject uniqueIndexMapJson;
    for (const QString& key : uniqueIndexMap.keys()) {
        uniqueIndexMapJson[key] = QJsonArray::fromStringList(uniqueIndexMap[key]);
    }
    tableInfoDetail["uniqueIndexMap"] = uniqueIndexMapJson;
    
    QJsonObject globalIndexMapJson;
    for (const QString& key : globalIndexMap.keys()) {
        globalIndexMapJson[key] = QJsonArray::fromStringList(globalIndexMap[key]);
    }
    tableInfoDetail["globalIndexMap"] = globalIndexMapJson;
    
    if (!tableEngName.isEmpty()) {
        resultMap[tableEngName] = tableInfoDetail;
    }
}