// 4J-PB -
// The ATG Framework is a common set of C++ class libraries that is used by the
// samples in the XDK, and was developed by the Advanced Technology Group (ATG).
// The ATG Framework offers a clean and consistent format for the samples. These
// classes define functions used by all the samples. The ATG Framework together
// with the samples demonstrates best practices and innovative techniques for
// Xbox 360. There are many useful sections of code in the samples. You are
// encouraged to incorporate this code into your titles.

//-------------------------------------------------------------------------------------
//  AtgXmlParser.h
//
//  XMLParser and SAX interface declaration
//
//  Xbox Advanced Technology Group
//  Copyright (C) Microsoft Corporation. All rights reserved.
//-------------------------------------------------------------------------------------

#pragma once
#ifndef ATGXMLPARSER_H
#define ATGXMLPARSER_H

namespace ATG {

//-----------------------------------------------------------------------------
// error returns from XMLParse
//-----------------------------------------------------------------------------
#define _ATGFAC 0x61B
#define E_COULD_NOT_OPEN_FILE MAKE_HRESULT(1, _ATGFAC, 0x0001)
#define E_INVALID_XML_SYNTAX MAKE_HRESULT(1, _ATGFAC, 0x0002)

const uint32_t XML_MAX_ATTRIBUTES_PER_ELEMENT = 32;
const uint32_t XML_MAX_NAME_LENGTH = 128;
const uint32_t XML_READ_BUFFER_SIZE = 2048;
const uint32_t XML_WRITE_BUFFER_SIZE = 2048;

// No tag can be longer than XML_WRITE_BUFFER_SIZE - an error will be returned
// if it is

//-------------------------------------------------------------------------------------
struct XMLAttribute {
    wchar_t* strName;
    uint32_t NameLen;
    wchar_t* strValue;
    uint32_t ValueLen;
};

//-------------------------------------------------------------------------------------
class ISAXCallback {
    friend class XMLParser;

public:
    ISAXCallback() {};
    virtual ~ISAXCallback() {};

    virtual int32_t StartDocument() = 0;
    virtual int32_t EndDocument() = 0;

    virtual int32_t ElementBegin(const wchar_t* strName, uint32_t NameLen,
                                 const XMLAttribute* pAttributes,
                                 uint32_t NumAttributes) = 0;
    virtual int32_t ElementContent(const wchar_t* strData, uint32_t DataLen,
                                   bool More) = 0;
    virtual int32_t ElementEnd(const wchar_t* strName, uint32_t NameLen) = 0;

    virtual int32_t CDATABegin() = 0;
    virtual int32_t CDATAData(const wchar_t* strCDATA, uint32_t CDATALen,
                              bool bMore) = 0;
    virtual int32_t CDATAEnd() = 0;

    virtual void Error(int32_t hError, const char* strMessage) = 0;

    virtual void SetParseProgress(uint32_t dwProgress) {}

    const char* GetFilename() { return m_strFilename; }
    uint32_t GetLineNumber() { return m_LineNum; }
    uint32_t GetLinePosition() { return m_LinePos; }

private:
    const char* m_strFilename;
    uint32_t m_LineNum;
    uint32_t m_LinePos;
};

//-------------------------------------------------------------------------------------
class XMLParser {
public:
    XMLParser();
    ~XMLParser();

    //      Register an interface inheiriting from ISAXCallback
    void RegisterSAXCallbackInterface(ISAXCallback* pISAXCallback);

    //      Get the registered interface
    ISAXCallback* GetSAXCallbackInterface();

    //      ParseXMLFile returns one of the following:
    //         E_COULD_NOT_OPEN_FILE - couldn't open the file
    //         E_INVALID_XML_SYNTAX - bad XML syntax according to this parser
    //         E_NOINTERFACE - RegisterSAXCallbackInterface not called
    //         E_ABORT - callback returned a fail code
    //         S_OK - file parsed and completed

    int32_t ParseXMLFile(const char* strFilename);

    //      Parses from a buffer- if you pass a wchar_t buffer (and cast it), it
    //      will
    //         correctly detect it and use unicode instead.  Return codes are
    //         the same as for ParseXMLFile

    int32_t ParseXMLBuffer(const char* strBuffer, uint32_t uBufferSize);

private:
    int32_t MainParseLoop();

    int32_t AdvanceCharacter(bool bOkToFail = false);
    void SkipNextAdvance();

    int32_t ConsumeSpace();
    int32_t ConvertEscape();
    int32_t AdvanceElement();
    int32_t AdvanceName();
    int32_t AdvanceAttrVal();
    int32_t AdvanceCDATA();
    int32_t AdvanceComment();

    void FillBuffer();

#ifdef _Printf_format_string_  // VC++ 2008 and later support this annotation
    void Error(int32_t hRet,
               _In_z_ _Printf_format_string_ const char* strFormat, ...);
#else
    void Error(int32_t hRet, const char* strFormat, ...);
#endif

    ISAXCallback* m_pISAXCallback;

    void* m_hFile;
    const char* m_pInXMLBuffer;
    uint32_t m_uInXMLBufferCharsLeft;
    uint32_t m_dwCharsTotal;
    uint32_t m_dwCharsConsumed;

    uint8_t m_pReadBuf[XML_READ_BUFFER_SIZE + 2];  // room for a trailing NULL
    wchar_t m_pWriteBuf[XML_WRITE_BUFFER_SIZE];

    uint8_t* m_pReadPtr;
    wchar_t* m_pWritePtr;  // write pointer within m_pBuf

    bool m_bUnicode;       // true = 16-bits, false = 8-bits
    bool m_bReverseBytes;  // true = reverse bytes, false = don't reverse

    bool m_bSkipNextAdvance;
    wchar_t m_Ch;  // Current character being parsed
};

}  // namespace ATG

#endif