#pragma once

#include <QString>
#include <QColor>
#include "xml/tinyxml2.h"

enum class FileEntryType {
    Curve,
    Surface,
    Table,
    Light
};

enum class ChartType {
    Wave,
    Report
};

inline const char* ChartTypeToString(ChartType t) {
    switch (t) {
    case ChartType::Wave: return "Wave";
    case ChartType::Report: return "Report";
    }
    return "Wave";
}

inline bool ChartTypeFromString(const char* s, ChartType& out) {
    if (!s) return false;
    if (0 == strcmp(s, "Wave")) { out = ChartType::Wave; return true; }
    if (0 == strcmp(s, "Report")) { out = ChartType::Report; return true; }
    return false;
}

inline const char* FileEntryTypeToString(FileEntryType t) {
    switch (t) {
    case FileEntryType::Curve: return "curve";
    case FileEntryType::Surface: return "surface";
    case FileEntryType::Table: return "table";
    case FileEntryType::Light: return "light";
    }
    return "unknown";
}

inline bool FileEntryTypeFromString(const char* s, FileEntryType& out) {
    if (!s) return false;
    if (0 == strcmp(s, "curve")) { out = FileEntryType::Curve; return true; }
    if (0 == strcmp(s, "surface")) { out = FileEntryType::Surface; return true; }
    if (0 == strcmp(s, "table")) { out = FileEntryType::Table; return true; }
    if (0 == strcmp(s, "light")) { out = FileEntryType::Light; return true; }
    return false;
}

class FileEntryCurve;
class FileEntryLight;
class FileEntrySurface;
class FileEntryTable;

class FileEntry {
public:
    virtual ~FileEntry() = default;

    FileEntryType GetType() const { return type_; }
    void SetType(FileEntryType type) { type_ = type; }

    void SetPath(const QString& path);
    QString GetPath() const { return path_; }

    void SetFileNanme(const QString& fileNmae) { fileName_ = fileNmae; }
    const QString& GetFileName() const { return fileName_; }

    void SetName(const QString& name) { name_ = name; }
    QString GetName() const { return name_; }

    virtual FileEntryCurve* AsCurve() { return nullptr; }
    virtual FileEntryLight* AsLight() { return nullptr; }
    virtual FileEntrySurface* AsSurface() { return nullptr; }
    virtual FileEntryTable* AsTable() { return nullptr; }

    virtual bool ParseFiles(const tinyxml2::XMLElement* element) { return false; }
    virtual bool SaveFiles(tinyxml2::XMLElement* scene, tinyxml2::XMLDocument* doc) { return false; }

protected:
    FileEntryType type_;
    QString path_;
    QString fileName_;
    QString name_;
};

QString QColorToString(const QColor& color);
QColor StringToQColor(const QString& colorStr);

// Factory functions for creating FileEntry objects
std::shared_ptr<FileEntry> CreateFileEntry(FileEntryType type, const QString& filePath);
std::shared_ptr<FileEntryCurve> CreateFileEntryCurve(const QString& filePath);
std::shared_ptr<FileEntry> CreateFileEntrySurface(const QString& filePath);
std::shared_ptr<FileEntryTable> CreateFileEntryTable(const QString& filePath);
std::shared_ptr<FileEntryLight> CreateFileEntryLight(const QString& filePath);

// Factory functions for creating empty FileEntry objects (for XML parsing)
std::shared_ptr<FileEntry> CreateEmptyFileEntry(FileEntryType type);
std::shared_ptr<FileEntryCurve> CreateEmptyFileEntryCurve();
std::shared_ptr<FileEntry> CreateEmptyFileEntrySurface();
std::shared_ptr<FileEntryTable> CreateEmptyFileEntryTable();
std::shared_ptr<FileEntryLight> CreateEmptyFileEntryLight();


class FileEntryCurve : public FileEntry {
public:
    struct ChartProperties {
        ChartType chartType;  // 新增：Chart类型
        int xCount;
        int yCount;          // 对应XML的yCount
        QString xTitle;
        QString yTitle;
        double xMin;
        double xMax;
        double yMin;
        double yMax;
        double timeParam;    // 对应XML的t
    };

    struct CurveProperty {
        QString name;
        QColor color;

        // Wave类型使用start/stop，Report类型使用x/y
        union {
            struct {
                int start;
                int stop;
            } wave;
            struct {
                double x;
                double y;
            } report;
        } data;
    };

    using CurveProperties = QList<CurveProperty>;

public:
    FileEntryCurve() { 
        type_ = FileEntryType::Curve; 
        chartProperties_.chartType = ChartType::Wave; // 默认为Wave类型
    }

    void SetChartProperties(const ChartProperties& props) { chartProperties_ = props; }
    const ChartProperties& GetChartProperties() const { return chartProperties_; }

    void SetChartType(ChartType type) { chartProperties_.chartType = type; }
    ChartType GetChartType() const { return chartProperties_.chartType; }

    void AddCurveProperty(const CurveProperty& prop) { curveProperties_.append(prop); }
    void RemoveCurveProperty(int index) { curveProperties_.removeAt(index); }
    const CurveProperties& GetCurveProperties() const { return curveProperties_; }

    FileEntryCurve* AsCurve() override { return this; }

    // XML处理方法
    bool SaveFiles(tinyxml2::XMLElement* scene, tinyxml2::XMLDocument* doc) override;
    bool ParseFiles(const tinyxml2::XMLElement* element) override;

private:
    ChartProperties chartProperties_;
    CurveProperties curveProperties_;
};

class FileEntrySurface : public FileEntry {
public:
    struct ChartProperties {
        int xCount;
        int yCount;  // Added missing yCount
        int zCount;  // Added missing zCount
        QString xTitle;
        QString yTitle;
        QString zTitle;
        double xMin;
        double xMax;
        double yMin;
        double yMax;
        double zMin;
        double zMax;
        double timeParam;
    };

    struct SurfaceProperty {
        QString name;
        QColor color;
        int start;
        int stop;
        QString x;
        QString y;
        QString z;
    };

    using SurfaceProperties = QList<SurfaceProperty>;

public:
    FileEntrySurface() { type_ = FileEntryType::Surface; }
    
    // Chart properties management
    void SetChartProperties(const ChartProperties& properties);
    const ChartProperties& GetChartProperties() const;
    
    // Surface properties management
    void AddSurfaceProperty(const SurfaceProperty& surface);
    void RemoveSurfaceProperty(int index);
    void SetSurfaceProperty(int index, const SurfaceProperty& surface);
    const SurfaceProperties& GetSurfaceProperties() const;
    
    // Type conversion
    FileEntrySurface* AsSurface() override;
    
	// XML处理方法
	bool SaveFiles(tinyxml2::XMLElement* scene, tinyxml2::XMLDocument* doc) override;
	bool ParseFiles(const tinyxml2::XMLElement* element) override;

private:
    ChartProperties chartProperties_;
    SurfaceProperties surfaceProperties_;
};

class FileEntryTable : public FileEntry {
public:
    struct ChartProperties {
        QString headerString;
        double timeParam;
    };

    struct TableProperty {
        QString name;
        QColor color;
        QList<int> datas;
    };

    using TableProperties = QList<TableProperty>;

public:
    FileEntryTable() { type_ = FileEntryType::Table; }
    
    // Chart properties management
    void SetChartProperties(const ChartProperties& properties);
    const ChartProperties& GetChartProperties() const;
    
    // Table properties management
    void AddTableProperty(const TableProperty& table);
    void RemoveTableProperty(int index);
    void SetTableProperty(int index, const TableProperty& table);
    const TableProperties& GetTableProperties() const;
    
    // Type conversion
    FileEntryTable* AsTable() override;

	// XML处理方法
	bool SaveFiles(tinyxml2::XMLElement* scene, tinyxml2::XMLDocument* doc) override;
	bool ParseFiles(const tinyxml2::XMLElement* element) override;

private:
    ChartProperties chartProperties_;
    TableProperties tableProperties_;
};

class FileEntryLight : public FileEntry {
public:
    struct ColorProperties {
        QColor openColor;
        QColor closeColor;
		double timeParam;
    };

    struct LightRowProperty {
        QStringList name;
        QList<int> data;
    };

    using LightRowProperties = QList<LightRowProperty>;

public:
    FileEntryLight() { type_ = FileEntryType::Light; }

    void SetColorProperties(const ColorProperties& props) { colorProperties_ = props; }
    const ColorProperties& GetColorProperties() const { return colorProperties_; }

    void AddLightProperty(const LightRowProperty& prop) { lightProperties_.append(prop); }
    void RemoveLightProperty(int index) { lightProperties_.removeAt(index); }
    const LightRowProperties& GetLightProperties() const { return lightProperties_; }

    FileEntryLight* AsLight() override { return this; }

	bool SaveFiles(tinyxml2::XMLElement* scene, tinyxml2::XMLDocument* doc) override;
	bool ParseFiles(const tinyxml2::XMLElement* element) override;

private:
    ColorProperties colorProperties_;
    LightRowProperties lightProperties_;
};