#pragma once

#include <optional>
#include <cstring>

#include <Unreal/FText.hpp>
#include <Unreal/NameTypes.hpp>

#include <Api\UmgTypes.hpp>
#include <Api\UnrealWrapper.hpp>

#include "PalTypes.hpp"

namespace PalUIExtension::Api::Pal
{
    
    enum class EPalGenderType_ : uint8 { None = 0, Male = 1, Female = 2 };

    enum class EPalElementType_ : uint8
    {
        None = 0, Normal = 1, Fire = 2, Water = 3, Leaf = 4,
        Electricity = 5, Ice = 6, Earth = 7, Dark = 8, Dragon = 9, MAX = 10,
    };

    enum class EPalWorkSuitability_ : uint8
    {
        None = 0, EmitFlame = 1, Watering = 2, Seeding = 3,
        GenerateElectricity = 4, Handcraft = 5, Collection = 6, Deforest = 7,
        Mining = 8, OilExtraction = 9, ProductMedicine = 10, Cool = 11,
        Transport = 12, MonsterFarm = 13, Anyone = 14, MAX = 15,
    };

    class LooseObject : public UnrealWrapper
    {
    public:
        LooseObject() = default;
        explicit LooseObject(UObject* Obj, const TCHAR* Tag = STR("Loose"))
            : UnrealWrapper(Obj, UncheckedTag{}, Tag) {
        }

        using UnrealWrapper::Call;
        using UnrealWrapper::CallVoid;
        using UnrealWrapper::CallForReturn;
        using UnrealWrapper::PropertyPtr;
        using UnrealWrapper::PropertyValue;
    };
   
    // this struct is now redundant. watch it never get removed.
  
    struct FPalInstanceID {
        FGuid_ PlayerUID;
        FGuid_ InstanceID;
        FString DebugName;     
    };

    struct PalIdentity
    {
        UObject* Handle{};
        UObject* IndividualParameter{};

        std::optional<FName>            CharacterId;   // the species. "SheepBall", etc.
        std::optional<int32>            Level;
        std::optional<int32>            Rank;
        std::optional<EPalGenderType_>  Gender;
        std::optional<bool>             bRare;

        explicit operator bool() const { return CharacterId.has_value(); }
    };

    class PalIndividual
    {
    public:
        static auto ParameterFromHandle(UObject* Handle) -> UObject*
        {
            if (!Handle) return nullptr;
            LooseObject H{ Handle, STR("PalIndividualCharacter") };
            return H.CallForReturn<UObject*>(STR("TryGetIndividualParameter")).value_or(nullptr);
        }

        static auto CharacterId(UObject* Parameter) -> std::optional<FName>
        {
            if (!Parameter) return std::nullopt;
            LooseObject P{ Parameter, STR("PalIndividualCharacterParameter") };
            return P.CallForReturn<FName>(STR("GetCharacterID"));
        }

        static auto CharacterIdFromHandle(UObject* Handle) -> std::optional<FName>
        {
            return CharacterId(ParameterFromHandle(Handle));
        }

        static auto IdentifyFromParameter(UObject* Parameter) -> PalIdentity
        {
            PalIdentity Out{};
            Out.IndividualParameter = Parameter;
            if (!Parameter) return Out;

            LooseObject P{ Parameter, STR("PalIndividualCharacterParameter") };
            Out.CharacterId = P.CallForReturn<FName>(STR("GetCharacterID"));
            Out.Level = P.CallForReturn<int32>(STR("GetLevel"));
            Out.Rank = P.CallForReturn<int32>(STR("GetRank"));
            Out.Gender = P.CallForReturn<EPalGenderType_>(STR("GetGenderType"));
            Out.bRare = P.CallForReturn<bool>(STR("IsRarePal"));
            return Out;
        }

        static auto Identify(UObject* Handle) -> PalIdentity
        {
            PalIdentity Out = IdentifyFromParameter(ParameterFromHandle(Handle));
            Out.Handle = Handle;
            return Out;
        }

        static auto GetInstanceIds(UObject* Handle) -> std::optional<FPalInstanceID>
        {
            if (!Handle) return std::nullopt;
            // FPalInstanceID
            LooseObject H{ Handle, STR("PalIndividualCharacterHandle") };
            auto _Out = H.CallForReturn<FPalInstanceID>(STR("GetIndividualID"));

            if (!_Out.has_value()) return std::nullopt;
            return FPalInstanceID{ _Out.value().PlayerUID, _Out.value().InstanceID, _Out.value().DebugName };
        }

    };

}