/*
   Copyright (C) 2001-2006, William Joseph.
   All Rights Reserved.

   This file is part of GtkRadiant.

   GtkRadiant is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   GtkRadiant 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
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GtkRadiant; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include "eclass_doom3.h"

#include "debugging/debugging.h"

#include <map>

#include "ifilesystem.h"
#include "iscriplib.h"
#include "iarchive.h"
#include "qerplugin.h"

#include "generic/callback.h"
#include "string/string.h"
#include "eclasslib.h"
#include "os/path.h"
#include "os/dir.h"
#include "stream/stringstream.h"
#include "moduleobservers.h"
#include "stringio.h"

class RawString {
    const char *m_value;
public:
    RawString(const char *value) : m_value(value)
    {
    }

    const char *c_str() const
    {
        return m_value;
    }
};

inline bool operator<(const RawString &self, const RawString &other)
{
    return string_less_nocase(self.c_str(), other.c_str());
}

typedef std::map<RawString, EntityClass *> EntityClasses;
EntityClasses g_EntityClassDoom3_classes;
EntityClass *g_EntityClassDoom3_bad = 0;


void EntityClassDoom3_clear()
{
    for (EntityClasses::iterator i = g_EntityClassDoom3_classes.begin(); i != g_EntityClassDoom3_classes.end(); ++i) {
        (*i).second->free((*i).second);
    }
    g_EntityClassDoom3_classes.clear();
}

// entityClass will be inserted only if another of the same name does not already exist.
// if entityClass was inserted, the same object is returned, otherwise the already-existing object is returned.
EntityClass *EntityClassDoom3_insertUnique(EntityClass *entityClass)
{
    return (*g_EntityClassDoom3_classes.insert(
            EntityClasses::value_type(entityClass->name(), entityClass)).first).second;
}

void EntityClassDoom3_forEach(EntityClassVisitor &visitor)
{
    for (EntityClasses::iterator i = g_EntityClassDoom3_classes.begin(); i != g_EntityClassDoom3_classes.end(); ++i) {
        visitor.visit((*i).second);
    }
}

inline void printParseError(const char *message)
{
    globalErrorStream() << message;
}

#define PARSE_RETURN_FALSE_IF_FAIL(expression) do { if (!( expression)) { printParseError(FILE_LINE "\nparse failed: " #expression "\n"); return false; } } while (0)

bool EntityClassDoom3_parseToken(Tokeniser &tokeniser)
{
    const char *token = tokeniser.getToken();
    PARSE_RETURN_FALSE_IF_FAIL(token != 0);
    return true;
}

bool EntityClassDoom3_parseToken(Tokeniser &tokeniser, const char *string)
{
    const char *token = tokeniser.getToken();
    PARSE_RETURN_FALSE_IF_FAIL(token != 0);
    return string_equal(token, string);
}

bool EntityClassDoom3_parseString(Tokeniser &tokeniser, const char *&s)
{
    const char *token = tokeniser.getToken();
    PARSE_RETURN_FALSE_IF_FAIL(token != 0);
    s = token;
    return true;
}

bool EntityClassDoom3_parseString(Tokeniser &tokeniser, CopiedString &s)
{
    const char *token = tokeniser.getToken();
    PARSE_RETURN_FALSE_IF_FAIL(token != 0);
    s = token;
    return true;
}

bool EntityClassDoom3_parseString(Tokeniser &tokeniser, StringOutputStream &s)
{
    const char *token = tokeniser.getToken();
    PARSE_RETURN_FALSE_IF_FAIL(token != 0);
    s << token;
    return true;
}

bool EntityClassDoom3_parseUnknown(Tokeniser &tokeniser)
{
    //const char* name =
    PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));

    //globalOutputStream() << "parsing unknown block " << makeQuoted(name) << "\n";

    PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser, "{"));
    tokeniser.nextLine();

    std::size_t depth = 1;
    for (;;) {
        const char *token;
        PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, token));
        if (string_equal(token, "}")) {
            if (--depth == 0) {
                tokeniser.nextLine();
                break;
            }
        } else if (string_equal(token, "{")) {
            ++depth;
        }
        tokeniser.nextLine();
    }
    return true;
}


class Model {
public:
    bool m_resolved;
    CopiedString m_mesh;
    CopiedString m_skin;
    CopiedString m_parent;
    typedef std::map<CopiedString, CopiedString> Anims;
    Anims m_anims;

    Model() : m_resolved(false)
    {
    }
};

typedef std::map<CopiedString, Model> Models;

Models g_models;

void Model_resolveInheritance(const char *name, Model &model)
{
    if (model.m_resolved == false) {
        model.m_resolved = true;

        if (!string_empty(model.m_parent.c_str())) {
            Models::iterator i = g_models.find(model.m_parent);
            if (i == g_models.end()) {
                globalErrorStream() << "model " << name << " inherits unknown model " << model.m_parent.c_str() << "\n";
            } else {
                Model_resolveInheritance((*i).first.c_str(), (*i).second);
                model.m_mesh = (*i).second.m_mesh;
                model.m_skin = (*i).second.m_skin;
            }
        }
    }
}

bool EntityClassDoom3_parseModel(Tokeniser &tokeniser)
{
    const char *name;
    PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, name));

    Model &model = g_models[name];

    PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser, "{"));
    tokeniser.nextLine();

    for (;;) {
        const char *parameter;
        PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, parameter));
        if (string_equal(parameter, "}")) {
            tokeniser.nextLine();
            break;
        } else if (string_equal(parameter, "inherit")) {
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, model.m_parent));
            tokeniser.nextLine();
        } else if (string_equal(parameter, "remove")) {
            //const char* remove =
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
            tokeniser.nextLine();
        } else if (string_equal(parameter, "mesh")) {
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, model.m_mesh));
            tokeniser.nextLine();
        } else if (string_equal(parameter, "skin")) {
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, model.m_skin));
            tokeniser.nextLine();
        } else if (string_equal(parameter, "offset")) {
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser, "("));
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser, ")"));
            tokeniser.nextLine();
        } else if (string_equal(parameter, "channel")) {
            //const char* channelName =
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser, "("));
            for (;;) {
                const char *end;
                PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, end));
                if (string_equal(end, ")")) {
                    tokeniser.nextLine();
                    break;
                }
            }
        } else if (string_equal(parameter, "anim")) {
            CopiedString animName;
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, animName));
            const char *animFile;
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, animFile));
            model.m_anims.insert(Model::Anims::value_type(animName, animFile));

            const char *token;
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, token));

            while (string_equal(token, ",")) {
                PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, animFile));
                PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, token));
            }

            if (string_equal(token, "{")) {
                for (;;) {
                    const char *end;
                    PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, end));
                    if (string_equal(end, "}")) {
                        tokeniser.nextLine();
                        break;
                    }
                    tokeniser.nextLine();
                }
            } else {
                tokeniser.ungetToken();
            }
        } else {
            globalErrorStream() << "unknown model parameter: " << makeQuoted(parameter) << "\n";
            return false;
        }
        tokeniser.nextLine();
    }
    return true;
}

inline bool char_isSpaceOrTab(char c)
{
    return c == ' ' || c == '\t';
}

inline bool char_isNotSpaceOrTab(char c)
{
    return !char_isSpaceOrTab(c);
}

template<typename Predicate>
inline const char *string_find_if(const char *string, Predicate predicate)
{
    for (; *string != 0; ++string) {
        if (predicate(*string)) {
            return string;
        }
    }
    return string;
}

inline const char *string_findFirstSpaceOrTab(const char *string)
{
    return string_find_if(string, char_isSpaceOrTab);
}

inline const char *string_findFirstNonSpaceOrTab(const char *string)
{
    return string_find_if(string, char_isNotSpaceOrTab);
}


static bool EntityClass_parse(EntityClass &entityClass, Tokeniser &tokeniser)
{
    PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, entityClass.m_name));

    PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser, "{"));
    tokeniser.nextLine();

    StringOutputStream usage(256);
    StringOutputStream description(256);
    CopiedString *currentDescription = 0;
    StringOutputStream *currentString = 0;

    for (;;) {
        const char *key;
        PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, key));

        const char *last = string_findFirstSpaceOrTab(key);
        CopiedString first(StringRange(key, last));

        if (!string_empty(last)) {
            last = string_findFirstNonSpaceOrTab(last);
        }

        if (currentString != 0 && string_equal(key, "\\")) {
            tokeniser.nextLine();
            *currentString << " ";
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, *currentString));
            continue;
        }

        if (currentDescription != 0) {
            *currentDescription = description.c_str();
            description.clear();
            currentDescription = 0;
        }
        currentString = 0;

        if (string_equal(key, "}")) {
            tokeniser.nextLine();
            break;
        } else if (string_equal(key, "model")) {
            const char *token;
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, token));
            entityClass.fixedsize = true;
            StringOutputStream buffer(256);
            buffer << PathCleaned(token);
            entityClass.m_modelpath = buffer.c_str();
        } else if (string_equal(key, "editor_color")) {
            const char *value;
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, value));
            if (!string_empty(value)) {
                entityClass.colorSpecified = true;
                bool success = string_parse_vector3(value, entityClass.color);
                ASSERT_MESSAGE(success, "editor_color: parse error");
            }
        } else if (string_equal(key, "editor_ragdoll")) {
            //bool ragdoll = atoi(tokeniser.getToken()) != 0;
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
        } else if (string_equal(key, "editor_mins")) {
            entityClass.sizeSpecified = true;
            const char *value;
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, value));
            if (!string_empty(value) && !string_equal(value, "?")) {
                entityClass.fixedsize = true;
                bool success = string_parse_vector3(value, entityClass.mins);
                ASSERT_MESSAGE(success, "editor_mins: parse error");
            }
        } else if (string_equal(key, "editor_maxs")) {
            entityClass.sizeSpecified = true;
            const char *value;
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, value));
            if (!string_empty(value) && !string_equal(value, "?")) {
                entityClass.fixedsize = true;
                bool success = string_parse_vector3(value, entityClass.maxs);
                ASSERT_MESSAGE(success, "editor_maxs: parse error");
            }
        } else if (string_equal(key, "editor_usage")) {
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, usage));
            currentString = &usage;
        } else if (string_equal_n(key, "editor_usage", 12)) {
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, usage));
            currentString = &usage;
        } else if (string_equal(key, "editor_rotatable")
                   || string_equal(key, "editor_showangle")
                   || string_equal(key, "editor_showangles") // typo? in prey movables.def
                   || string_equal(key, "editor_mover")
                   || string_equal(key, "editor_model")
                   || string_equal(key, "editor_material")
                   || string_equal(key, "editor_combatnode")
                   || (!string_empty(last) && string_equal(first.c_str(), "editor_gui"))
                   || string_equal_n(key, "editor_copy", 11)) {
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
        } else if (!string_empty(last) &&
                   (string_equal(first.c_str(), "editor_var") || string_equal(first.c_str(), "editor_string"))) {
            EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, last).second;
            attribute.m_type = "string";
            currentDescription = &attribute.m_description;
            currentString = &description;
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, description));
        } else if (!string_empty(last) && string_equal(first.c_str(), "editor_float")) {
            EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, last).second;
            attribute.m_type = "string";
            currentDescription = &attribute.m_description;
            currentString = &description;
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, description));
        } else if (!string_empty(last) && string_equal(first.c_str(), "editor_snd")) {
            EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, last).second;
            attribute.m_type = "sound";
            currentDescription = &attribute.m_description;
            currentString = &description;
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, description));
        } else if (!string_empty(last) && string_equal(first.c_str(), "editor_bool")) {
            EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, last).second;
            attribute.m_type = "boolean";
            currentDescription = &attribute.m_description;
            currentString = &description;
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, description));
        } else if (!string_empty(last) && string_equal(first.c_str(), "editor_int")) {
            EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, last).second;
            attribute.m_type = "integer";
            currentDescription = &attribute.m_description;
            currentString = &description;
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, description));
        } else if (!string_empty(last) && string_equal(first.c_str(), "editor_model")) {
            EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, last).second;
            attribute.m_type = "model";
            currentDescription = &attribute.m_description;
            currentString = &description;
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, description));
        } else if (!string_empty(last) && string_equal(first.c_str(), "editor_color")) {
            EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, last).second;
            attribute.m_type = "color";
            currentDescription = &attribute.m_description;
            currentString = &description;
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, description));
        } else if (!string_empty(last) &&
                   (string_equal(first.c_str(), "editor_material") || string_equal(first.c_str(), "editor_mat"))) {
            EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, last).second;
            attribute.m_type = "shader";
            currentDescription = &attribute.m_description;
            currentString = &description;
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, description));
        } else if (string_equal(key, "inherit")) {
            entityClass.inheritanceResolved = false;
            ASSERT_MESSAGE(entityClass.m_parent.empty(), "only one 'inherit' supported per entityDef");
            const char *token;
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, token));
            entityClass.m_parent.push_back(token);
        }
            // begin quake4-specific keys
        else if (string_equal(key, "editor_targetonsel")) {
            //const char* value =
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
        } else if (string_equal(key, "editor_menu")) {
            //const char* value =
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
        } else if (string_equal(key, "editor_ignore")) {
            //const char* value =
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
        }
            // end quake4-specific keys
            // begin ignore prey (unknown/unused?) entity keys
        else if (string_equal(key, "editor_light")
                 || string_equal(key, "editor_def def_debrisspawner")
                 || string_equal(key, "editor_def def_drop")
                 || string_equal(key, "editor_def def_guihand")
                 || string_equal(key, "editor_def def_mine")) {
            //const char* value =
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseToken(tokeniser));
        }
            // end ignore prey entity keys
        else {
            CopiedString tmp(key);
            if (string_equal_n(key, "editor_", 7)) {
                globalErrorStream() << "unsupported editor key " << makeQuoted(key);
            }
            EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, key).second;
            attribute.m_type = "string";
            const char *value;
            PARSE_RETURN_FALSE_IF_FAIL(EntityClassDoom3_parseString(tokeniser, value));
            if (string_equal(value, "}")) { // hack for quake4 powerups.def bug
                globalErrorStream() << "entityDef " << makeQuoted(entityClass.m_name.c_str()) << " key "
                                    << makeQuoted(tmp.c_str()) << " has no value\n";
                break;
            } else {
                attribute.m_value = value;
            }
        }
        tokeniser.nextLine();
    }

    entityClass.m_comments = usage.c_str();

    if (string_equal(entityClass.m_name.c_str(), "light")) {
        {
            EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, "light_radius").second;
            attribute.m_type = "vector3";
            attribute.m_value = "300 300 300";
        }
        {
            EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, "light_center").second;
            attribute.m_type = "vector3";
        }
        {
            EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, "noshadows").second;
            attribute.m_type = "boolean";
            attribute.m_value = "0";
        }
        {
            EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, "nospecular").second;
            attribute.m_type = "boolean";
            attribute.m_value = "0";
        }
        {
            EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, "nodiffuse").second;
            attribute.m_type = "boolean";
            attribute.m_value = "0";
        }
        {
            EntityClassAttribute &attribute = EntityClass_insertAttribute(entityClass, "falloff").second;
            attribute.m_type = "real";
        }
    }

    return true;
}

bool EntityClassDoom3_parseEntityDef(Tokeniser &tokeniser)
{
    EntityClass *entityClass = Eclass_Alloc();
    entityClass->free = &Eclass_Free;

    if (!EntityClass_parse(*entityClass, tokeniser)) {
        eclass_capture_state(entityClass); // finish constructing the entity so that it can be destroyed cleanly.
        entityClass->free(entityClass);
        return false;
    }

    EntityClass *inserted = EntityClassDoom3_insertUnique(entityClass);
    if (inserted != entityClass) {
        globalErrorStream() << "entityDef " << entityClass->name()
                            << " is already defined, second definition ignored\n";
        eclass_capture_state(entityClass); // finish constructing the entity so that it can be destroyed cleanly.
        entityClass->free(entityClass);
    }
    return true;
}

bool EntityClassDoom3_parseBlock(Tokeniser &tokeniser, const char *blockType)
{
    if (string_equal(blockType, "entityDef")) {
        return EntityClassDoom3_parseEntityDef(tokeniser);
    } else if (string_equal(blockType, "model")) {
        return EntityClassDoom3_parseModel(tokeniser);
    } else {
        return EntityClassDoom3_parseUnknown(tokeniser);
    }
}

bool EntityClassDoom3_parse(TextInputStream &inputStream, const char *filename)
{
    Tokeniser &tokeniser = GlobalScriptLibrary().m_pfnNewScriptTokeniser(inputStream);

    tokeniser.nextLine();

    for (;;) {
        const char *blockType = tokeniser.getToken();
        if (blockType == 0) {
            return true;
        }
        CopiedString tmp(blockType);
        if (!EntityClassDoom3_parseBlock(tokeniser, tmp.c_str())) {
            globalErrorStream() << GlobalFileSystem().findFile(filename) << filename << ":"
                                << (unsigned int) tokeniser.getLine() << ": " << tmp.c_str()
                                << " parse failed, skipping rest of file\n";
            return false;
        }
    }

    tokeniser.release();
}


void EntityClassDoom3_loadFile(const char *filename)
{
    globalOutputStream() << "parsing entity classes from " << makeQuoted(filename) << "\n";

    StringOutputStream fullname(256);
    fullname << "def/" << filename;

    ArchiveTextFile *file = GlobalFileSystem().openTextFile(fullname.c_str());
    if (file != 0) {
        EntityClassDoom3_parse(file->getInputStream(), fullname.c_str());
        file->release();
    }
}

EntityClass *EntityClassDoom3_findOrInsert(const char *name, bool has_brushes)
{
    ASSERT_NOTNULL(name);

    if (string_empty(name)) {
        return g_EntityClassDoom3_bad;
    }

    EntityClasses::iterator i = g_EntityClassDoom3_classes.find(name);
    if (i != g_EntityClassDoom3_classes.end()
        //&& string_equal((*i).first, name)
            ) {
        return (*i).second;
    }

    EntityClass *e = EntityClass_Create_Default(name, has_brushes);
    EntityClass *inserted = EntityClassDoom3_insertUnique(e);
    ASSERT_MESSAGE(inserted == e, "");
    return inserted;
}

const ListAttributeType *EntityClassDoom3_findListType(const char *name)
{
    return 0;
}


void EntityClass_resolveInheritance(EntityClass *derivedClass)
{
    if (derivedClass->inheritanceResolved == false) {
        derivedClass->inheritanceResolved = true;
        EntityClasses::iterator i = g_EntityClassDoom3_classes.find(derivedClass->m_parent.front().c_str());
        if (i == g_EntityClassDoom3_classes.end()) {
            globalErrorStream() << "failed to find entityDef " << makeQuoted(derivedClass->m_parent.front().c_str())
                                << " inherited by " << makeQuoted(derivedClass->m_name.c_str()) << "\n";
        } else {
            EntityClass *parentClass = (*i).second;
            EntityClass_resolveInheritance(parentClass);
            if (!derivedClass->colorSpecified) {
                derivedClass->colorSpecified = parentClass->colorSpecified;
                derivedClass->color = parentClass->color;
            }
            if (!derivedClass->sizeSpecified) {
                derivedClass->sizeSpecified = parentClass->sizeSpecified;
                derivedClass->mins = parentClass->mins;
                derivedClass->maxs = parentClass->maxs;
                derivedClass->fixedsize = parentClass->fixedsize;
            }

            for (EntityClassAttributes::iterator j = parentClass->m_attributes.begin();
                 j != parentClass->m_attributes.end(); ++j) {
                EntityClass_insertAttribute(*derivedClass, (*j).first.c_str(), (*j).second);
            }
        }
    }
}

class EntityClassDoom3 : public ModuleObserver {
    std::size_t m_unrealised;
    ModuleObservers m_observers;
public:
    EntityClassDoom3() : m_unrealised(2)
    {
    }

    void realise()
    {
        if (--m_unrealised == 0) {
            globalOutputStream() << "searching vfs directory " << makeQuoted("def") << " for *.def\n";
            GlobalFileSystem().forEachFile("def/", "def", makeCallbackF(EntityClassDoom3_loadFile));

            {
                for (Models::iterator i = g_models.begin(); i != g_models.end(); ++i) {
                    Model_resolveInheritance((*i).first.c_str(), (*i).second);
                }
            }
            {
                for (EntityClasses::iterator i = g_EntityClassDoom3_classes.begin();
                     i != g_EntityClassDoom3_classes.end(); ++i) {
                    EntityClass_resolveInheritance((*i).second);
                    if (!string_empty((*i).second->m_modelpath.c_str())) {
                        Models::iterator j = g_models.find((*i).second->m_modelpath);
                        if (j != g_models.end()) {
                            (*i).second->m_modelpath = (*j).second.m_mesh;
                            (*i).second->m_skin = (*j).second.m_skin;
                        }
                    }
                    eclass_capture_state((*i).second);

                    StringOutputStream usage(256);

                    usage << "-------- NOTES --------\n";

                    if (!string_empty((*i).second->m_comments.c_str())) {
                        usage << (*i).second->m_comments.c_str() << "\n";
                    }

                    usage << "\n-------- KEYS --------\n";

                    for (EntityClassAttributes::iterator j = (*i).second->m_attributes.begin();
                         j != (*i).second->m_attributes.end(); ++j) {
                        const char *name = EntityClassAttributePair_getName(*j);
                        const char *description = EntityClassAttributePair_getDescription(*j);
                        if (!string_equal(name, description)) {
                            usage << EntityClassAttributePair_getName(*j) << " : "
                                  << EntityClassAttributePair_getDescription(*j) << "\n";
                        }
                    }

                    (*i).second->m_comments = usage.c_str();
                }
            }

            m_observers.realise();
        }
    }

    void unrealise()
    {
        if (++m_unrealised == 1) {
            m_observers.unrealise();
            EntityClassDoom3_clear();
        }
    }

    void attach(ModuleObserver &observer)
    {
        m_observers.attach(observer);
    }

    void detach(ModuleObserver &observer)
    {
        m_observers.detach(observer);
    }
};

EntityClassDoom3 g_EntityClassDoom3;

void EntityClassDoom3_attach(ModuleObserver &observer)
{
    g_EntityClassDoom3.attach(observer);
}

void EntityClassDoom3_detach(ModuleObserver &observer)
{
    g_EntityClassDoom3.detach(observer);
}

void EntityClassDoom3_realise()
{
    g_EntityClassDoom3.realise();
}

void EntityClassDoom3_unrealise()
{
    g_EntityClassDoom3.unrealise();
}

void EntityClassDoom3_construct()
{
    GlobalFileSystem().attach(g_EntityClassDoom3);

    // start by creating the default unknown eclass
    g_EntityClassDoom3_bad = EClass_Create("UNKNOWN_CLASS", Vector3(0.0f, 0.5f, 0.0f), "");

    EntityClassDoom3_realise();
}

void EntityClassDoom3_destroy()
{
    EntityClassDoom3_unrealise();

    g_EntityClassDoom3_bad->free(g_EntityClassDoom3_bad);

    GlobalFileSystem().detach(g_EntityClassDoom3);
}

class EntityClassDoom3Dependencies : public GlobalFileSystemModuleRef, public GlobalShaderCacheModuleRef {
};

class EntityClassDoom3API {
    EntityClassManager m_eclassmanager;
public:
    typedef EntityClassManager Type;

    STRING_CONSTANT(Name, "doom3");

    EntityClassDoom3API()
    {
        EntityClassDoom3_construct();

        m_eclassmanager.findOrInsert = &EntityClassDoom3_findOrInsert;
        m_eclassmanager.findListType = &EntityClassDoom3_findListType;
        m_eclassmanager.forEach = &EntityClassDoom3_forEach;
        m_eclassmanager.attach = &EntityClassDoom3_attach;
        m_eclassmanager.detach = &EntityClassDoom3_detach;
        m_eclassmanager.realise = &EntityClassDoom3_realise;
        m_eclassmanager.unrealise = &EntityClassDoom3_unrealise;
    }

    ~EntityClassDoom3API()
    {
        EntityClassDoom3_destroy();
    }

    EntityClassManager *getTable()
    {
        return &m_eclassmanager;
    }
};

#include "modulesystem/singletonmodule.h"
#include "modulesystem/moduleregistry.h"

typedef SingletonModule<EntityClassDoom3API, EntityClassDoom3Dependencies> EntityClassDoom3Module;
typedef Static<EntityClassDoom3Module> StaticEntityClassDoom3Module;
StaticRegisterModule staticRegisterEntityClassDoom3(StaticEntityClassDoom3Module::instance());