/********************************************************************************
 *                                                                              *
 * This file is part of IfcOpenShell.                                           *
 *                                                                              *
 * IfcOpenShell is free software: you can redistribute it and/or modify         *
 * it under the terms of the Lesser GNU General Public License as published by  *
 * the Free Software Foundation, either version 3.0 of the License, or          *
 * (at your option) any later version.                                          *
 *                                                                              *
 * IfcOpenShell is distributed in the hope that it will be useful,              *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of               *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the                 *
 * Lesser GNU General Public License for more details.                          *
 *                                                                              *
 * You should have received a copy of the Lesser GNU General Public License     *
 * along with this program. If not, see <http://www.gnu.org/licenses/>.         *
 *                                                                              *
 ********************************************************************************/

/********************************************************************************
 *                                                                              *
 * This file provides functions for loading an IFC file into memory and access  *
 * its entities either by ID, by an IfcSchema::Type or by reference             * 
 *                                                                              *
 ********************************************************************************/

#ifndef IFCPARSE_H
#define IFCPARSE_H

#include "aggregate_of_instance.h"
#include "Argument.h"
#include "ifc_parse_api.h"
#include "IfcBaseClass.h"
#include "IfcCharacterDecoder.h"
#include "FileReader.h"
#include "macros.h"
#include "storage.h"

#include <boost/dynamic_bitset.hpp>
#include <boost/shared_ptr.hpp>
#include <cstring>
#include <iostream>
#include <string>
#include <vector>


extern const char *IFCOPENSHELL_VERSION;

namespace IfcParse {

/// Provides functions to convert Tokens to binary data
/// Tokens are merely offsets to where they can be read in the file
class IFC_PARSE_API TokenFunc {
  private:
    static bool startsWith(const Token& token, char character);

  public:
    /// Returns the offset at which the token is read from the file
    // static unsigned int Offset(const Token& t);
    /// Returns whether the token can be interpreted as a string
    static bool isString(const Token& token);
    /// Returns whether the token can be interpreted as an identifier
    static bool isIdentifier(const Token& token);
    /// Returns whether the token can be interpreted as a syntactical operator
    static bool isOperator(const Token& token);
    /// Returns whether the token is a given operator
    static bool isOperator(const Token& token, char character);
    /// Returns whether the token can be interpreted as an enumerated value
    static bool isEnumeration(const Token& token);
    /// Returns whether the token can be interpreted as a datatype name
    static bool isKeyword(const Token& token);
    /// Returns whether the token can be interpreted as an integer
    static bool isInt(const Token& token);
    /// Returns whether the token can be interpreted as a boolean
    static bool isBool(const Token& token);
    /// Returns whether the token can be interpreted as a logical
    static bool isLogical(const Token& token);
    /// Returns whether the token can be interpreted as a floating point number
    static bool isFloat(const Token& token);
    /// Returns whether the token can be interpreted as a binary type
    static bool isBinary(const Token& token);
    /// Returns the token interpreted as an integer
    static int asInt(const Token& token);
    /// Returns the token interpreted as an identifier
    static int asIdentifier(const Token& token);
    /// Returns the token interpreted as an boolean (.T. or .F.)
    static bool asBool(const Token& token);
    /// Returns the token interpreted as an logical (.T. or .F. or .U.)
    static boost::logic::tribool asLogical(const Token& token);
    /// Returns the token as a floating point number
    static double asFloat(const Token& token);
    /// Returns the token as a string (without the dot or apostrophe)
    static std::string asString(const Token& token);
    /// Returns the token as a string in internal buffer (for optimization purposes)
    static const std::string& asStringRef(const Token& token);
    /// Returns the token as a string (without the dot or apostrophe)
    static boost::dynamic_bitset<> asBinary(const Token& token);
    /// Returns a string representation of the token (including the dot or apostrophe)
    static std::string toString(const Token& token);
};

//
// Functions for creating Tokens from an arbitary file offset
// The first 4 bits are reserved for Tokens of type ()=,;$*
//
Token OperatorTokenPtr(IfcSpfLexer* tokens, size_t start, char data);
Token GeneralTokenPtr(IfcSpfLexer* tokens, size_t start, const std::string& data);

/// A stream of tokens to be read from a FileReader.
class IFC_PARSE_API IfcSpfLexer {
  private:
    IfcCharacterDecoder* decoder_;
    size_t skipWhitespace() const;
    size_t skipComment() const;

  public:
    std::string& GetTempString() const {
        static my_thread_local std::string string;
        return string;
    }
    FileReader* stream;
    // IfcFile* file;
    IfcSpfLexer(FileReader* stream);
    Token Next();
    ~IfcSpfLexer();
    void TokenString(size_t offset, std::string& result);
};

IFC_PARSE_API aggregate_of_instance::ptr traverse(IfcUtil::IfcBaseClass* instance, int max_level = -1);

IFC_PARSE_API aggregate_of_instance::ptr traverse_breadth_first(IfcUtil::IfcBaseClass* instance, int max_level = -1);
} // namespace IfcParse

IFC_PARSE_API std::ostream& operator<<(std::ostream& out, const IfcParse::IfcFile& file);

#endif