#include "workspace/FileEntry.h"

#include <QFileInfo>

#include "common/SpdLogger.h"

// 颜色转换辅助函数
QString QColorToString(const QColor& color) {
    return QString("%1,%2,%3").arg(color.red()).arg(color.green()).arg(color.blue());
}

QColor StringToQColor(const QString& colorStr) {
    QStringList rgb = colorStr.split(',');
    if (rgb.size() == 3) {
        bool ok1, ok2, ok3;
        int r = rgb[0].toInt(&ok1);
        int g = rgb[1].toInt(&ok2);
        int b = rgb[2].toInt(&ok3);
        if (ok1 && ok2 && ok3) {
            return QColor(r, g, b);
        }
    }
    return QColor(); // 返回无效颜色
}

void FileEntry::SetPath(const QString& path) { 
    QFileInfo fileInfo(path);
    if (!fileInfo.exists()) {
        LOG_WARN("file not exist: {}", path.toLocal8Bit().constData());
        return;
    }
    path_ = fileInfo.path();
    fileName_ = fileInfo.fileName();
}

// Factory function implementations
std::shared_ptr<FileEntry> CreateFileEntry(FileEntryType type, const QString& filePath) {
    switch (type) {
        case FileEntryType::Curve:
            return CreateFileEntryCurve(filePath);
        case FileEntryType::Surface:
            return CreateFileEntrySurface(filePath);
        case FileEntryType::Table:
            return CreateFileEntryTable(filePath);
        case FileEntryType::Light:
            return CreateFileEntryLight(filePath);
        default:
            LOG_ERROR("Unknown FileEntryType: {}", static_cast<int>(type));
            return nullptr;
    }
}

std::shared_ptr<FileEntryCurve> CreateFileEntryCurve(const QString& filePath) {
    QFileInfo fileInfo(filePath);
    if (!fileInfo.exists()) {
        LOG_ERROR("File does not exist: {}", filePath.toUtf8().constData());
        return nullptr;
    }
    
    auto fileEntry = std::make_shared<FileEntryCurve>();
    fileEntry->SetPath(filePath);
    fileEntry->SetName(fileInfo.baseName()); // Use base name as default display name
    
    return fileEntry;
}

std::shared_ptr<FileEntry> CreateFileEntrySurface(const QString& filePath) {
    QFileInfo fileInfo(filePath);
    if (!fileInfo.exists()) {
        LOG_ERROR("File does not exist: {}", filePath.toUtf8().constData());
        return nullptr;
    }
    
    auto fileEntry = std::make_shared<FileEntrySurface>();
    fileEntry->SetPath(filePath);
    fileEntry->SetName(fileInfo.baseName()); // Use base name as default display name
    
    return fileEntry;
}

std::shared_ptr<FileEntryTable> CreateFileEntryTable(const QString& filePath) {
    QFileInfo fileInfo(filePath);
    if (!filePath.isEmpty() && !fileInfo.exists()) {
        LOG_ERROR("File does not exist: {}", filePath.toUtf8().constData());
        return nullptr;
    }
    
    auto fileEntry = std::make_shared<FileEntryTable>();
    fileEntry->SetPath(filePath);
    fileEntry->SetName(fileInfo.baseName()); // Use base name as default display name
    
    return fileEntry;
}

std::shared_ptr<FileEntryLight> CreateFileEntryLight(const QString& filePath) {
    QFileInfo fileInfo(filePath);
    if (!fileInfo.exists()) {
        LOG_ERROR("File does not exist: {}", filePath.toUtf8().constData());
        return nullptr;
    }

    auto fileEntry = std::make_shared<FileEntryLight>();
    fileEntry->SetPath(filePath);
    fileEntry->SetName(fileInfo.baseName()); // Use base name as default display name

    return fileEntry;
}

// Factory functions for creating empty FileEntry objects (for XML parsing)
std::shared_ptr<FileEntry> CreateEmptyFileEntry(FileEntryType type) {
    switch (type) {
        case FileEntryType::Curve:
            return CreateEmptyFileEntryCurve();
        case FileEntryType::Surface:
            return CreateEmptyFileEntrySurface();
        case FileEntryType::Table:
            return CreateEmptyFileEntryTable();
        case FileEntryType::Light:
            return CreateEmptyFileEntryLight();
        default:
            LOG_ERROR("Unknown FileEntryType: {}", static_cast<int>(type));
            return nullptr;
    }
}

std::shared_ptr<FileEntryCurve> CreateEmptyFileEntryCurve() {
    auto fileEntry = std::make_shared<FileEntryCurve>();
    // Don't set path or name - these will be set during XML parsing
    return fileEntry;
}

std::shared_ptr<FileEntry> CreateEmptyFileEntrySurface() {
    auto fileEntry = std::make_shared<FileEntrySurface>();
    // Don't set path or name - these will be set during XML parsing
    return fileEntry;
}

std::shared_ptr<FileEntryTable> CreateEmptyFileEntryTable() {
    auto fileEntry = std::make_shared<FileEntryTable>();
    // Don't set path or name - these will be set during XML parsing
    return fileEntry;
}

std::shared_ptr<FileEntryLight> CreateEmptyFileEntryLight() {
    auto fileEntry = std::make_shared<FileEntryLight>();
    // Don't set path or name - these will be set during XML parsing
    return fileEntry;
}

// FileEntrySurface method implementations
void FileEntrySurface::SetChartProperties(const ChartProperties& properties) {
    chartProperties_ = properties;
}

const FileEntrySurface::ChartProperties& FileEntrySurface::GetChartProperties() const {
    return chartProperties_;
}

void FileEntrySurface::AddSurfaceProperty(const SurfaceProperty& surface) {
    surfaceProperties_.append(surface);
}

void FileEntrySurface::RemoveSurfaceProperty(int index) {
    if (index >= 0 && index < surfaceProperties_.size()) {
        surfaceProperties_.removeAt(index);
    }
}

void FileEntrySurface::SetSurfaceProperty(int index, const SurfaceProperty& surface) {
    if (index >= 0 && index < surfaceProperties_.size()) {
        surfaceProperties_[index] = surface;
    }
}

const FileEntrySurface::SurfaceProperties& FileEntrySurface::GetSurfaceProperties() const {
    return surfaceProperties_;
}

FileEntrySurface* FileEntrySurface::AsSurface() {
    return this;
}

void FileEntrySurface::SetDescription(const QString& description) {
    description_ = description;
}

const QString& FileEntrySurface::GetDescription() const {
    return description_;
}

// FileEntryTable method implementations
void FileEntryTable::SetChartProperties(const ChartProperties& properties) {
    chartProperties_ = properties;
}

const FileEntryTable::ChartProperties& FileEntryTable::GetChartProperties() const {
    return chartProperties_;
}

void FileEntryTable::AddTableProperty(const TableProperty& table) {
    tableProperties_.append(table);
}

void FileEntryTable::RemoveTableProperty(int index) {
    if (index >= 0 && index < tableProperties_.size()) {
        tableProperties_.removeAt(index);
    }
}

void FileEntryTable::SetTableProperty(int index, const TableProperty& table) {
    if (index >= 0 && index < tableProperties_.size()) {
        tableProperties_[index] = table;
    }
}

const FileEntryTable::TableProperties& FileEntryTable::GetTableProperties() const {
    return tableProperties_;
}

void FileEntryTable::SetTableHeaders(const QStringList& headers) {
    tableHeaders_ = headers;
}

void FileEntryTable::SetTableHeaders(const QString& headerString) {
    tableHeaders_ = headerString.split(',', Qt::SkipEmptyParts);
    // Trim whitespace from each header
    for (QString& header : tableHeaders_) {
        header = header.trimmed();
    }
}

const QStringList& FileEntryTable::GetTableHeaders() const {
    return tableHeaders_;
}

FileEntryTable* FileEntryTable::AsTable() {
    return this;
}

void FileEntryTable::SetDescription(const QString& description) {
    description_ = description;
}

const QString& FileEntryTable::GetDescription() const {
    return description_;
}

// FileEntryCurve SaveFiles implementation
bool FileEntryCurve::SaveFiles(tinyxml2::XMLElement* scene, tinyxml2::XMLDocument* doc) {
    if (!scene || !doc) {
        LOG_ERROR("Invalid XML parameters");
        return false;
    }

    // 创建 <chart> 元素
    tinyxml2::XMLElement* chartElement = doc->NewElement("chart");
    scene->InsertEndChild(chartElement);

    // 设置chart属性
    chartElement->SetAttribute("name", name_.toUtf8().constData());
    chartElement->SetAttribute("path", fileName_.toUtf8().constData());
    chartElement->SetAttribute("xCount", chartProperties_.xCount);
    chartElement->SetAttribute("yCount", chartProperties_.yCount);
    chartElement->SetAttribute("xTitle", chartProperties_.xTitle.toUtf8().constData());
    chartElement->SetAttribute("yTitle", chartProperties_.yTitle.toUtf8().constData());
    chartElement->SetAttribute("xMin", chartProperties_.xMin);
    chartElement->SetAttribute("xMax", chartProperties_.xMax);
    chartElement->SetAttribute("yMin", chartProperties_.yMin);
    chartElement->SetAttribute("yMax", chartProperties_.yMax);
    chartElement->SetAttribute("t", chartProperties_.timeParam);

    // 为每个CurveProperty创建<curve>元素
    for (const auto& curve : curveProperties_) {
        tinyxml2::XMLElement* curveElement = doc->NewElement("curve");
        chartElement->InsertEndChild(curveElement);

        curveElement->SetAttribute("name", curve.name.toUtf8().constData());
        curveElement->SetAttribute("color", QColorToString(curve.color).toUtf8().constData());
        curveElement->SetAttribute("start", curve.start);
        curveElement->SetAttribute("stop", curve.stop);
    }

    return true;
}

// FileEntryCurve ParseFiles implementation
bool FileEntryCurve::ParseFiles(const tinyxml2::XMLElement* chartElement) {
    if (!chartElement) {
        LOG_ERROR("Invalid XML element");
        return false;
    }

    // 查找<chart>元素
    //const tinyxml2::XMLElement* chartElement = element->FirstChildElement("chart");
    //if (!chartElement) {
    //    LOG_ERROR("No chart element found");
    //    return false;
    //}

    // 解析chart属性
    const char* nameAttr = chartElement->Attribute("name");
    const char* pathAttr = chartElement->Attribute("path");
    if (nameAttr) name_ = QString::fromUtf8(nameAttr);
    if (pathAttr) {
        QString fullPath = QString::fromUtf8(pathAttr);
        QFileInfo fileInfo(fullPath);
        fileName_ = fileInfo.fileName();
        path_ = fileInfo.absolutePath();
    }

    chartProperties_.xCount = chartElement->IntAttribute("xCount", 0);
    chartProperties_.yCount = chartElement->IntAttribute("yCount", 0);
    
    const char* xTitleAttr = chartElement->Attribute("xTitle");
    const char* yTitleAttr = chartElement->Attribute("yTitle");
    if (xTitleAttr) chartProperties_.xTitle = QString::fromUtf8(xTitleAttr);
    if (yTitleAttr) chartProperties_.yTitle = QString::fromUtf8(yTitleAttr);

    chartProperties_.xMin = chartElement->DoubleAttribute("xMin", 0.0);
    chartProperties_.xMax = chartElement->DoubleAttribute("xMax", 0.0);
    chartProperties_.yMin = chartElement->DoubleAttribute("yMin", 0.0);
    chartProperties_.yMax = chartElement->DoubleAttribute("yMax", 0.0);
    chartProperties_.timeParam = chartElement->DoubleAttribute("t", 0.0);

    // 解析所有<curve>元素
    curveProperties_.clear();
    for (const tinyxml2::XMLElement* curveElement = chartElement->FirstChildElement("curve");
         curveElement != nullptr;
         curveElement = curveElement->NextSiblingElement("curve")) {
        
        CurveProperty curve;
        
        const char* curveNameAttr = curveElement->Attribute("name");
        const char* colorAttr = curveElement->Attribute("color");
        if (curveNameAttr) curve.name = QString::fromUtf8(curveNameAttr);
        if (colorAttr) curve.color = StringToQColor(QString::fromUtf8(colorAttr));

		const char* startAttr = curveElement->Attribute("start");
		if (startAttr)
		{
			curve.start = curveElement->IntAttribute("start", 0);
		}
		const char* stopAttr = curveElement->Attribute("stop");
		if (stopAttr)
		{
			curve.stop = curveElement->IntAttribute("stop", 0);
		}
		const char* xAttr = curveElement->Attribute("x");
		if (xAttr)
		{
			curve.x = curveElement->IntAttribute("x", 0);
		}
		const char* yAttr = curveElement->Attribute("y");
		if (yAttr)
		{
			curve.y = curveElement->IntAttribute("y", 0);
		}

        curveProperties_.append(curve);
    }

    return true;
}