#pragma once

#include <XCEngine/Core/Asset/ImportSettings.h>
#include <XCEngine/Resources/Mesh/Mesh.h>
#include <XCEngine/Core/Math/Vector3.h>

namespace XCEngine {
namespace Resources {

enum class MeshImportFlags : Core::uint32 {
    None = 0,
    FlipUVs = 1 << 0,
    FlipWindingOrder = 1 << 1,
    GenerateNormals = 1 << 2,
    GenerateTangents = 1 << 3,
    OptimizeMesh = 1 << 4,
    ImportSkinning = 1 << 5,
    ImportAnimations = 1 << 6,
    ImportMaterials = 1 << 7,
    ImportCameras = 1 << 8,
    ImportLights = 1 << 9
};

inline MeshImportFlags operator|(MeshImportFlags a, MeshImportFlags b) {
    return static_cast<MeshImportFlags>(static_cast<Core::uint32>(a) | static_cast<Core::uint32>(b));
}

inline MeshImportFlags operator&(MeshImportFlags a, MeshImportFlags b) {
    return static_cast<MeshImportFlags>(static_cast<Core::uint32>(a) & static_cast<Core::uint32>(b));
}

inline MeshImportFlags operator~(MeshImportFlags a) {
    return static_cast<MeshImportFlags>(~static_cast<Core::uint32>(a));
}

class MeshImportSettings : public ImportSettings {
public:
    MeshImportSettings();
    virtual ~MeshImportSettings() override;

    Core::UniqueRef<ImportSettings> Clone() const override;
    bool LoadFromJSON(const Containers::String& json) override;
    Containers::String SaveToJSON() const override;

    void SetImportFlags(MeshImportFlags flags) { m_importFlags = flags; }
    MeshImportFlags GetImportFlags() const { return m_importFlags; }

    void AddImportFlag(MeshImportFlags flag) { m_importFlags = static_cast<MeshImportFlags>(static_cast<Core::uint32>(m_importFlags) | static_cast<Core::uint32>(flag)); }
    void RemoveImportFlag(MeshImportFlags flag) { m_importFlags = static_cast<MeshImportFlags>(static_cast<Core::uint32>(m_importFlags) & ~static_cast<Core::uint32>(flag)); }
    bool HasImportFlag(MeshImportFlags flag) const { return (static_cast<Core::uint32>(m_importFlags) & static_cast<Core::uint32>(flag)) != 0; }

    void SetScale(float scale) { m_scale = scale; }
    float GetScale() const { return m_scale; }

    void SetOffset(const Math::Vector3& offset) { m_offset = offset; }
    const Math::Vector3& GetOffset() const { return m_offset; }

    void SetAxisConversion(bool convert) { m_axisConversion = convert; }
    bool GetAxisConversion() const { return m_axisConversion; }

    void SetMergeMeshes(bool merge) { m_mergeMeshes = merge; }
    bool GetMergeMeshes() const { return m_mergeMeshes; }

    void SetOptimizeThreshold(float threshold) { m_optimizeThreshold = threshold; }
    float GetOptimizeThreshold() const { return m_optimizeThreshold; }

    void SetImportScale(float scale) { m_importScale = scale; }
    float GetImportScale() const { return m_importScale; }

    void SetThreshold(float threshold) { m_threshold = threshold; }
    float GetThreshold() const { return m_threshold; }

private:
    MeshImportFlags m_importFlags = MeshImportFlags::None;
    float m_scale = 1.0f;
    Math::Vector3 m_offset = Math::Vector3::Zero();
    bool m_axisConversion = true;
    bool m_mergeMeshes = false;
    float m_optimizeThreshold = 0.3f;
    float m_importScale = 1.0f;
    float m_threshold = 0.0f;
};

} // namespace Resources
} // namespace XCEngine