#pragma once

class IBaseFileSystem;

class CUtlBuffer;

class Color;

class KeyValues;

class IKeyValuesDumpContext;

typedef void* FileHandle_t;
typedef void* GetSymbolProc_t;

// single byte identifies a xbox kv file in binary format
// strings are pooled from a searchpath/zip mounted symbol table
#define KV_BINARY_POOLED_FORMAT 0xAA

#define FOR_EACH_SUBKEY(kvRoot, kvSubKey)                                  \
    for (KeyValues* kvSubKey = kvRoot->GetFirstSubKey(); kvSubKey != NULL; \
         kvSubKey = kvSubKey->GetNextKey())

#define FOR_EACH_TRUE_SUBKEY(kvRoot, kvSubKey)                                 \
    for (KeyValues* kvSubKey = kvRoot->GetFirstTrueSubKey(); kvSubKey != NULL; \
         kvSubKey = kvSubKey->GetNextTrueSubKey())

#define FOR_EACH_VALUE(kvRoot, kvValue)                                 \
    for (KeyValues* kvValue = kvRoot->GetFirstValue(); kvValue != NULL; \
         kvValue = kvValue->GetNextValue())

//-----------------------------------------------------------------------------
// Purpose: Simple recursive data access class
//			Used in vgui for message parameters and resource files
//			Destructor deletes all child KeyValues nodes
//			Data is stored in key (string names) -
//(string/int/float)value pairs called nodes.
//
//	About KeyValues Text File Format:

//	It has 3 control characters '{', '}' and '"'. Names and values may be
//quoted or 	not. The quote '"' charater must not be used within name or values,
//only for 	quoting whole tokens. You may use escape sequences wile parsing and
//add within a 	quoted token a \" to add quotes within your name or token. When
//using Escape 	Sequence the parser must now that by setting
//KeyValues::UsesEscapeSequences(true), 	which it's off by default. Non-quoted
//tokens ends with a whitespace, '{', '}' and '"'. 	So you may use '{' and '}'
//within quoted tokens, but not for non-quoted tokens.
//  An open bracket '{' after a key name indicates a list of subkeys which is
//  finished with a closing bracket '}'. Subkeys use the same definitions
//  recursively. Whitespaces are space, return, newline and tabulator. Allowed
//  Escape sequences
//	are \n, \t, \\, \n and \". The number character '#' is used for macro
//purposes 	(eg #include), don't use it as first charater in key names.
//-----------------------------------------------------------------------------
class KeyValues {
   public:
    //	By default, the KeyValues class uses a string table for the key names
    //that is 	limited to 4MB. The game will exit in error if this space is
    //exhausted. In 	general this is preferable for game code for performance and
    //memory fragmentation 	reasons.
    //
    //	If this is not acceptable, you can use this call to switch to a table
    //that can grow 	arbitrarily. This call must be made before any KeyValues
    //objects are allocated or it 	will result in undefined behavior. If you use
    //the growable string table, you cannot 	share KeyValues pointers directly
    //with any other module. You can serialize them across 	module boundaries.
    //These limitations are acceptable in the Steam backend code 	this option was
    //written for, but may not be in other situations. Make sure to 	understand
    //the implications before using this.
    static void SetUseGrowableStringTable(bool bUseGrowableTable);

    KeyValues(const char* setName) {}

    //
    // AutoDelete class to automatically free the keyvalues.
    // Simply construct it with the keyvalues you allocated and it will free
    // them when falls out of scope. When you decide that keyvalues shouldn't be
    // deleted call Assign(NULL) on it. If you constructed AutoDelete(NULL) you
    // can later assign the keyvalues to be deleted with Assign(pKeyValues). You
    // can also pass temporary KeyValues object as an argument to a function by
    // wrapping it into KeyValues::AutoDelete instance:   call_my_function(
    // KeyValues::AutoDelete( new KeyValues( "test" ) ) )
    //
    class AutoDelete {
       public:
        explicit inline AutoDelete(KeyValues* pKeyValues)
            : m_pKeyValues(pKeyValues) {}

        explicit inline AutoDelete(const char* pchKVName)
            : m_pKeyValues(new KeyValues(pchKVName)) {}

        inline ~AutoDelete(void) {
            if (m_pKeyValues) m_pKeyValues->deleteThis();
        }

        inline void Assign(KeyValues* pKeyValues) { m_pKeyValues = pKeyValues; }

        KeyValues* operator->() { return m_pKeyValues; }

        operator KeyValues*() { return m_pKeyValues; }

       private:
        AutoDelete(AutoDelete const& x);             // forbid
        AutoDelete& operator=(AutoDelete const& x);  // forbid
        KeyValues* m_pKeyValues;
    };

    // Quick setup constructors
    KeyValues(const char* setName, const char* firstKey,
              const char* firstValue);

    KeyValues(const char* setName, const char* firstKey,
              const wchar_t* firstValue);

    KeyValues(const char* setName, const char* firstKey, int firstValue);

    KeyValues(const char* setName, const char* firstKey, const char* firstValue,
              const char* secondKey, const char* secondValue);

    KeyValues(const char* setName, const char* firstKey, int firstValue,
              const char* secondKey, int secondValue);

    // Section name
    const char* GetName() const;

    void SetName(const char* setName);

    // gets the name as a unique int
    int GetNameSymbol() const { return m_iKeyName; }

    // File access. Set UsesEscapeSequences true, if resource file/buffer uses
    // Escape Sequences (eg \n, \t)
    void UsesEscapeSequences(bool state);  // default false
    void UsesConditionals(bool state);     // default true
    bool LoadFromFile(void* filesystem, const char* resourceName,
                      const char* pathID = NULL);

    bool SaveToFile(void* filesystem, const char* resourceName,
                    const char* pathID = NULL, bool sortKeys = false,
                    bool bAllowEmptyString = false);

    // Read from a buffer...  Note that the buffer must be null terminated
    bool LoadFromBuffer(char const* resourceName, const char* pBuffer,
                        void* pFileSystem = NULL, const char* pPathID = NULL);

    // Read from a utlbuffer...
    bool LoadFromBuffer(char const* resourceName, void* buf,
                        void* pFileSystem = NULL, const char* pPathID = NULL);

    // Find a keyValue, create it if it is not found.
    // Set bCreate to true to create the key if it doesn't already exist (which
    // ensures a valid pointer will be returned)
    KeyValues* FindKey(const char* keyName, bool bCreate = false);

    KeyValues* FindKey(int keySymbol) const;

    KeyValues*
    CreateNewKey();  // creates a new key, with an autogenerated name.  name is
                     // guaranteed to be an integer, of value 1 higher than the
                     // highest other integer key name
    void AddSubKey(
        KeyValues* pSubkey);  // Adds a subkey. Make sure the subkey isn't a
                              // child of some other keyvalues
    void RemoveSubKey(KeyValues* subKey);  // removes a subkey from the list,
                                           // DOES NOT DELETE IT

    // Key iteration.
    //
    // NOTE: GetFirstSubKey/GetNextKey will iterate keys AND values. Use the
    // functions below if you want to iterate over just the keys or just the
    // values.
    //
    KeyValues* GetFirstSubKey() {
        return m_pSub;
    }  // returns the first subkey in the list
    KeyValues* GetNextKey() { return m_pPeer; }  // returns the next subkey
    void SetNextKey(KeyValues* pDat);

    KeyValues*
    FindLastSubKey();  // returns the LAST subkey in the list.  This requires a
                       // linked list iteration to find the key.  Returns NULL
                       // if we don't have any children

    //
    // These functions can be used to treat it like a true key/values tree
    // instead of confusing values with keys.
    //
    // So if you wanted to iterate all subkeys, then all values, it would look
    // like this:
    //     for ( KeyValues *pKey = pRoot->GetFirstTrueSubKey(); pKey; pKey =
    //     pKey->GetNextTrueSubKey() )
    //     {
    //		   Msg( "Key name: %s\n", pKey->GetName() );
    //     }
    //     for ( KeyValues *pValue = pRoot->GetFirstValue(); pKey; pKey =
    //     pKey->GetNextValue() )
    //     {
    //         Msg( "Int value: %d\n", pValue->GetInt() );  // Assuming
    //         pValue->GetDataType() == TYPE_INT...
    //     }
    KeyValues* GetFirstTrueSubKey();

    KeyValues* GetNextTrueSubKey();

    KeyValues* GetFirstValue();  // When you get a value back, you can use GetX
                                 // and pass in NULL to get the value.
    KeyValues* GetNextValue();

    // Data access
    int GetInt(const char* keyName = NULL, int defaultValue = 0);

    uint64_t GetUint64(const char* keyName = NULL, uint64_t defaultValue = 0);

    float GetFloat(const char* keyName = NULL, float defaultValue = 0.0f);

    const char* GetString(const char* keyName = NULL,
                          const char* defaultValue = "");

    const wchar_t* GetWString(const char* keyName = NULL,
                              const wchar_t* defaultValue = L"");

    void* GetPtr(const char* keyName = NULL, void* defaultValue = (void*)0);

    bool GetBool(const char* keyName = NULL, bool defaultValue = false);

    Color GetColor(const char* keyName = NULL /* default value is all black */);

    bool IsEmpty(const char* keyName = NULL);

    // Data access
    int GetInt(int keySymbol, int defaultValue = 0);

    float GetFloat(int keySymbol, float defaultValue = 0.0f);

    const char* GetString(int keySymbol, const char* defaultValue = "");

    const wchar_t* GetWString(int keySymbol, const wchar_t* defaultValue = L"");

    void* GetPtr(int keySymbol, void* defaultValue = (void*)0);

    Color GetColor(int keySymbol /* default value is all black */);

    bool IsEmpty(int keySymbol);

    // Key writing
    void SetWString(const char* keyName, const wchar_t* value);

    void SetString(const char* keyName, const char* value);

    void SetInt(const char* keyName, int value);

    void SetUint64(const char* keyName, uint64_t value);

    void SetFloat(const char* keyName, float value);

    void SetPtr(const char* keyName, void* value);

    void SetColor(const char* keyName, Color value);

    void SetBool(const char* keyName, bool value) {
        SetInt(keyName, value ? 1 : 0);
    }

    // Adds a chain... if we don't find stuff in this keyvalue, we'll look
    // in the one we're chained to.
    void ChainKeyValue(KeyValues* pChain);

    void RecursiveSaveToFile(void* buf, int indentLevel, bool sortKeys = false,
                             bool bAllowEmptyString = false);

    bool WriteAsBinary(void* buffer);

    bool ReadAsBinary(void* buffer, int nStackDepth = 0);

    // Allocate & create a new copy of the keys
    KeyValues* MakeCopy(void) const;

    // Make a new copy of all subkeys, add them all to the passed-in keyvalues
    void CopySubkeys(KeyValues* pParent) const;

    // Clear out all subkeys, and the current value
    void Clear(void);

    // Data type
    enum types_t {
        TYPE_NONE = 0,
        TYPE_STRING,
        TYPE_INT,
        TYPE_FLOAT,
        TYPE_PTR,
        TYPE_WSTRING,
        TYPE_COLOR,
        TYPE_UINT64,
        TYPE_NUMTYPES,
    };

    types_t GetDataType(const char* keyName = NULL);

    // Virtual deletion function - ensures that KeyValues object is deleted from
    // correct heap
    void deleteThis();

    void SetStringValue(char const* strValue);

    // unpack a key values list into a structure
    void UnpackIntoStructure(
        struct KeyValuesUnpackStructure const* pUnpackTable, void* pDest,
        size_t DestSizeInBytes);

    // Process conditional keys for widescreen support.
    bool ProcessResolutionKeys(const char* pResString);

    // Dump keyvalues recursively into a dump context
    bool Dump(class IKeyValuesDumpContext* pDump, int nIndentLevel = 0);

    // Merge in another KeyValues, keeping "our" settings
    void RecursiveMergeKeyValues(KeyValues* baseKV);

   private:
    KeyValues(KeyValues&);  // prevent copy constructor being used

    // prevent delete being called except through deleteThis()
    ~KeyValues();

    KeyValues* CreateKey(const char* keyName);

    /// Create a child key, given that we know which child is currently the last
    /// child. This avoids the O(N^2) behaviour when adding children in sequence
    /// to KV, when CreateKey() wil have to re-locate the end of the list each
    /// time.  This happens, for example, every time we load any KV file
    /// whatsoever.
    KeyValues* CreateKeyUsingKnownLastChild(const char* keyName,
                                            KeyValues* pLastChild);

    void AddSubkeyUsingKnownLastChild(KeyValues* pSubKey,
                                      KeyValues* pLastChild);

    void RecursiveCopyKeyValues(KeyValues& src);

    void RemoveEverything();
    //	void RecursiveSaveToFile( IBaseFileSystem *filesystem, void*buffer, int
    //indentLevel ); 	void WriteConvertedString( void*buffer, const char
    //*pszString );

    // NOTE: If both filesystem and pBuf are non-null, it'll save to both of
    // them. If filesystem is null, it'll ignore f.
    void RecursiveSaveToFile(void* filesystem, FileHandle_t f, void* pBuf,
                             int indentLevel, bool sortKeys,
                             bool bAllowEmptyString);

    void SaveKeyToFile(KeyValues* dat, void* filesystem, FileHandle_t f,
                       void* pBuf, int indentLevel, bool sortKeys,
                       bool bAllowEmptyString);

    void WriteConvertedString(void* filesystem, FileHandle_t f, void* pBuf,
                              const char* pszString);

    void RecursiveLoadFromBuffer(char const* resourceName, void* buf);

    // For handling #include "filename"
    void AppendIncludedKeys(void* includedKeys);

    void ParseIncludedKeys(char const* resourceName, const char* filetoinclude,
                           void* pFileSystem, const char* pPathID,
                           void* includedKeys);

    // For handling #base "filename"
    void MergeBaseKeys(void* baseKeys);

    // NOTE: If both filesystem and pBuf are non-null, it'll save to both of
    // them. If filesystem is null, it'll ignore f.
    void InternalWrite(void* filesystem, FileHandle_t f, void* pBuf,
                       const void* pData, int len);

    void Init();

    const char* ReadToken(void* buf, bool& wasQuoted, bool& wasConditional);

    void WriteIndents(void* filesystem, FileHandle_t f, void* pBuf,
                      int indentLevel);

    void FreeAllocatedValue();

    void AllocateValueBlock(int size);

    int m_iKeyName;  // keyname is a symbol defined in KeyValuesSystem

    // These are needed out of the union because the API returns string pointers
    char* m_sValue;
    wchar_t* m_wsValue;

    // we don't delete these
    union {
        int m_iValue;
        float m_flValue;
        void* m_pValue;
        unsigned char m_Color[4];
    };

    char m_iDataType;
    char m_bHasEscapeSequences;  // true, if while parsing this KeyValue, Escape
                                 // Sequences are used (default false)
    char m_bEvaluateConditionals;  // true, if while parsing this KeyValue,
                                   // conditionals blocks are evaluated (default
                                   // true)
    char unused[1];

    KeyValues* m_pPeer;   // pointer to next key in list
    KeyValues* m_pSub;    // pointer to Start of a new sub key list
    KeyValues* m_pChain;  // Search here if it's not in our list

   private:
    // Statics to implement the optional growable string table
    // Function pointers that will determine which mode we are in
    static int (*s_pfGetSymbolForString)(const char* name, bool bCreate);

    static const char* (*s_pfGetStringForSymbol)(int symbol);

    static void* s_pGrowableStringTable;

   public:
    // Functions that invoke the default behavior
    static int GetSymbolForStringClassic(const char* name, bool bCreate = true);

    static const char* GetStringForSymbolClassic(int symbol);

    // Functions that use the growable string table
    static int GetSymbolForStringGrowable(const char* name,
                                          bool bCreate = true);

    static const char* GetStringForSymbolGrowable(int symbol);

    // Functions to get external access to whichever of the above functions
    // we're going to call.
    static int CallGetSymbolForString(const char* name, bool bCreate = true) {
        return s_pfGetSymbolForString(name, bCreate);
    }

    static const char* CallGetStringForSymbol(int symbol) {
        return s_pfGetStringForSymbol(symbol);
    }
};