#ifndef _ASW_SCRIPT_OBJECT_H_
#define _ASW_SCRIPT_OBJECT_H_

#include <boost/shared_ptr.hpp>
#include "asw/script/parameter.h"

namespace ASW
{
    namespace Script
    {
        class Object;

        // Encapsulates a script call in a Variant
        class Function
        {
        public:
            ~Function();

            void Call();
        };

        // Represents a method accessible from script - either scripted or compiled
        class Method
        {
        public:
            virtual ~Method() {}

                    void                                       Call(Object &, Variant &) const;
                    void                                       Call(Object &, const Parameter &) const;
                    void                                       Call(Object &, const Parameter &, Variant &) const;
            virtual void                                       Call(Object &, const Parameter::Container *, Parameter::List *, const int) const = 0;
            virtual const ASW::Script::Parameter::Definition * GetSignature() const = 0;

            typedef std::auto_ptr<Method>                    AutoPtr;
            typedef boost::shared_ptr<Method>                SharedPtr;
            typedef std::list<const Method *>                List;
            typedef std::pair<const TCHAR *, const Method *> Definition;

            // This class is used by script globals to link parent virtual tables
            class Table
            {
            private:
                const Definition * m_ptrMethods;
                const Table *      m_ptrParent;

            public:
                Table(const Definition * ptrMethods = NULL, const Table * ptrParent = NULL)
                    : m_ptrMethods(ptrMethods), m_ptrParent(ptrParent) {}

                const Method * GetMethod(const TCHAR *) const;
            };
        };

        // Represents a scripted method
        class MethodScript : public Method
        {
        private:
            UTIL::String m_clsBody;

        public:
            MethodScript() {}
            MethodScript(const TCHAR * ptrBody) : m_clsBody(ptrBody) {}
            virtual ~MethodScript();

            using Method::Call;
            virtual void                                       Call(Object &, const Parameter::Container *, Parameter::List *, const int) const;
            virtual const TCHAR *                              GetBody() const {return m_clsBody.c_str();}
            virtual const ASW::Script::Parameter::Definition * GetSignature() const {return NULL;}
        };

        // Represents an object stored outside script memory but accessible to it
        class Object
        {
        public:
            virtual ~Object();

            virtual const Object * GetEnvironment(const Object *, const Object *) const = 0;
            virtual const Method * GetMethod(const TCHAR *) const = 0;
            virtual Variant        GetProperty(const TCHAR *) const = 0;
            virtual void           SetProperty(const TCHAR *, const Variant &) = 0;
            virtual bool           IsDangling() const = 0;
        };

        // Used by script global objects; facilitates calling compiled methods from script
        template <typename T>
        class Callback : public Method
        {
        public:
            typedef void (* Signature)(T &, const Parameter::Container &, Parameter::List &);

        private:
            Signature                                  m_ftnCallback;
            const ASW::Script::Parameter::Definition * m_ptrParameters;

        public:
            Callback(Signature ftnCallback, const ASW::Script::Parameter::Definition * ptrParameters = NULL)
                : m_ftnCallback(ftnCallback),
                  m_ptrParameters(ptrParameters) {}

            virtual void Call(Object & refObject, const Parameter::Container * ptrParameters, Parameter::List * ptrReturn, const int intReturnAmount) const
            {
                ASW::Script::Parameter::Array clsArray(ptrParameters);
                ASW::Script::Parameter::List clsReturn;
                if ( ptrReturn == NULL )
                    ptrReturn = &clsReturn;

                m_ftnCallback(static_cast<T &>(refObject), clsArray, *ptrReturn);
                if ( intReturnAmount >= 0 && ptrReturn != NULL )
                    ptrReturn->Trim((unsigned int)(intReturnAmount));
            }

            virtual const ASW::Script::Parameter::Definition * GetSignature() const {return m_ptrParameters;}
        };

        // A convenience class for hiding code from the global namespace
        class Registry
        {
            template <typename T, typename Traits> friend class Global;

        private:
            static void Register(Object &, const TCHAR *);
        };
    }
}

#endif