#ifndef __TYPEINFO_H__
#define __TYPEINFO_H__

#include "boost/smart_ptr.hpp"
#include <string>
#include <map>
#include <vector>

#include "devicememory.h"
class FieldInfo;
class Dereference;

typedef boost::shared_ptr<FieldInfo> FieldInfoPtr;
typedef std::map<int,FieldInfoPtr> FieldInfoMap;
typedef std::vector<FieldInfoPtr> FieldInfoList;
class TypeInfo {
public:
    virtual ~TypeInfo() {}
    std::string name;
    FieldInfoMap fields;
    FieldInfoList tmpfields;
    // TODO: add function to render as string
    virtual std::string summary(Pointer ptr, Value& val)=0;
    virtual Pointer getpointer(Pointer ptr, Value& val)=0;

    virtual Value readvalue(Pointer ptr) const = 0;
};

typedef boost::shared_ptr<TypeInfo>  TypeInfoPtr;
typedef std::map<std::string,TypeInfoPtr> TypeInfoMap;


class FieldInfo {
public:
    std::string name;
    TypeInfoPtr type;
    //const Dereference& deref;
    std::string tip;
    FieldInfo(const std::string& name, const TypeInfoPtr type, const std::string& tip=std::string())
        : name(name), type(type), tip(tip)
    {
    }
    Value readvalue(Pointer ptr) const
    {
        return type->readvalue(ptr);
    }
//  FieldInfo&operator=(const FieldInfo& fi)
//  {
//      name= fi.name;
//      type= fi.type;
//      tip= fi.tip;
//      return *this;
//  }
};
extern TypeInfoMap typeinfomap;
extern FieldInfoMap root;


/*
root
    CINFO => {
# summary gets a ptr and a field object
        summary => sub { return sprintf("%-4s (%d) [%s]", field("acName").c_str(), field("type"), field("pServer.lpszProcName").c_str()) },
        fields => [
            { name=>acName, type=>'char4' }
            { name=>pServer, type=>PROCESS, reftype=>ptr }
            { name=>cMethods, type=>WORD }
            { name=>ppfnmethods, type=>PFNVOID, reftype=>arrayptr(cMethods) }
        ];
    }
    HANDLE => [
        summary => sub { return sprintf("%08lx %-4s", field("hd"), field("hd.pci.acName").c_str()) },
        fields => [
            { name=>hd, type=>HDATA, reftype=>handle }
        ]
    ]
    HDATA => [
        fields => [
            { name=>pci, type=>CINFO, reftype=ptr }
            { name=>pvObj, type=>cinfomap[pci.acName], reftype=varptr }
        ];
    ]
    PROCESS => [
        fields => [
            { name=>e32, type=>e32_lite, reftype=>struct }
        ]
    ]
    KDATA => [
        fields => [
            { name=>PROCARRAY, type=>PROCESS, reftype=>arrayptr(32) }
            { name=>sections, type=>SECTION, reftype=>ptrarray(64) }
        ]
    ]

*/

#endif