#pragma once

#include <QString>
#include <QColor>

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

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; }

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

// 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);


class FileEntryCurve : public FileEntry {
public:
    struct ChartProperties {
        int xCount;
        QString xTitle;
        QString yTitle;
        double xMin;
        double xMax;
        double yMin;
        double yMax;
        double timeParam;
    };

    struct CurveProperty {
        QString name;
        QColor color;
        int start;
        int stop;
    };

    using CurveProperties = QList<CurveProperty>;

public:
    FileEntryCurve() { type_ = FileEntryType::Curve; }

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

    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; }

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;
    
    // Description management
    void SetDescription(const QString& description);
    const QString& GetDescription() const;

private:
    ChartProperties chartProperties_;
    SurfaceProperties surfaceProperties_;
    QString description_;
};

class FileEntryTable : public FileEntry {
public:
    struct ChartProperties {
        QString name;
        QString path;
        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;
    
    // Table headers management
    void SetTableHeaders(const QStringList& headers);
    void SetTableHeaders(const QString& headerString); // Parse from comma-separated string
    const QStringList& GetTableHeaders() const;
    
    // Type conversion
    FileEntryTable* AsTable() override;
    
    // Description management
    void SetDescription(const QString& description);
    const QString& GetDescription() const;

private:
    ChartProperties chartProperties_;
    QStringList tableHeaders_;
    TableProperties tableProperties_;
    QString description_;
};

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

    struct LightProperty {
        QString name;
        int  index;
    };

    using LightProperties = QList<LightProperty>;

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

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

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

    FileEntryLight* AsLight() override { return this; }

private:
    ColorProperties colorProperties_;
    LightProperties lightProperties_;
};