#pragma once

#include "Game/T6/T6.h"

#include "Json/JsonExtension.h"
#include <memory>
#include <nlohmann/json.hpp>
#include <optional>
#include <string>
#include <vector>

namespace T6
{
    NLOHMANN_JSON_SERIALIZE_ENUM(GfxStencilOp,
                                 {
                                     {GFXS_STENCILOP_KEEP,    "keep"   },
                                     {GFXS_STENCILOP_ZERO,    "zero"   },
                                     {GFXS_STENCILOP_REPLACE, "replace"},
                                     {GFXS_STENCILOP_INCRSAT, "incrsat"},
                                     {GFXS_STENCILOP_DECRSAT, "decrsat"},
                                     {GFXS_STENCILOP_INVERT,  "invert" },
                                     {GFXS_STENCILOP_INCR,    "incr"   },
                                     {GFXS_STENCILOP_DECR,    "decr"   },
    });

    NLOHMANN_JSON_SERIALIZE_ENUM(GfxStencilFunc,
                                 {
                                     {GFXS_STENCILFUNC_NEVER,        "never"       },
                                     {GFXS_STENCILFUNC_LESS,         "less"        },
                                     {GFXS_STENCILFUNC_EQUAL,        "equal"       },
                                     {GFXS_STENCILFUNC_LESSEQUAL,    "lessequal"   },
                                     {GFXS_STENCILFUNC_GREATER,      "greater"     },
                                     {GFXS_STENCILFUNC_NOTEQUAL,     "notequal"    },
                                     {GFXS_STENCILFUNC_GREATEREQUAL, "greaterequal"},
                                     {GFXS_STENCILFUNC_ALWAYS,       "always"      },
    });

    class JsonStencil
    {
    public:
        GfxStencilOp pass;
        GfxStencilOp fail;
        GfxStencilOp zfail;
        GfxStencilFunc func;
    };

    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonStencil, pass, fail, zfail, func);

    enum class JsonAlphaTest
    {
        INVALID,
        DISABLED,
        GT0,
        GE128
    };

    NLOHMANN_JSON_SERIALIZE_ENUM(
        JsonAlphaTest,
        {
            {JsonAlphaTest::INVALID,  nullptr   },
            {JsonAlphaTest::DISABLED, "disabled"},
            {JsonAlphaTest::GT0,      "gt0"     },
            {JsonAlphaTest::GE128,    "ge128"   }
    });

    enum class JsonCullFace
    {
        INVALID,
        NONE,
        BACK,
        FRONT
    };

    NLOHMANN_JSON_SERIALIZE_ENUM(
        JsonCullFace,
        {
            {JsonCullFace::INVALID, nullptr},
            {JsonCullFace::NONE,    "none" },
            {JsonCullFace::BACK,    "back" },
            {JsonCullFace::FRONT,   "front"}
    });

    enum class JsonDepthTest
    {
        INVALID,
        DISABLED,
        ALWAYS,
        LESS,
        EQUAL,
        LESS_EQUAL
    };

    NLOHMANN_JSON_SERIALIZE_ENUM(JsonDepthTest,
                                 {
                                     {JsonDepthTest::INVALID,    nullptr     },
                                     {JsonDepthTest::DISABLED,   "disabled"  },
                                     {JsonDepthTest::ALWAYS,     "always"    },
                                     {JsonDepthTest::LESS,       "less"      },
                                     {JsonDepthTest::EQUAL,      "equal"     },
                                     {JsonDepthTest::LESS_EQUAL, "less_equal"}
    });

    NLOHMANN_JSON_SERIALIZE_ENUM(GfxBlend,
                                 {
                                     {GFXS_BLEND_DISABLED,     "disabled"    },
                                     {GFXS_BLEND_ZERO,         "zero"        },
                                     {GFXS_BLEND_ONE,          "one"         },
                                     {GFXS_BLEND_SRCCOLOR,     "srccolor"    },
                                     {GFXS_BLEND_INVSRCCOLOR,  "invsrccolor" },
                                     {GFXS_BLEND_SRCALPHA,     "srcalpha"    },
                                     {GFXS_BLEND_INVSRCALPHA,  "invsrcalpha" },
                                     {GFXS_BLEND_DESTALPHA,    "destalpha"   },
                                     {GFXS_BLEND_INVDESTALPHA, "invdestalpha"},
                                     {GFXS_BLEND_DESTCOLOR,    "destcolor"   },
                                     {GFXS_BLEND_INVDESTCOLOR, "invdestcolor"},
    });

    NLOHMANN_JSON_SERIALIZE_ENUM(GfxBlendOp,
                                 {
                                     {GFXS_BLENDOP_DISABLED,    "disabled"   },
                                     {GFXS_BLENDOP_ADD,         "add"        },
                                     {GFXS_BLENDOP_SUBTRACT,    "subtract"   },
                                     {GFXS_BLENDOP_REVSUBTRACT, "revsubtract"},
                                     {GFXS_BLENDOP_MIN,         "min"        },
                                     {GFXS_BLENDOP_MAX,         "max"        },
    });

    NLOHMANN_JSON_SERIALIZE_ENUM(GfxPolygonOffset_e,
                                 {
                                     {GFXS_POLYGON_OFFSET_0,         "offset0"        },
                                     {GFXS_POLYGON_OFFSET_1,         "offset1"        },
                                     {GFXS_POLYGON_OFFSET_2,         "offset2"        },
                                     {GFXS_POLYGON_OFFSET_SHADOWMAP, "offsetShadowmap"},
    });

    class JsonStateBitsTableEntry
    {
    public:
        GfxBlend srcBlendRgb;
        GfxBlend dstBlendRgb;
        GfxBlendOp blendOpRgb;
        JsonAlphaTest alphaTest;
        JsonCullFace cullFace;
        GfxBlend srcBlendAlpha;
        GfxBlend dstBlendAlpha;
        GfxBlendOp blendOpAlpha;
        bool colorWriteRgb;
        bool colorWriteAlpha;
        bool polymodeLine;
        bool depthWrite;
        JsonDepthTest depthTest;
        GfxPolygonOffset_e polygonOffset;
        std::optional<JsonStencil> stencilFront;
        std::optional<JsonStencil> stencilBack;
    };

    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonStateBitsTableEntry,
                                   srcBlendRgb,
                                   dstBlendRgb,
                                   blendOpRgb,
                                   alphaTest,
                                   cullFace,
                                   srcBlendAlpha,
                                   dstBlendAlpha,
                                   blendOpAlpha,
                                   colorWriteRgb,
                                   colorWriteAlpha,
                                   polymodeLine,
                                   depthWrite,
                                   depthWrite,
                                   depthTest,
                                   polygonOffset,
                                   stencilFront,
                                   stencilBack);

    class JsonConstant
    {
    public:
        std::optional<std::string> name;
        std::optional<std::string> nameFragment;
        std::optional<unsigned> nameHash;
        std::vector<float> literal;
    };

    inline void to_json(nlohmann::json& out, const JsonConstant& in)
    {
        if (in.name.has_value())
        {
            optional_to_json(out, "name", in.name);
        }
        else
        {
            optional_to_json(out, "nameFragment", in.nameFragment);
            optional_to_json(out, "nameHash", in.nameHash);
        }

        out["literal"] = in.literal;
    }

    inline void from_json(const nlohmann::json& in, JsonConstant& out)
    {
        optional_from_json(in, "name", out.name);
        optional_from_json(in, "nameFragment", out.nameFragment);
        optional_from_json(in, "nameHash", out.nameHash);
        in.at("literal").get_to(out.literal);
    };

    NLOHMANN_JSON_SERIALIZE_ENUM(TextureFilter,
                                 {
                                     {TEXTURE_FILTER_DISABLED, "disabled"},
                                     {TEXTURE_FILTER_NEAREST,  "nearest" },
                                     {TEXTURE_FILTER_LINEAR,   "linear"  },
                                     {TEXTURE_FILTER_ANISO2X,  "aniso2x" },
                                     {TEXTURE_FILTER_ANISO4X,  "aniso4x" },
                                     {TEXTURE_FILTER_COMPARE,  "compare" },
    });

    NLOHMANN_JSON_SERIALIZE_ENUM(SamplerStateBitsMipMap_e,
                                 {
                                     {SAMPLER_MIPMAP_ENUM_DISABLED, "disabled"},
                                     {SAMPLER_MIPMAP_ENUM_NEAREST,  "nearest" },
                                     {SAMPLER_MIPMAP_ENUM_LINEAR,   "linear"  },
    });

    class JsonSamplerState
    {
    public:
        TextureFilter filter;
        SamplerStateBitsMipMap_e mipMap;
        bool clampU;
        bool clampV;
        bool clampW;
    };

    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonSamplerState, filter, mipMap, clampU, clampV, clampW);

    NLOHMANN_JSON_SERIALIZE_ENUM(TextureSemantic,
                                 {
                                     {TS_2D,            "2D"          },
                                     {TS_FUNCTION,      "function"    },
                                     {TS_COLOR_MAP,     "colorMap"    },
                                     {TS_UNUSED_1,      "unused1"     },
                                     {TS_UNUSED_2,      "unused2"     },
                                     {TS_NORMAL_MAP,    "normalMap"   },
                                     {TS_UNUSED_3,      "unused3"     },
                                     {TS_UNUSED_4,      "unused4"     },
                                     {TS_SPECULAR_MAP,  "specularMap" },
                                     {TS_UNUSED_5,      "unused5"     },
                                     {TS_OCCLUSION_MAP, "occlusionMap"},
                                     {TS_UNUSED_6,      "unused6"     },
                                     {TS_COLOR0_MAP,    "color0Map"   },
                                     {TS_COLOR1_MAP,    "color1Map"   },
                                     {TS_COLOR2_MAP,    "color2Map"   },
                                     {TS_COLOR3_MAP,    "color3Map"   },
                                     {TS_COLOR4_MAP,    "color4Map"   },
                                     {TS_COLOR5_MAP,    "color5Map"   },
                                     {TS_COLOR6_MAP,    "color6Map"   },
                                     {TS_COLOR7_MAP,    "color7Map"   },
                                     {TS_COLOR8_MAP,    "color8Map"   },
                                     {TS_COLOR9_MAP,    "color9Map"   },
                                     {TS_COLOR10_MAP,   "color10Map"  },
                                     {TS_COLOR11_MAP,   "color11Map"  },
                                     {TS_COLOR12_MAP,   "color12Map"  },
                                     {TS_COLOR13_MAP,   "color13Map"  },
                                     {TS_COLOR14_MAP,   "color14Map"  },
                                     {TS_COLOR15_MAP,   "color15Map"  },
                                     {TS_THROW_MAP,     "throwMap"    },
    });

    class JsonTexture
    {
    public:
        std::optional<std::string> name;
        std::optional<unsigned> nameHash;
        std::optional<std::string> nameStart;
        std::optional<std::string> nameEnd;
        TextureSemantic semantic;
        bool isMatureContent;
        JsonSamplerState samplerState;
        std::string image;
    };

    inline void to_json(nlohmann::json& out, const JsonTexture& in)
    {
        if (in.name.has_value())
        {
            optional_to_json(out, "name", in.name);
        }
        else
        {
            optional_to_json(out, "nameHash", in.nameHash);
            optional_to_json(out, "nameStart", in.nameStart);
            optional_to_json(out, "nameEnd", in.nameEnd);
        }

        out["semantic"] = in.semantic;
        out["isMatureContent"] = in.isMatureContent;
        out["samplerState"] = in.samplerState;
        out["image"] = in.image;
    }

    inline void from_json(const nlohmann::json& in, JsonTexture& out)
    {
        optional_from_json(in, "name", out.name);
        optional_from_json(in, "nameHash", out.nameHash);
        optional_from_json(in, "nameStart", out.nameStart);
        optional_from_json(in, "nameEnd", out.nameEnd);
        in.at("semantic").get_to(out.semantic);
        in.at("isMatureContent").get_to(out.isMatureContent);
        in.at("samplerState").get_to(out.samplerState);
        in.at("image").get_to(out.image);
    };

    class JsonTextureAtlas
    {
    public:
        uint8_t rows;
        uint8_t columns;
    };

    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonTextureAtlas, rows, columns);

    NLOHMANN_JSON_SERIALIZE_ENUM(MaterialGameFlags,
                                 {
                                     {MTL_GAMEFLAG_1,            "1"           },
                                     {MTL_GAMEFLAG_2,            "2"           },
                                     {MTL_GAMEFLAG_NO_MARKS,     "NO_MARKS"    },
                                     {MTL_GAMEFLAG_NO_MARKS,     "4"           },
                                     {MTL_GAMEFLAG_8,            "8"           },
                                     {MTL_GAMEFLAG_10,           "10"          },
                                     {MTL_GAMEFLAG_20,           "20"          },
                                     {MTL_GAMEFLAG_CASTS_SHADOW, "CASTS_SHADOW"},
                                     {MTL_GAMEFLAG_CASTS_SHADOW, "40"          },
                                     {MTL_GAMEFLAG_80,           "80"          },
                                     {MTL_GAMEFLAG_100,          "100"         },
                                     {MTL_GAMEFLAG_200,          "200"         },
                                     {MTL_GAMEFLAG_400,          "400"         },
                                     {MTL_GAMEFLAG_800,          "800"         },
                                     {MTL_GAMEFLAG_1000,         "1000"        },
    });

    NLOHMANN_JSON_SERIALIZE_ENUM(GfxCameraRegionType,
                                 {
                                     {CAMERA_REGION_LIT_OPAQUE,       "litOpaque"     },
                                     {CAMERA_REGION_LIT_TRANS,        "litTrans"      },
                                     {CAMERA_REGION_LIT_QUASI_OPAQUE, "litQuasiOpaque"},
                                     {CAMERA_REGION_EMISSIVE_OPAQUE,  "emissiveOpaque"},
                                     {CAMERA_REGION_EMISSIVE_TRANS,   "emissiveTrans" },
                                     {CAMERA_REGION_EMISSIVE_FX,      "emissiveFx"    },
                                     {CAMERA_REGION_LIGHT_MAP_OPAQUE, "lightMapOpaque"},
                                     {CAMERA_REGION_DEPTH_HACK,       "depthHack"     },
                                     {CAMERA_REGION_UNUSED,           "unused"        },
                                     {CAMERA_REGION_SONAR,            "sonar"         },
                                     {CAMERA_REGION_NONE,             "none"          },
    });

    class JsonMaterial
    {
    public:
        std::vector<MaterialGameFlags> gameFlags;
        unsigned sortKey;
        std::optional<JsonTextureAtlas> textureAtlas;
        unsigned surfaceTypeBits;
        unsigned layeredSurfaceTypes;
        unsigned hashIndex;
        unsigned surfaceFlags;
        unsigned contents;
        std::vector<int8_t> stateBitsEntry;
        unsigned stateFlags;
        GfxCameraRegionType cameraRegion;
        uint8_t probeMipBits;
        std::string techniqueSet;
        std::vector<JsonTexture> textures;
        std::vector<JsonConstant> constants;
        std::vector<JsonStateBitsTableEntry> stateBits;
        std::optional<std::string> thermalMaterial;
    };

    NLOHMANN_DEFINE_TYPE_EXTENSION(JsonMaterial,
                                   gameFlags,
                                   sortKey,
                                   textureAtlas,
                                   surfaceTypeBits,
                                   layeredSurfaceTypes,
                                   hashIndex,
                                   surfaceFlags,
                                   contents,
                                   stateBitsEntry,
                                   stateFlags,
                                   cameraRegion,
                                   probeMipBits,
                                   techniqueSet,
                                   textures,
                                   constants,
                                   stateBits,
                                   thermalMaterial);
} // namespace T6