#ifndef ENGINE_H
#define ENGINE_H

#include <string>
#include <lua.hpp>
#include <map>
#include "Video.h"
#include "OdeWorld/OdeWorld.h"
#include "wfobj/WFObj.hh"

class Engine
{
    public:
        class Object
        {
            public:
                Object(bool is_static, OdeWorld & world, GLuint dl,
                        float scale = 1.0f);
                Object(const Object & orig);
                ~Object();

                void setPosition(double x, double y, double z)
                {
                    m_ode_object->setPosition(x, y, z);
                }
                void getPosition(double * x, double * y, double * z)
                {
                    m_ode_object->getPosition(x, y, z);
                }
                void loadPhy(const std::string & path)
                {
                    m_ode_object->loadPhy(path);
                }
                void setVisible(bool visible) { m_is_visible = visible; }
                bool getVisible() { return m_is_visible; }

                void draw();

            protected:
                OdeWorld::Object * m_ode_object;
                GLuint m_display_list;
                int * m_display_list_refcnt;
                bool m_is_visible;
                float m_scale;
                bool m_is_scaled;
        };

        Engine(const std::string & path);
        ~Engine();

        std::string locateResource(const std::string & shortname);
        Video * getVideo() { return m_video; }
        bool load(const char * program);
        void run();
        void reportErrors(int status);
        OdeWorld & getWorld() { return m_world; }
        int addObject(WFObj * obj, bool is_static, float scale = 1.0f);
        void removeObject(int id);
        int cloneObject(const Object * obj);
        Object * getObject(int id);
        void doPhysics();
        void drawObjects();
        void setAutoPhysics(bool autoPhysics) { m_autoPhysics = autoPhysics; }
        bool getAutoPhysics() { return m_autoPhysics; }

        /* lua services */
        int startFrame(lua_State * L);
        int endFrame(lua_State * L);
        int setCamera(lua_State * L);

    protected:
        static Uint32 updateCallback(Uint32 interval, void * param);
        static SDL_Event userEvent;

        Uint32 updateCallback(Uint32 interval);
        void registerLibraries();
        bool fileExists(const std::string & path);
        void update();
        Object * createObject(bool is_static, GLuint display_list,
                float scale = 1.0f)
        {
            return new Object(is_static, m_world, display_list, scale);
        }

        lua_State * m_luaState;
        Video *     m_video;
        std::string m_program_path;
        std::string m_engine_path;
        OdeWorld    m_world;
        std::map<int, Object *> m_objects;
        int         m_next_object_index;
        GLdouble    m_eye[3];
        GLdouble    m_center[3];
        GLdouble    m_up[3];
        bool        m_drawing;
        bool        m_autoPhysics;
};

extern Engine * g_engine;

#endif