// This file is a part of the Framsticks GDK.
// Copyright (C) 1999-2014  Maciej Komosinski and Szymon Ulatowski.  See LICENSE.txt for details.
// Refer to http://www.framsticks.com/ for further information.

#include "mutableparam.h"
#include <frams/util/extvalue.h>

#define FIELDSTRUCT MutableParam
ParamEntry MutableParam::pe_tab[]=
{
{"clear",0,PARAM_DONTSAVE+PARAM_USERHIDDEN,"remove all properties","p",PROCEDURE(p_clear),},
{"add",0,PARAM_DONTSAVE+PARAM_USERHIDDEN,"add property (id,type,name,help)","p",PROCEDURE(p_addprop),},
{"remove",0,PARAM_DONTSAVE+PARAM_USERHIDDEN,"remove property (index)","p",PROCEDURE(p_remprop),},
{"addGroup",0,PARAM_DONTSAVE+PARAM_USERHIDDEN,"add group (name)","p",PROCEDURE(p_addgroup),},
{"removeGroup",0,PARAM_DONTSAVE+PARAM_USERHIDDEN,"remove group (index)","p",PROCEDURE(p_remgroup),},
{"changedProperty",0,PARAM_DONTSAVE+PARAM_USERHIDDEN+PARAM_READONLY,"last changed property #","d",FIELD(changed),},
{"changedPropertyId",0,PARAM_DONTSAVE+PARAM_USERHIDDEN+PARAM_READONLY,"last changed property id","s",GETONLY(changedname),},
};
#undef FIELDSTRUCT

MutableParam::MutableParam(const char*n,const char*g,int gr0)
	:SimpleAbstractParam(this,n),persistgroup0(gr0),grprefix(g)
{
if (persistgroup0)
	addGroup(grprefix,1);
}

int MutableParam::findGroup(const SString name,int ignoreprefix)
{
int skipprefix=grprefix.len()?grprefix.len()+2:0;
for (int i=0;i<groups.size();i++)
	{
	if (ignoreprefix)
		{
      const char *noprefix=(const char*)groupname(i);
      if ((int)strlen(noprefix) < skipprefix) continue;
		noprefix+=skipprefix;
		if (!strcmp(noprefix,(const char*)name)) return i;
		}
		else
			if (groupname(i)==name) return i;
	}
return -1;
}

int MutableParam::addGroup(const SString& gname,int noprefix)
{
SString tmp;
if (noprefix)
	tmp=gname;
else
	{
	tmp=grprefix;
	if (tmp.len()) tmp+=": ";
	tmp+=gname;
	}
groups+=new SString(tmp);
int position=groups.size()-1;
ongroupadd.action(position);
return position;
}

void MutableParam::removeGroup(int g)
{
if ((g<0)||(g>=MutableParam::getGroupCount())) return;
ParamEntry *e;
for (int i=MutableParam::getPropCount()-1;i>=staticprops;i--)
	{
	e=entry(i);
	if (g==e->group)
		removeProperty(i);
	}
SString *s=(SString *)groups(g);
if (s) delete s;
groups-=g;
ongroupdelete.action(g);
}

int MutableParam::grmember(int g,int a)
{
if (g==0)
	{
	if (getGroupCount()<2)
		return (a<getPropCount())?a:-9999;
	if (a<staticprops) return a;
	a-=staticprops;
	}
ParamEntry *e;
for (int i=staticprops;e=entry(i);i++)
	if (g==e->group)
		if (!a--) return i;
return -9999;
}

int MutableParam::addProperty(ParamEntry *pe,int position)
{
DB(printf("MutableParam::add(%s)\n",pe->id));
if (position<0)
	position=entries.size()+staticprops;
entries.insert(position-staticprops,pe);

if (pe->offset)
	pe->flags &= ~MUTPARAM_ALLOCDATA;
else
	{
	pe->flags |= MUTPARAM_ALLOCDATA;
	void *d=0;
	switch(pe->type[0])
		{
		case 'd': d=new int(); *((int*)d)=0; break;
		case 'f': d=new double(); *((double*)d)=0; break;
		case 's': d=new SString(); break;
		case 'x': d=new ExtValue(); break;
		case 'o': d=new ExtObject(); break;
		}
	pe->offset=(int)d;
	}
onadd.action(position);
return position;
}

ParamEntry * MutableParam::removeProperty(ParamEntry *pe)
{
   int index=entries.find(pe);
   if (index>=0) return removeProperty(index); else return pe;
}

ParamEntry * MutableParam::removeProperty(int i)
{
ParamEntry *pe=(ParamEntry *)entries(i-staticprops);
DB(printf("MutableParam::remove(%d)\n",i));
void *d=(void*)pe->offset;
if (d && (pe->flags & MUTPARAM_ALLOCDATA))
	switch(pe->type[0])
		{
		case 'd': delete (int*)d; break;
		case 'f': delete (double*)d; break;
		case 's': delete (SString*)d; break;
		case 'x': delete (ExtValue*)d; break;
		case 'o': delete (ExtObject*)d; break;
		}
entries-=i-staticprops;
if (pe->flags & MUTPARAM_ALLOCENTRY)
	{
	if (pe->name) free((void*)pe->name);
	if (pe->id) free((void*)pe->id);
	if (pe->help) free((void*)pe->help);
	if (pe->type) free((void*)pe->type);
	delete pe;
	}
ondelete.action(i);
return pe;
}

void MutableParam::clear(int everything)
{
DB(printf("MutableParam::clear\n"));
for (int i=entries.size()-1;i>=0;i--)
	removeProperty(i+staticprops);
int lastgroup=(everything || (persistgroup0==0))?0:1;
for (int i=groups.size()-1;i>=lastgroup;i--)
	removeGroup(i);
}

void MutableParam::p_clear(ExtValue *args,ExtValue *ret)
{ clear(); }

int MutableParam::addProperty(void* data,const char* id,const char* type,const char* name,const char* help,int flags,int group,int position)
{
if ((!id)&&(!type)) return -1;
ParamEntry *pe=new ParamEntry();
pe->fun1=0; pe->fun2=0;
pe->group=(short)group;
pe->flags=(short)(flags | MUTPARAM_ALLOCENTRY);
pe->offset=(long)data;
pe->id=strdup(id);
pe->type=strdup(type);
pe->name=name?strdup(name):0;
pe->help=help?strdup(help):0;
return addProperty(pe,position);
}

void MutableParam::p_addprop(ExtValue *args,ExtValue *ret)
{
int i=addProperty(0,args[2].getString(),args[1].getString(),args[0].getString());
ret->setInt(i);
}

void MutableParam::p_remprop(ExtValue *args,ExtValue *ret)
{
removeProperty(args[0].getInt());
}

void MutableParam::p_addgroup(ExtValue *args,ExtValue *ret)
{
int i=addGroup(args[0].getString());
ret->setInt(i);
}

void MutableParam::p_remgroup(ExtValue *args,ExtValue *ret)
{
removeGroup(args[0].getInt());
}

void MutableParam::notify(int id)
{
changed=id;
onactivate.action(id);
}

int MutableParam::setInt(int i,long v)
{
int ret=SimpleAbstractParam::setInt(i,v);
if (ret & PSET_CHANGED) notify(i);
return ret;
}

int MutableParam::setDouble(int i,double v)
{
int ret=SimpleAbstractParam::setDouble(i,v);
if (ret & PSET_CHANGED) notify(i);
return ret;
}

int MutableParam::setString(int i,const SString &v)
{
int ret=SimpleAbstractParam::setString(i,v);
if (ret & PSET_CHANGED) notify(i);
return ret;
}

int MutableParam::setObject(int i,const ExtObject &v)
{
int ret=SimpleAbstractParam::setObject(i,v);
if (ret & PSET_CHANGED) notify(i);
return ret;
}

int MutableParam::setExtValue(int i,const ExtValue &v)
{
int ret=SimpleAbstractParam::setExtValue(i,v);
if (ret & PSET_CHANGED) notify(i);
return ret;
}

void MutableParam::call(int i,ExtValue* args,ExtValue *ret)
{
if (i<staticprops) return SimpleAbstractParam::call(i,args,ret);
notify(i);
}

///////////////////

void ParamSaver::clear()
{
for(int i=0;i<store.size();i+=2)
	{
	SString *n=(SString*)store(i);
	ExtValue *v=(ExtValue*)store(i+1);
	delete n;
	delete v;
	}	
store.clear();
}

void ParamSaver::loadFrom(ParamInterface& p)
{
int N=p.getPropCount();
for(int i=0;i<N;i++)
	{
	if (shouldLoad(p,i))
		{
		ExtValue v;
		p.get(i,v);
		store+=new SString(p.id(i));
		store+=new ExtValue(v);
		}
	}
}

void ParamSaver::saveTo(MutableParam& p)
{
for(int i=0;i<store.size();i+=2)
	{
	SString *n=(SString*)store(i);
	int prop=p.findId((const char*)*n);
	if (prop<0)
		prop=p.addProperty(0,(const char*)*n,"x",0,0,0,0,-1);
	p.setExtValue(prop,*(ExtValue*)store(i+1));
	}
}