#include <stdarg.h>
#include "common.h"
#include "PseuWoW.h"
#include "DefScript/DefScript.h"
#include "DefScript/DefScriptTools.h"
#include "World/Player.h"
#include "World/Opcodes.h"
#include "World/SharedDefines.h"
#include "World/WorldSession.h"
#include "World/Channel.h"
#include "World/CacheHandler.h"
#include "SCPDatabase.h"
#include "MemoryDataHolder.h"


void DefScriptPackage::_InitDefScriptInterface(void)
{
    AddFunc("pause",&DefScriptPackage::SCpause);
    AddFunc("emote",&DefScriptPackage::SCemote);
    AddFunc("follow",&DefScriptPackage::SCfollow);
    AddFunc("savecache",&DefScriptPackage::SCsavecache);
    AddFunc("sendchatmessage",&DefScriptPackage::SCSendChatMessage);
    AddFunc("joinchannel",&DefScriptPackage::SCjoinchannel);
    AddFunc("leavechannel",&DefScriptPackage::SCleavechannel);
    AddFunc("listchannel",&DefScriptPackage::SClistchannel);
    AddFunc("loadconf",&DefScriptPackage::SCloadconf);
    AddFunc("applyconf",&DefScriptPackage::SCapplyconf);
    AddFunc("applypermissions",&DefScriptPackage::SCapplypermissions);
    AddFunc("log",&DefScriptPackage::SClog);
    AddFunc("logdetail",&DefScriptPackage::SClogdetail);
    AddFunc("logerror",&DefScriptPackage::SClogerror);
    AddFunc("logdebug",&DefScriptPackage::SClogdebug);
    AddFunc("castspell",&DefScriptPackage::SCcastspell);
    AddFunc("queryitem",&DefScriptPackage::SCqueryitem);
    AddFunc("target",&DefScriptPackage::SCtarget);
    AddFunc("getscpvalue",&DefScriptPackage::SCGetScpValue);
    AddFunc("getplayerguid",&DefScriptPackage::SCGetPlayerGuid);
    AddFunc("getname",&DefScriptPackage::SCGetName);
    AddFunc("getentry",&DefScriptPackage::SCGetEntry);
    AddFunc("getitemprotovalue",&DefScriptPackage::SCGetItemProtoValue);
    AddFunc("getobjecttype",&DefScriptPackage::SCGetObjectType);
    AddFunc("objectknown",&DefScriptPackage::SCObjectKnown);
    AddFunc("getplayerperm",&DefScriptPackage::SCGetPlayerPerm);
    AddFunc("getscriptperm",&DefScriptPackage::SCGetScriptPerm);
    AddFunc("lgetfiles",&DefScriptPackage::SCGetFileList);
    AddFunc("printscript",&DefScriptPackage::SCPrintScript);
    AddFunc("getobjectvalue",&DefScriptPackage::SCGetObjectValue);
    AddFunc("getrace",&DefScriptPackage::SCGetRace);
    AddFunc("getclass",&DefScriptPackage::SCGetClass);
    AddFunc("sendworldpacket",&DefScriptPackage::SCSendWorldPacket);
    AddFunc("getopcodename",&DefScriptPackage::SCGetOpcodeName);
    AddFunc("getopcodeid",&DefScriptPackage::SCGetOpcodeID);
    AddFunc("bbgetpackedguid",&DefScriptPackage::SCBBGetPackedGuid);
    AddFunc("bbputpackedguid",&DefScriptPackage::SCBBPutPackedGuid);
    AddFunc("gui",&DefScriptPackage::SCGui);
    AddFunc("sendwho",&DefScriptPackage::SCSendWho);
    AddFunc("getobjectdist",&DefScriptPackage::SCGetObjectDistance);
    AddFunc("getobjectpos",&DefScriptPackage::SCGetPos);
    AddFunc("switchopcodehandler",&DefScriptPackage::SCSwitchOpcodeHandler);
    AddFunc("opcodedisabled",&DefScriptPackage::SCOpcodeDisabled);
    AddFunc("spoofworldpacket",&DefScriptPackage::SCSpoofWorldPacket);
    AddFunc("loaddb",&DefScriptPackage::SCLoadDB);
    AddFunc("adddbpath",&DefScriptPackage::SCAddDBPath);
    AddFunc("preloadfile",&DefScriptPackage::SCPreloadFile);
}

DefReturnResult DefScriptPackage::SCshdn(CmdSet& Set)
{
    ((PseuInstance*)parentMethod)->Stop();
    return true;
}

DefReturnResult DefScriptPackage::SCpause(CmdSet& Set){
    ((PseuInstance*)parentMethod)->Sleep(atoi(Set.defaultarg.c_str()));
    return true;
}

DefReturnResult DefScriptPackage::SCSendChatMessage(CmdSet& Set){
    if(!(((PseuInstance*)parentMethod)->GetWSession()))
    {
        logerror("Invalid Script call: SCSendChatMessage: WorldSession not valid");
        DEF_RETURN_ERROR;
    }
    std::stringstream ss;
    SCPDatabaseMgr& dbmgr = ((PseuInstance*)parentMethod)->dbmgr;
    uint32 type=atoi(Set.arg[0].c_str());
    uint32 lang=atoi(Set.arg[1].c_str());

    ss << lang;
    if(ss.str()!=Set.arg[1]) // given lang is NOT a number
    {
        SCPDatabase *langdb = dbmgr.GetDB("language");
        uint32 dblang = langdb->GetFieldByStringValue("name",Set.arg[1].c_str());
        logdev("looking up language id for lang '%s', found %i",Set.arg[1].c_str(),dblang);
        // TODO: comment this out to enable using addon language??!
        if(dblang != SCP_INVALID_INT)
            lang = dblang;
    }

    std::string msg=Set.arg[2];
    std::string to=Set.arg[3];
    ((PseuInstance*)parentMethod)->GetWSession()->SendChatMessage(type,lang,msg,to);
    return true;
}

DefReturnResult DefScriptPackage::SCsavecache(CmdSet& Set){
   ((PseuInstance*)parentMethod)->SaveAllCache();
   if(DefScriptTools::isTrue(Set.defaultarg))
   {
        std::stringstream str;
        if(((PseuInstance*)parentMethod)->GetWSession())
        {
            str << "Cache saved. [ ";
            str << ((PseuInstance*)parentMethod)->GetWSession()->plrNameCache.GetSize();
            str << " Playernames, ";
            str << ((PseuInstance*)parentMethod)->GetWSession()->objmgr.GetItemProtoCount();
            str << " Item Prototypes, ";
            str << ((PseuInstance*)parentMethod)->GetWSession()->objmgr.GetCreatureTemplateCount();
            str << " Creature Templates, ";
            str << ((PseuInstance*)parentMethod)->GetWSession()->objmgr.GetGOTemplateCount();
            str << " GameObject Tempates";
            str << " ]";

            ((PseuInstance*)parentMethod)->GetWSession()->SendChatMessage(CHAT_MSG_SAY,0,str.str(),"");
        }
   }
   return true;
}

DefReturnResult DefScriptPackage::SCemote(CmdSet& Set){
    if(Set.defaultarg.empty())
        return false;
    if(!(((PseuInstance*)parentMethod)->GetWSession()))
    {
        logerror("Invalid Script call: SCEmote: WorldSession not valid");
        DEF_RETURN_ERROR;
    }

    // check if the given name exists in the database, if it does, use its record id; if not, convert emote name into a number.
    // this supports calls like "emote 126" and "emote ready"
    uint32 id = uint32(-1);
    SCPDatabaseMgr& dbmgr = ((PseuInstance*)parentMethod)->dbmgr;
    SCPDatabase *emotedb = dbmgr.GetDB("emote");
    if(emotedb)
    {

        id = emotedb->GetFieldByStringValue("name",(char*)DefScriptTools::stringToUpper(Set.defaultarg).c_str()); // emote names are always uppercased
    }
    if(id == SCP_INVALID_INT)
    {
        id=atoi(Set.defaultarg.c_str());
        if(!id)
        {
            logerror("SCEmote: Invalid emote!");
            return true;
        }
    }
    ((PseuInstance*)parentMethod)->GetWSession()->SendEmote(id);
    return true;
}


DefReturnResult DefScriptPackage::SCfollow(CmdSet& Set)
{
    DEF_RETURN_ERROR; // prevent execution for now
        /*
    WorldSession *ws=((PseuInstance*)parentMethod)->GetWSession();
    if(Set.defaultarg.empty()){
        ws->SendChatMessage(CHAT_MSG_SAY,0,"Stopping! (Please give me a Playername to follow!)","");
        ws->SetFollowTarget(0);
        return true;
    }
    ws->SetFollowTarget(ws->plrNameCache.GetGuid(Set.defaultarg));
    std::stringstream ss;
    if(ws->GetFollowTarget())
        ss << "Following player '"<<Set.defaultarg<<"'";
    else
        ss << "Can't follow player '"<<Set.defaultarg<<"' (not known)";
    ws->SendChatMessage(CHAT_MSG_SAY,0,ss.str(),"");
        */
    return true;

}

DefReturnResult DefScriptPackage::SCjoinchannel(CmdSet& Set){
    if(Set.defaultarg.empty())
        return false;
    if(!(((PseuInstance*)parentMethod)->GetWSession()))
    {
        logerror("Invalid Script call: SCjoinchannel: WorldSession not valid");
        DEF_RETURN_ERROR;
    }
    ((PseuInstance*)parentMethod)->GetWSession()->GetChannels()->Join(Set.defaultarg,Set.arg[0]);
    return true;
}

DefReturnResult DefScriptPackage::SClistchannel(CmdSet& Set){
    if(Set.defaultarg.empty())
        return false;
    if(!(((PseuInstance*)parentMethod)->GetWSession()))
    {
        logerror("Invalid Script call: SClistchannel: WorldSession not valid");
        DEF_RETURN_ERROR;
    }
    ((PseuInstance*)parentMethod)->GetWSession()->GetChannels()->RequestList(Set.defaultarg);
    return true;
}

DefReturnResult DefScriptPackage::SCleavechannel(CmdSet& Set){
    if(Set.defaultarg.empty())
        return false;
    if(!(((PseuInstance*)parentMethod)->GetWSession()))
    {
        logerror("Invalid Script call: SCleavechannel: WorldSession not valid");
        DEF_RETURN_ERROR;
    }
    ((PseuInstance*)parentMethod)->GetWSession()->GetChannels()->Leave(Set.defaultarg);
    return true;
}

DefReturnResult DefScriptPackage::SCloadconf(CmdSet& Set){
    if(Set.defaultarg.empty())
        return false;
    std::string fn;
    if(Set.defaultarg.find('/')==std::string::npos && Set.defaultarg.find('\\')==std::string::npos)
        fn += ((PseuInstance*)parentMethod)->GetConfDir();
    fn += Set.defaultarg;

    if(variables.ReadVarsFromFile(fn))
    {
        logdev("Loaded conf file [%s]",fn.c_str());
        return true;
    }

    log("Error loading conf file [%s]",fn.c_str());
    return false;
}

DefReturnResult DefScriptPackage::SCapplypermissions(CmdSet& Set){
    this->My_LoadUserPermissions(variables);
    return true;
}

DefReturnResult DefScriptPackage::SCapplyconf(CmdSet& Set){
    ((PseuInstance*)parentMethod)->GetConf()->ApplyFromVarSet(variables);
    return true;
}

DefReturnResult DefScriptPackage::SClog(CmdSet& Set){
    log(Set.defaultarg.c_str());
    return true;
}

DefReturnResult DefScriptPackage::SClogdetail(CmdSet& Set){
    logdetail(Set.defaultarg.c_str());
    return true;
}

DefReturnResult DefScriptPackage::SClogdebug(CmdSet& Set){
    logdebug(Set.defaultarg.c_str());
    return true;
}

DefReturnResult DefScriptPackage::SClogerror(CmdSet& Set){
    logerror(Set.defaultarg.c_str());
    return true;
}

DefReturnResult DefScriptPackage::SCcastspell(CmdSet& Set)
{
        if(Set.defaultarg.empty())
                return false;
        if(!(((PseuInstance*)parentMethod)->GetWSession()))
        {
                logerror("Invalid Script call: SCcastspell: WorldSession not valid");
                DEF_RETURN_ERROR;
        }

        uint32 spellId = atoi(Set.defaultarg.c_str());

        if (spellId <= 0)
        {
                return false;
        }

        ((PseuInstance*)parentMethod)->GetWSession()->SendCastSpell(spellId);
        return true;
}

DefReturnResult DefScriptPackage::SCqueryitem(CmdSet& Set)
{
    if(!(((PseuInstance*)parentMethod)->GetWSession()))
    {
        logerror("Invalid Script call: SCqueryitem: WorldSession not valid");
        DEF_RETURN_ERROR;
    }

    uint32 id = atoi(Set.defaultarg.c_str());
    if(!id)
        return false;

    ((PseuInstance*)parentMethod)->GetWSession()->SendQueryItem(id,0);
    return true;
}

DefReturnResult DefScriptPackage::SCtarget(CmdSet& Set)
{
    // TODO: special targets: _self _pet _nearest ...
    WorldSession *ws = ((PseuInstance*)parentMethod)->GetWSession();
    if(!ws)
    {
        logerror("Invalid Script call: SCtarget: WorldSession not valid");
        DEF_RETURN_ERROR;
    }

    if(Set.defaultarg.empty())
    {
        ((PseuInstance*)parentMethod)->GetWSession()->SendSetSelection(0); // no target
        return true;
    }

    std::string what = stringToLower(Set.arg[0]);
    uint64 guid = 0;
    if(what == "guid")
    {
        guid = DefScriptTools::toUint64(Set.defaultarg);
    }
    else if(what.empty() || what == "player")
    {
        // TODO: search through all objects. for now only allow to target player
        guid = ws->plrNameCache.GetGuid(Set.defaultarg);
    }

    Object *obj = ws->objmgr.GetObj(guid);
    if(obj && (obj->IsUnit() || obj->IsCorpse())) // only units and corpses are targetable
    {
        ws->SendSetSelection(guid); // will also set the target for myCharacter
        return DefScriptTools::toString(guid);
    }
    else
    {
        logdetail("Target '%s' not found!",Set.defaultarg.c_str());
        return false;
    }
    return "";
}

/*
DefReturnResult DefScriptPackage::SCloadscp(CmdSet& Set)
{
    SCPDatabaseMgr& dbmgr = ((PseuInstance*)parentMethod)->dbmgr;
    if(Set.defaultarg.empty()) // exit if no filename was given
        return false;
    std::string dbname = stringToLower(Set.arg[0]);
    uint32 sections = 0;
    if(dbname.empty()) // if no db name was supplied, try to find it automatically in the file ("#dbname=...")
    {
        sections = dbmgr.AutoLoadFile((char*)Set.defaultarg.c_str());
        if(!sections)
        {
            logerror("Tried to auto-load SCP file: \"%s\", but no name tag found. skipped.");
        }
    }
    else
    {
        sections = dbmgr.GetDB(dbname).LoadFromFile((char*)Set.defaultarg.c_str());
        if(sections)
        {
            logdetail("Loaded SCP: \"%s\" [%s] (%u sections)",dbname.c_str(),Set.defaultarg.c_str(),sections);
        }
        else
        {
            logerror("Failed to load SCP: \"%s\" [%s]",dbname.c_str(),Set.defaultarg.c_str());
        }
    }
    return DefScriptTools::toString((uint64)sections);
}
*/

// GetScpValue,db,key entry
// db & key will be stored, that multiple calls like GetScpValue entryxyz are possible
DefReturnResult DefScriptPackage::SCGetScpValue(CmdSet& Set)
{
    static std::string dbname;
    static uint32 keyid;
    std::string entry;
    SCPDatabaseMgr& dbmgr = ((PseuInstance*)parentMethod)->dbmgr;

    if(!Set.arg[0].empty())
        dbname=Set.arg[0];
    if(!Set.arg[1].empty())
        keyid=(uint32)DefScriptTools::toUint64(Set.arg[1]);
    if(!Set.defaultarg.empty())
        entry=Set.defaultarg;
    if( (!entry.empty()) && (!dbname.empty()) )
    {
        SCPDatabase *db = dbmgr.GetDB(dbname);
        if(db)
        {
            uint32 ftype = db->GetFieldType((char*)entry.c_str());
            switch(ftype)
            {
                case SCP_TYPE_INT:
                {
                    return DefScriptTools::toString(db->GetInt(keyid,(char*)entry.c_str()));
                }
                case SCP_TYPE_FLOAT:
                {
                    return DefScriptTools::toString(db->GetFloat(keyid,(char*)entry.c_str()));
                }
                case SCP_TYPE_STRING:
                {
                    return std::string(db->GetString(keyid,(char*)entry.c_str()));
                }
                default: logerror("GetSCPValue: field '%s' does not exist in DB '%s'!",entry.c_str(),dbname.c_str());
            }
        }
        else
        {
            logerror("GetSCPValue: No such DB: '%s'",dbname.c_str());
        }
    }

    return "";
}

DefReturnResult DefScriptPackage::SCGetPlayerGuid(CmdSet& Set)
{
    if(!(((PseuInstance*)parentMethod)->GetWSession()))
    {
        logerror("Invalid Script call: SCGetPlayerGuid: WorldSession not valid");
        DEF_RETURN_ERROR;
    }
    DefReturnResult r;
    if(Set.defaultarg.empty())
    {
        r.ret="0";
    }
    else
    {
        uint64 guid=((PseuInstance*)parentMethod)->GetWSession()->plrNameCache.GetGuid(Set.defaultarg);
        r.ret=DefScriptTools::toString(guid);
    }
    return r;
}

DefReturnResult DefScriptPackage::SCGetName(CmdSet& Set)
{
    WorldSession *ws = ((PseuInstance*)parentMethod)->GetWSession();
    if(!ws)
    {
        logerror("Invalid Script call: SCGetName: WorldSession not valid");
        DEF_RETURN_ERROR;
    }
    uint64 id = DefScriptTools::toUint64(Set.defaultarg);
    std::string source = DefScriptTools::stringToLower(Set.arg[0]);

    // "guid" type can be everything - item, player, unit, gameobject... whatever has this guid.
    if(source.empty() || source == "guid")
    {
        Object *o = ws->objmgr.GetObj(id);
        std::string n;
        if(o)
        {
            n = o->GetName();
            if(!n.empty())
                return n;
        }

        if(!o || n.empty())
        {
            // fallback if that guid is player guid, its maybe stored, so check that
            if(IS_PLAYER_GUID(id))
            {
                if(ws->plrNameCache.IsKnown(id))
                    return ws->plrNameCache.GetName(id);
            }
        }
    }
    else if(source == "player")
    {
        if(ws->plrNameCache.IsKnown(id))
            return ws->plrNameCache.GetName(id);
        else
            return "";

    }
    else if(source == "item")
    {
        ItemProto *iproto = ws->objmgr.GetItemProto((uint32)id);
        return iproto ? iproto->Name : "";
    }
    else if(source == "unit")
    {
        CreatureTemplate *ct = ws->objmgr.GetCreatureTemplate((uint32)id);
        return ct ? ct->name : "";
    }
    else if(source == "gameobject")
    {
        GameobjectTemplate *gt = ws->objmgr.GetGOTemplate((uint32)id);
        return gt ? gt->name : "";
    }
    // TODO: add gameobject, dynamicobject

    return "";
}

DefReturnResult DefScriptPackage::SCGetEntry(CmdSet& Set)
{
    if(!(((PseuInstance*)parentMethod)->GetWSession()))
    {
        logerror("Invalid Script call: SCGetEntry: WorldSession not valid");
        DEF_RETURN_ERROR;
    }
    DefReturnResult r;
    uint64 guid=DefScriptTools::toUint64(Set.defaultarg);
    r.ret="0";
    Object *o=((PseuInstance*)parentMethod)->GetWSession()->objmgr.GetObj(guid);
    if(o)
    {
        r.ret=DefScriptTools::toString((uint64)o->GetEntry());
    }
    else
    {
        logerror("SCGetEntry: Object %016I64X not known",guid);
    }
    return r;
}

DefReturnResult DefScriptPackage::SCGetObjectType(CmdSet& Set)
{
    if(!(((PseuInstance*)parentMethod)->GetWSession()))
    {
        logerror("Invalid Script call: SCGetObjectType: WorldSession not valid");
        DEF_RETURN_ERROR;
    }
    DefReturnResult r;
    uint64 guid=DefScriptTools::toUint64(Set.defaultarg);
    r.ret="0";
    Object *o=((PseuInstance*)parentMethod)->GetWSession()->objmgr.GetObj(guid);
    if(o)
    {
        r.ret=DefScriptTools::toString((uint64)o->GetTypeId());
    }
    else
    {
        logerror("SCGetObjectType: Object %016I64X not known",guid);
    }
    return r;
}

DefReturnResult DefScriptPackage::SCObjectKnown(CmdSet& Set)
{
    if(!(((PseuInstance*)parentMethod)->GetWSession()))
    {
        logerror("Invalid Script call: SCObjectIsKnown: WorldSession not valid");
        DEF_RETURN_ERROR;
    }
    uint64 guid=DefScriptTools::toUint64(Set.defaultarg);
    Object *o=((PseuInstance*)parentMethod)->GetWSession()->objmgr.GetObj(guid);
    return o!=NULL;
}

DefReturnResult DefScriptPackage::SCGetPlayerPerm(CmdSet& Set)
{
    DefReturnResult r;
    uint8 perm=0;
    for (std::map<std::string,unsigned char>::iterator i = my_usrPermissionMap.begin(); i != my_usrPermissionMap.end(); i++)
        if(i->first == Set.defaultarg)
            perm = i->second;
    r.ret = toString(perm);
    return r;
}

DefReturnResult DefScriptPackage::SCGetScriptPerm(CmdSet& Set)
{
    DefReturnResult r;
    uint8 perm=0;
    for (std::map<std::string,unsigned char>::iterator i = scriptPermissionMap.begin(); i != scriptPermissionMap.end(); i++)
        if(i->first == Set.defaultarg)
            perm = i->second;
    r.ret = toString(perm);
    return r;
}

DefReturnResult DefScriptPackage::SCGetItemProtoValue(CmdSet& Set)
{
    if(!(((PseuInstance*)parentMethod)->GetWSession()))
    {
        logerror("Invalid Script call: SCGetItemProtoValue: WorldSession not valid");
        DEF_RETURN_ERROR;
    }
    DefReturnResult r;
    uint32 entry=DefScriptTools::toUint64(Set.arg[0]);
    ItemProto *proto=((PseuInstance*)parentMethod)->GetWSession()->objmgr.GetItemProto(entry);
    if(proto)
    {
        std::string t=stringToLower(Set.defaultarg);
        uint32 tmp=0;
        if(t=="class")     r.ret=toString(proto->Class);
        else if(t=="subclass")  r.ret=toString(proto->SubClass);
        else if(t=="name") r.ret=proto->Name;
        else if(t=="model" || t=="displayid")  r.ret=toString(proto->DisplayInfoID);
        else if(t=="quality")  r.ret=toString(proto->Quality);
        else if(t=="flags")  r.ret=toString(proto->Flags);
        else if(t=="buycount")  r.ret=toString(proto->BuyCount);
        else if(t=="buyprice")  r.ret=toString(proto->BuyPrice);
        else if(t=="sellprice")  r.ret=toString(proto->SellPrice);
        else if(t=="inventorytype")  r.ret=toString(proto->InventoryType);
        else if(t=="allowableclass")  r.ret=toString(proto->AllowableClass);
        else if(t=="allowablerace")  r.ret=toString(proto->AllowableRace);
        else if(t=="itemlevel")  r.ret=toString(proto->ItemLevel);
        else if(t=="reqlevel")  r.ret=toString(proto->RequiredLevel);
        else if(t=="reqskill")  r.ret=toString(proto->RequiredSkill);
        else if(t=="reqskillrank")  r.ret=toString(proto->RequiredSkillRank);
        else if(t=="reqspell")  r.ret=toString(proto->RequiredSpell);
        else if(t=="reqhonorrank")  r.ret=toString(proto->RequiredHonorRank);
        else if(t=="reqcityrank")  r.ret=toString(proto->RequiredCityRank);
        else if(t=="reqrepfaction")  r.ret=toString(proto->RequiredReputationFaction);
        else if(t=="reqreprank")  r.ret=toString(proto->RequiredReputationRank);
        else if(t=="maxcount")  r.ret=toString(proto->MaxCount);
        else if(t=="stackable")  r.ret=toString(proto->Stackable);
        else if(t=="slots")  r.ret=toString(proto->ContainerSlots);
        else if(t=="str")
        {
            for(uint32 i=0;i<10;i++)
                if(proto->ItemStat[i].ItemStatType==ITEM_STAT_STRENGTH)
                    tmp+=proto->ItemStat[i].ItemStatValue;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="agi")
        {
            for(uint32 i=0;i<10;i++)
                if(proto->ItemStat[i].ItemStatType==ITEM_STAT_AGILITY)
                    tmp+=proto->ItemStat[i].ItemStatValue;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="sta")
        {
            for(uint32 i=0;i<10;i++)
                if(proto->ItemStat[i].ItemStatType==ITEM_STAT_STAMINA)
                    tmp+=proto->ItemStat[i].ItemStatValue;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="int")
        {
            for(uint32 i=0;i<10;i++)
                if(proto->ItemStat[i].ItemStatType==ITEM_STAT_INTELLECT)
                    tmp+=proto->ItemStat[i].ItemStatValue;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="spi")
        {
            for(uint32 i=0;i<10;i++)
                if(proto->ItemStat[i].ItemStatType==ITEM_STAT_SPIRIT)
                    tmp+=proto->ItemStat[i].ItemStatValue;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="hp" || t=="health")
        {
            for(uint32 i=0;i<10;i++)
                if(proto->ItemStat[i].ItemStatType==ITEM_STAT_HEALTH)
                    tmp+=proto->ItemStat[i].ItemStatValue;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="mindmg")
        {
            for(uint32 i=0;i<5;i++)
                if(proto->Damage[i].DamageType==NORMAL_DAMAGE)
                    tmp+=proto->Damage[i].DamageMin;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="maxdmg")
        {
            for(uint32 i=0;i<5;i++)
                if(proto->Damage[i].DamageType==NORMAL_DAMAGE)
                    tmp+=proto->Damage[i].DamageMax;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="mindmg_holy")
        {
            for(uint32 i=0;i<5;i++)
                if(proto->Damage[i].DamageType==HOLY_DAMAGE)
                    tmp+=proto->Damage[i].DamageMin;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="maxdmg_holy")
        {
            for(uint32 i=0;i<5;i++)
                if(proto->Damage[i].DamageType==HOLY_DAMAGE)
                    tmp+=proto->Damage[i].DamageMax;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="mindmg_fire")
        {
            for(uint32 i=0;i<5;i++)
                if(proto->Damage[i].DamageType==FIRE_DAMAGE)
                    tmp+=proto->Damage[i].DamageMin;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="maxdmg_fire")
        {
            for(uint32 i=0;i<5;i++)
                if(proto->Damage[i].DamageType==FIRE_DAMAGE)
                    tmp+=proto->Damage[i].DamageMax;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="mindmg_nature")
        {
            for(uint32 i=0;i<5;i++)
                if(proto->Damage[i].DamageType==NATURE_DAMAGE)
                    tmp+=proto->Damage[i].DamageMin;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="maxdmg_nature")
        {
            for(uint32 i=0;i<5;i++)
                if(proto->Damage[i].DamageType==NATURE_DAMAGE)
                    tmp+=proto->Damage[i].DamageMax;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="mindmg_frost")
        {
            for(uint32 i=0;i<5;i++)
                if(proto->Damage[i].DamageType==FROST_DAMAGE)
                    tmp+=proto->Damage[i].DamageMin;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="maxdmg_frost")
        {
            for(uint32 i=0;i<5;i++)
                if(proto->Damage[i].DamageType==FROST_DAMAGE)
                    tmp+=proto->Damage[i].DamageMax;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="mindmg_shadow")
        {
            for(uint32 i=0;i<5;i++)
                if(proto->Damage[i].DamageType==SHADOW_DAMAGE)
                    tmp+=proto->Damage[i].DamageMin;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="maxdmg_shadow")
        {
            for(uint32 i=0;i<5;i++)
                if(proto->Damage[i].DamageType==SHADOW_DAMAGE)
                    tmp+=proto->Damage[i].DamageMax;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="mindmg_arcane")
        {
            for(uint32 i=0;i<5;i++)
                if(proto->Damage[i].DamageType==ARCANE_DAMAGE)
                    tmp+=proto->Damage[i].DamageMin;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="maxdmg_arcane")
        {
            for(uint32 i=0;i<5;i++)
                if(proto->Damage[i].DamageType==ARCANE_DAMAGE)
                    tmp+=proto->Damage[i].DamageMax;
            r.ret = toString((uint64)tmp);
        }
        else if(t=="armor")  r.ret=toString(proto->Armor);
        else if(t=="holyres")  r.ret=toString(proto->HolyRes);
        else if(t=="fireres")  r.ret=toString(proto->FireRes);
        else if(t=="natureres")  r.ret=toString(proto->NatureRes);
        else if(t=="frostres")  r.ret=toString(proto->FrostRes);
        else if(t=="shadowres")  r.ret=toString(proto->ShadowRes);
        else if(t=="arcaneres")  r.ret=toString(proto->ArcaneRes);
        else if(t=="delay")  r.ret=toString(proto->Delay);
        else if(t=="ammotype")  r.ret=toString(proto->Ammo_type);
        else if(t=="range")  r.ret=toString(proto->RangedModRange);
        else if(t=="bonding")  r.ret=toString(proto->Bonding);
        else if(t=="desc")  r.ret=proto->Description;
        else if(t=="pagetext")  r.ret=toString(proto->PageText);
        else if(t=="languageid")  r.ret=toString(proto->LanguageID);
        else if(t=="pagematerial")  r.ret=toString(proto->PageMaterial);
        else if(t=="startquest")  r.ret=toString(proto->StartQuest);
        else if(t=="lockid")  r.ret=toString(proto->LockID);
        else if(t=="material")  r.ret=toString(proto->Material);
        else if(t=="sheath")  r.ret=toString(proto->Sheath);
        else if(t=="randomprop")  r.ret=toString(proto->RandomProperty);
        else if(t=="randomsuffix")  r.ret=toString(proto->RandomSuffix);
        else if(t=="block")  r.ret=toString(proto->Block);
        else if(t=="itemset")  r.ret=toString(proto->ItemSet);
        else if(t=="maxdur")  r.ret=toString(proto->MaxDurability);
        else if(t=="area")  r.ret=toString(proto->Area);
        else if(t=="bagfamily")  r.ret=toString(proto->BagFamily);
        // TODO: add item spells
        else
        {
            logerror("SCGetItemProtoValue: Unknown property \"%s\" for Item Prototype %u",t.c_str(),entry);
        }
    }
    else
    {
        logerror("SCGetItemProtoValue: Item Prototype %u not known",entry);
    }
    return r;
}

DefReturnResult DefScriptPackage::SCGetFileList(CmdSet& Set)
{
    DefList *l = lists.Get(_NormalizeVarName(Set.arg[0],Set.myname));
    l->clear();
    *l = (DefList)GetFileList(Set.defaultarg);
    if(Set.arg[1].length())
    {
        std::string ext = ".";
        ext += Set.arg[1];
        ext = stringToLower(ext);
        for(DefList::iterator i = l->begin(); i != l->end(); )
        {
            std::string tmp = stringToLower(i->c_str() + (i->length() - ext.length()));
            if( tmp != ext )
            {
                i = l->erase(i);
                continue;
            }
            i++;
        }
    }
    return toString((uint64)l->size());
}

DefReturnResult DefScriptPackage::SCPrintScript(CmdSet &Set)
{
    DefScript *sc = GetScript(DefScriptTools::stringToLower(Set.defaultarg));
    if(!sc)
        return false;

    logcustom(0,GREEN,"== DefScript \"%s\", %u lines: ==",sc->GetName().c_str(),sc->GetLines());
    for(uint32 i = 0; i < sc->GetLines(); i++)
    {
        logcustom(0,GREEN,sc->GetLine(i).c_str());
    }

    return true;
}

DefReturnResult DefScriptPackage::SCGetObjectValue(CmdSet &Set)
{
    WorldSession *ws = ((PseuInstance*)parentMethod)->GetWSession();
    if(!ws)
    {
        logerror("Invalid Script call: SCGetObjectValue: WorldSession not valid");
        DEF_RETURN_ERROR;
    }

    uint64 guid = DefScriptTools::toUint64(Set.defaultarg);
    Object *o = ws->objmgr.GetObj(guid);
    if(o)
    {
        uint32 v = (uint32)DefScriptTools::toUint64(Set.arg[0]);
        if(v > o->GetValuesCount())
        {
            logerror("SCGetObjectValue [%llu, type %u]: invalid value index: %u",guid,o->GetTypeId(),v);
            return "";
        }
        else
        {
            if(DefScriptTools::stringToLower(Set.arg[1]) == "f")
                return toString((ldbl)o->GetFloatValue((UpdateFieldName)v));
            else if(DefScriptTools::stringToLower(Set.arg[1]) == "i64")
                return toString(o->GetUInt64Value((UpdateFieldName)v));
            else
                return toString((uint64)o->GetUInt32Value((UpdateFieldName)v));
        }
    }
    return "";
}

DefReturnResult DefScriptPackage::SCGetRace(CmdSet &Set)
{
    WorldSession *ws = ((PseuInstance*)parentMethod)->GetWSession();
    if(!ws)
    {
        logerror("Invalid Script call: SCGetObjectValue: WorldSession not valid");
        DEF_RETURN_ERROR;
    }

    uint64 guid = DefScriptTools::toUint64(Set.defaultarg);
    Object *o = ws->objmgr.GetObj(guid);
    if(o && (o->GetTypeId() == TYPEID_UNIT || o->GetTypeId() == TYPEID_PLAYER))
    {
        return DefScriptTools::toString((uint64)((Unit*)o)->GetRace());
    }
    return "";
}

DefReturnResult DefScriptPackage::SCGetClass(CmdSet &Set)
{
    WorldSession *ws = ((PseuInstance*)parentMethod)->GetWSession();
    if(!ws)
    {
        logerror("Invalid Script call: SCGetObjectValue: WorldSession not valid");
        DEF_RETURN_ERROR;
    }

    uint64 guid = DefScriptTools::toUint64(Set.defaultarg);
    Object *o = ws->objmgr.GetObj(guid);
    if(o && (o->GetTypeId() == TYPEID_UNIT || o->GetTypeId() == TYPEID_PLAYER))
    {
        return DefScriptTools::toString((uint64)((Unit*)o)->GetClass());
    }
    return "";
}

DefReturnResult DefScriptPackage::SCSendWorldPacket(CmdSet &Set)
{
    WorldSession *ws = ((PseuInstance*)parentMethod)->GetWSession();
    if(!ws)
    {
        logerror("Invalid Script call: SCSendWorldPacket: WorldSession not valid");
        DEF_RETURN_ERROR;
    }
    ByteBuffer *bb = bytebuffers.GetNoCreate(_NormalizeVarName(Set.defaultarg,Set.myname));
    if(bb)
    {
        uint16 opc = (uint16)DefScriptTools::toUint64(Set.arg[0]);
        if(!opc)
        {
            opc = (uint16)GetOpcodeID(Set.arg[0].c_str());
            if(opc == uint16(-1))
                return false;
        }
        if(opc) // prevent sending CMSG_NULL_ACTION
        {
            WorldPacket wp(opc, bb->size());
            if(bb->size())
                wp.append(bb->contents(), bb->size());
            ws->SendWorldPacket(wp);
            return true;
        }
    }
    return false;
}

DefReturnResult DefScriptPackage::SCGetOpcodeID(CmdSet &Set)
{
    uint32 id = GetOpcodeID(Set.defaultarg.c_str());
    return id != (uint32)(-1) ? toString(id) : "";
}

DefReturnResult DefScriptPackage::SCGetOpcodeName(CmdSet &Set)
{
    return GetOpcodeName((uint32)DefScriptTools::toUint64(Set.defaultarg));
}

DefReturnResult DefScriptPackage::SCBBGetPackedGuid(CmdSet &Set)
{
    ByteBuffer *bb = bytebuffers.GetNoCreate(_NormalizeVarName(Set.defaultarg,Set.myname));
    if (!bb)
        return false;

    if (bb->size() - bb->rpos() < sizeof(uint8))
        return false;

    uint8 mask;
    *bb >> mask;
    uint64 guid=0;
    for(uint8 i=0;i<8;i++)
    {
        if(mask & (1<<i) )
        {
            if (bb->size() - bb->rpos() < sizeof(uint8))
                return false;

            *bb >> ((uint8*)&guid)[i];
        }
    }

    return toString(guid);
}

DefReturnResult DefScriptPackage::SCBBPutPackedGuid(CmdSet &Set)
{
    ByteBuffer *bb = bytebuffers.Get(_NormalizeVarName(Set.arg[0],Set.myname));

    uint64 guid = DefScriptTools::toUint64(Set.defaultarg);
    if (!guid) // fast check if guid is empty (in this case mask must be 0 with no extra data)
    {
        *bb << uint8(0);
        return false;
    }

    ByteBuffer bbmask;
    uint8 mask = 0;

    for(uint8 i = 0; i < 8; i++)
    {
        if(guid & 0xFF)
        {
            mask |= (1<<i);
            bbmask << ((uint8)(guid & 0xFF));
        }
        guid >>= 8;
    }

    *bb << mask;
    bb->append(bbmask);

    return true;
}

DefReturnResult DefScriptPackage::SCGui(CmdSet &Set)
{
    PseuInstance *ins = (PseuInstance*)parentMethod;
    if(ins->InitGUI())
        logdebug("SCGui: gui created");
    else
    {
        logerror("SCGui: failed");
        return false;
    }
    while(!ins->GetGUI() || !ins->GetGUI()->IsInitialized())
        ins->GetRunnable()->sleep(1);

    ZThread::FastMutex mut;
    mut.acquire();
    if(!ins->GetWSession() && !ins->GetRSession())
    {
        ins->GetGUI()->SetSceneState(SCENESTATE_LOGINSCREEN);
    }
    else if(ins->GetRSession() && !ins->GetWSession())
    {
        ins->GetGUI()->SetSceneState(SCENESTATE_REALMSELECT);
    }
    else if(ins->GetRSession() && ins->GetWSession())
    {
        ins->GetGUI()->SetSceneState(SCENESTATE_CHARSELECT);
    }
    /*else if(ins->GetWSession() && !ins->GetWSession()->InWorld())
    {
        ins->GetGUI()->SetSceneState(SCENESTATE_LOGINSCREEN);
    }*/ // TODO: uncomment after implemented
    else if(ins->GetWSession() && ins->GetWSession()->InWorld())
    {
       ins->GetGUI()->SetSceneState(SCENESTATE_WORLD);
       ins->GetWSession()->objmgr.ReNotifyGUI();
    }
    else
        ins->GetGUI()->SetSceneState(SCENESTATE_GUISTART);
    mut.release();

    return true;
}

DefReturnResult DefScriptPackage::SCSendWho(CmdSet &Set)
{
    WorldSession *ws = ((PseuInstance*)parentMethod)->GetWSession();
    if(!ws)
    {
        logerror("Invalid Script call: SCSendWho: WorldSession not valid");
        DEF_RETURN_ERROR;
    }
    uint32 minlvl = (uint32)DefScriptTools::toUint64(Set.arg[0]);
    uint32 maxlvl = (uint32)DefScriptTools::toUint64(Set.arg[1]);
    uint32 racemask = (uint32)DefScriptTools::toUint64(Set.arg[2]);
    uint32 classmask = (uint32)DefScriptTools::toUint64(Set.arg[3]);
    std::string name = Set.arg[4];
    std::string guildname = Set.arg[5];
    // TODO: implement zonelist

    // convert empty string (default: 0) to default expected by server (-1 = 0xFFFFFFFF = all)
    // and do some values cleanup
    if(!racemask)
        racemask = -1;
    if(!classmask)
        classmask = -1;
    if(!maxlvl)
        maxlvl = 100;
    else if(maxlvl > 255)
        maxlvl = 255;
    if(minlvl > 255)
        minlvl = 255;
    if(minlvl > maxlvl)
        minlvl = maxlvl;

    ws->SendWhoListRequest(minlvl,maxlvl,racemask,classmask,name,guildname);
    return "";
}

DefReturnResult DefScriptPackage::SCGetObjectDistance(CmdSet &Set)
{
    WorldSession *ws = ((PseuInstance*)parentMethod)->GetWSession();
    if(!ws)
    {
        logerror("Invalid Script call: SCGetObjectDistance: WorldSession not valid");
        DEF_RETURN_ERROR;
    }
    uint64 guid1 = DefScriptTools::toUint64(Set.defaultarg);
    uint64 guid2 = DefScriptTools::toUint64(Set.arg[0]);
    std::string s = stringToLower(Set.arg[1]);
    Object *o1, *o2;
    float dist = 0;
    o1 = ws->objmgr.GetObj(guid1);
    o2 = ws->objmgr.GetObj(guid2);
    if(o1 && o2 && o1->IsWorldObject() && o2->IsWorldObject())
    {
        if(s.empty() || s == "2d")
            dist = ((WorldObject*)o1)->GetDistance2d((WorldObject*)o2);
        else if(s == "3d")
            dist = ((WorldObject*)o1)->GetDistance((WorldObject*)o2);

        return toString(ldbl(dist));
    }

    return "";
}

DefReturnResult DefScriptPackage::SCSwitchOpcodeHandler(CmdSet &Set)
{
    WorldSession *ws = ((PseuInstance*)parentMethod)->GetWSession();
    if(!ws)
    {
        logerror("Invalid Script call: SCSwitchOpcodeHandler: WorldSession not valid");
        DEF_RETURN_ERROR;
    }
    uint16 opc = (uint16)DefScriptTools::toUint64(Set.arg[0]);
    bool switchon = DefScriptTools::isTrue(Set.defaultarg);
    if(!opc) // ok we cant turn off MSG_NULL_ACTION with this, but who needs it anyway...
    {
        opc = (uint16)GetOpcodeID(Set.arg[0].c_str());
        if(opc == uint16(-1))
            return false;
    }
    else if(opc >= MAX_OPCODE_ID)
    {
        logerror("Can't enable/disable opcode handling of %u", opc);
        return false;
    }
    if(switchon)
        ws->EnableOpcode(opc);
    else
        ws->DisableOpcode(opc);

    logdebug("Opcode handler for %s (%u) %s",GetOpcodeName(opc), opc, switchon ? "enabled" : "disabled");
    return true;
}

DefReturnResult DefScriptPackage::SCOpcodeDisabled(CmdSet &Set)
{
    WorldSession *ws = ((PseuInstance*)parentMethod)->GetWSession();
    if(!ws)
    {
        logerror("Invalid Script call: SCOpcodeDisabled: WorldSession not valid");
        DEF_RETURN_ERROR;
    }
    uint16 opc = (uint16)DefScriptTools::toUint64(Set.defaultarg);
    if(!opc)
    {
        opc = (uint16)GetOpcodeID(Set.arg[0].c_str());
        if(opc == uint16(-1))
            return false;
    }
    else if(opc >= MAX_OPCODE_ID)
    {
        logerror("SCOpcodeDisabled: Opcode %u out of range", opc);
        return false; // we can NEVER handle out of range opcode, but since its not disabled, return false
    }
    return ws->IsOpcodeDisabled(opc);
}

DefReturnResult DefScriptPackage::SCSpoofWorldPacket(CmdSet &Set)
{
    WorldSession *ws = ((PseuInstance*)parentMethod)->GetWSession();
    if(!ws)
    {
        logerror("Invalid Script call: SCSpoofWorldPacket: WorldSession not valid");
        DEF_RETURN_ERROR;
    }
    ByteBuffer *bb = bytebuffers.GetNoCreate(_NormalizeVarName(Set.defaultarg,Set.myname));
    if(bb)
    {
        uint32 opcode = (uint32)DefScriptTools::toUint64(Set.arg[0]);
        if(opcode) // ok, here again CMSG_NULL_ACTION doesnt work, but who cares
        {
            WorldPacket *wp = new WorldPacket(opcode, bb->size()); // will be deleted by the opcode handler later
            if(bb->size())
                wp->append(bb->contents(), bb->size());
            logdebug("Spoofing WorldPacket with opcode %s (%u), size %u",GetOpcodeName(opcode),opcode,wp->size());
            ws->AddToPktQueue(wp); // handle this packet as if it was sent by the server
            return true;
        }
    }
    return false;
}

DefReturnResult DefScriptPackage::SCLoadDB(CmdSet &Set)
{
    PseuInstance *ins = (PseuInstance*)parentMethod;
    if(ins->dbmgr.GetDB(Set.defaultarg.c_str()))
        return "exists";
    logdetail("Loading database '%s'",Set.defaultarg.c_str());
    uint32 result = ins->dbmgr.SearchAndLoad((char*)Set.defaultarg.c_str(), false);
    return toString(result);
}

DefReturnResult DefScriptPackage::SCAddDBPath(CmdSet &Set)
{
    PseuInstance *ins = (PseuInstance*)parentMethod;
    ins->dbmgr.AddSearchPath((char*)Set.defaultarg.c_str());
    return true;
}

DefReturnResult DefScriptPackage::SCGetPos(CmdSet &Set)
{
    WorldSession *ws = ((PseuInstance*)parentMethod)->GetWSession();
    if(!ws)
    {
        logerror("Invalid Script call: SCGetPos: WorldSession not valid");
        DEF_RETURN_ERROR;
    }

    uint64 guid = DefScriptTools::toUint64(Set.arg[0]);
    Object* obj = ws->objmgr.GetObj(guid ? guid : ws->GetGuid());
    if (!obj || !obj->IsWorldObject())
        return "";

    if (Set.defaultarg == "x")
        return DefScriptTools::toString( ((WorldObject*)obj)->GetX() );
    else if (Set.defaultarg == "y")
        return DefScriptTools::toString( ((WorldObject*)obj)->GetY() );
    else if (Set.defaultarg == "z")
        return DefScriptTools::toString( ((WorldObject*)obj)->GetZ() );
    else if (Set.defaultarg == "o")
        return DefScriptTools::toString( ((WorldObject*)obj)->GetO() );
    return "";
}

DefReturnResult DefScriptPackage::SCPreloadFile(CmdSet& Set)
{
    MemoryDataHolder::BackgroundLoadFile(Set.defaultarg);
    return true;
}

void DefScriptPackage::My_LoadUserPermissions(VarSet &vs)
{
    static const char *prefix = "USERS::";
    std::string sub,usr;
    for(uint32 i=0;i<variables.Size();i++)
    {
        sub = variables[i].name.substr(0,strlen(prefix));
        if(sub == prefix)
        {
            usr = variables[i].name.substr(strlen(prefix), variables[i].name.length() - strlen(prefix));
            my_usrPermissionMap[usr] = atoi(variables[i].value.c_str());
            DEBUG( logdebug("Player '%s' permission = %u",usr.c_str(),atoi(variables[i].value.c_str())); )
        }
    }
}

void DefScriptPackage::My_Run(std::string line, std::string username)
{
    int16 scperm = -1; // builtin functions that have no explicit req. permission level assigned should be secure from beeing called from ingame
    uint8 usrperm=0; // users/players that have no explicit permission assigned should have minimal permission

    for (std::map<std::string,unsigned char>::iterator i = my_usrPermissionMap.begin(); i != my_usrPermissionMap.end(); i++)
    {
        if(i->first == username)
        {
            usrperm = i->second;
        }
    }

    DefXChgResult final;
    if(usrperm < 255 && line.find("?{")!=std::string::npos)
    {
        logerror("WARNING: %s wanted to exec \"%s\"",username.c_str(),line.c_str());
        final=ReplaceVars(line,NULL,0,false); // prevent execution of embedded scripts (= using return values) that could trigger dangerous stuff.
    }
    else
        final=ReplaceVars(line,NULL,0,true); // exec as usual


    CmdSet curSet;
    SplitLine(curSet,final.str);

    for (std::map<std::string,unsigned char>::iterator i = scriptPermissionMap.begin(); i != scriptPermissionMap.end(); i++)
    {
        if(i->first == curSet.cmd)
        {
            scperm = i->second;
        }
    }


    if(scperm >= 0) // skip "invisible" scripts (without any permission set) completely.
    {
        if(usrperm < scperm)
        {
            CmdSet Set;
            Set.arg[0] = username;
            Set.arg[1] = DefScriptTools::toString(usrperm);
            Set.arg[2] = DefScriptTools::toString(scperm);
            Set.arg[3] = curSet.cmd;
            RunScript("_nopermission",&Set);
            return;
        }
        else
        {
            Interpret(curSet);
        }
    }

}

void DefScriptPackage::my_print(const char *fmt, ...)
{
    if(!fmt)
        return;
    char buf[1000];
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(buf,1000, fmt, ap);
    va_end(ap);
    log(buf);
}

void DefScriptPackage::my_print_error(const char *fmt, ...)
{
    if(!fmt)
        return;
    char buf[1000];
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(buf,1000, fmt, ap);
    va_end(ap);
    logerror(buf);
}

void DefScriptPackage::my_print_debug(const char *fmt, ...)
{
    if(!fmt)
        return;
    char buf[1000];
    va_list ap;
    va_start(ap, fmt);
    vsnprintf(buf,1000, fmt, ap);
    va_end(ap);
    logdebug(buf);
}



