#include <stdlib.h>
#include <confdb.h>
#include <translat.h>
#include <tlmpdia.h>
#include "ldapconf_defs.h"
#include "ldapconf.m"
#include "ldapconf.h"
#include "fields.h"

static HELP_FILE help_field ("formfield","field");

static const char K_FORMCONF[]="formconf";
static const char K_ID[]="id";
static const char K_TITLE[]="title";
static const char K_TYPE[]="type";
static const char K_MINIMUM[]="minimum";
static const char K_MAXIMUM[]="maximum";
static const char K_MUSTFILL[]="mustfill";
static const char K_VALUE[]="value";
static const char K_DEFAULT[]="default"; // Default value
static const char K_ORDER[]="order"; // Field order
static const char K_BROWSE[]="browse";	// Field is used to present
										// the records
static const char K_MULTIVAL[]="multival";	// Multiple value allowed
static const char K_OBJECTCLASS[]="objectclass";	// Associated object class

static const char *tbtype[7];

PUBLIC FIELD_DEF::FIELD_DEF()
{
	type = FLD_TYPE_STRING;
	minimum = 0;
	maximum = 8000000;
	must_fill = 0;
	val.sel = 0;
	val.num = 0;
	order = 100;
	browse = 0;
	multi = 0;
}

/*

  FIELD_DEF object - One field

*/

/*
	Edit a field definition.
	Return -1 if edit cancelled, 0 if accepted, 1 if the field
	must be deleted
*/
PUBLIC int FIELD_DEF::edit()
{
	int ret = -1;
	DIALOG dia;
	dia.newf_str (MSG_U(F_ID,"Field ID"),id);
	dia.last_noempty();
	dia.newf_str (MSG_U(F_OCLASS,"Object Class"),oclass);
	dia.newf_str (MSG_U(F_TITLE,"Field title"),title);
	dia.last_noempty();
	dia.newf_num (MSG_U(F_ORDER,"Field order"),order);
	dia.newf_chk (MSG_U(F_BROWSE,"Visible"),browse,MSG_U(I_BROWSE,"in browser"));
	FIELD_ENUM *fenum = dia.newf_enum (MSG_U(F_TYPE,"Field type"),type);
	for (int i=0; i<8; i++) fenum->addopt(tbtype[i]);
	dia.newf_chk (MSG_U(F_STRINGF,"String field"),must_fill
				  ,MSG_U(I_STRINGF,"must be filled"));
	dia.newf_num (MSG_U(F_MINIMUM,"Minimum value"),minimum);
	int field_maximum = dia.getnb();
	dia.newf_num (MSG_U(F_MAXIMUM,"Maximum value"),maximum);
	dia.newf_str (MSG_U(F_DEFAULT,"Default value"),fdefault);
	dia.newf_chk (MSG_U(F_MULTIVAL,"Multiple values"),multi
		,MSG_U(I_MULTIVAL,"allowed"));
	dia.newf_title ("",MSG_U(T_VALUES,"List values"));
	int field_value = dia.getnb();
	{
		// Make sure there are at least 4 empty value entries
		int nb_empty = 0;
		for (int i=0; i<values.getnb(); i++){
			if (values.getitem(i)->is_empty()) nb_empty++;
		}
		for (int i=nb_empty; i<4; i++) values.add (new SSTRING);
		for (int i=0; i<values.getnb(); i++){
			dia.newf_str ("",*values.getitem(i));
		}
	}
	int nof = 0;
	dia.delwhat (MSG_U(I_DELFIELD,"the field definition"));
	while (1){
		MENU_STATUS code = dia.edit (MSG_U(T_FIELD_DEF,"Field definition")
									 ,MSG_U(I_FIELD_DEF,"You must describe one input field")
									 ,help_field
									 ,nof,MENUBUT_DEL|MENUBUT_CANCEL|MENUBUT_ACCEPT);
		if (code == MENU_CANCEL || code == MENU_ESCAPE){
			break;
		}else if (code == MENU_DEL){
			if (xconf_delok()){
				ret = 1;
				break;
			}
		}else if (minimum > maximum){
			xconf_error (MSG_U(E_RANGE,"Maximum must be greater than minimum"));
			nof = field_maximum;
		}else if (id.strchr(' ')!=NULL){
			xconf_error (MSG_U(E_NOSPACE,"No space allowed in ID"));
			nof = 0;
		}else{
			int nb_empty = 0;
			for (int i=0; i<values.getnb(); i++){
				if (values.getitem(i)->is_empty()) nb_empty++;
			}
			if (values.getnb() - nb_empty < 2
				&& type == FLD_TYPE_LIST){
				xconf_error (MSG_U(E_2ITEMS
								   ,"You must define minimally 2 values\n"
								   "for an enumeration field"));
				nof = field_value;
			}else{
				values.remove_empty();
				ret = 0;
				break;
			}
		}
	}
	return ret;
}

/*
	Load the value of a field for a given key
*/
PUBLIC void FIELD_DEF::loadval(CONFDB *c_data, const char *key)
{
	/* 
	   Lower the case of the attribute name since confdb is case-sensitive 
	   and we already lowered the name in ldap_object.
	*/
 
	id.to_lower();
	SSTRINGS tmp;
	int n = c_data->getall (key,id.get(),tmp,false);
	const char *s = "";
	if (n > 0) s = tmp.getitem(0)->get();

	D(debugf(6,"FIELD_DEF::loadval key=%s id=%s title=%s val=%s\n",key,id.get(),title.get(),s));

	if (s != NULL){
		if (type == FLD_TYPE_STRING || type == FLD_TYPE_COMBO || type == FLD_TYPE_LIST){
			val.strs.append (tmp);
		}else if (type == FLD_TYPE_BOOL){
			val.sel = atoi(s);
		}else if (type == FLD_TYPE_NUM || type == FLD_TYPE_ENUM){
			val.num = atoi(s);
		}
	}
}
/*
	Save the value of a field for a given key
*/
PUBLIC void FIELD_DEF::saveval(CONFDB &c_data, const char *key)
{
	const char *ptid = id.get();
	if (type == FLD_TYPE_STRING || type == FLD_TYPE_COMBO || type == FLD_TYPE_LIST){
		for (int i=0; i<val.strs.size(); i++){
			const char *s = val.strs.getitem(i)->get();
			if (s[0] != '\0') c_data.add (key,ptid,s);
		}
	}else if (type == FLD_TYPE_BOOL){
		c_data.add (key,ptid,val.sel);
	}else if (type == FLD_TYPE_NUM || type == FLD_TYPE_ENUM){
		c_data.add (key,ptid,val.num);
	}else // Other fields are not for data and should not be saved
		return;
}

#if 0
PUBLIC void FIELD_DEF::saveval(SSTRING_KEYS &c_data)
{
	const char *ptid = id.get();
	if (type == FLD_TYPE_STRING || type == FLD_TYPE_COMBO || type == FLD_TYPE_LIST){
		for (int i=0; i<val.strs.size(); i++){
			const char *s = val.strs.getitem(i)->get();
			if (s[0] != '\0') c_data.add (ptid,s);
		}
	}else if (type == FLD_TYPE_BOOL){
		SSTRING tmp;
		tmp.setfromf ("%d",val.sel);
		c_data.add (ptid,tmp.get());
	}else if (type == FLD_TYPE_NUM || type == FLD_TYPE_ENUM){
		SSTRING tmp;
		tmp.setfromf ("%d",val.num);
		c_data.add (ptid,tmp.get());
	}else // Other fields are not for data and should not be saved
		return;
}
#endif

PUBLIC void FIELD_DEF::saveval(LDAPOBJECT &ldapo)
{
	const char *ptid = id.get();
	if (type == FLD_TYPE_STRING || type == FLD_TYPE_COMBO || type == FLD_TYPE_LIST){
		for (int i=0; i<val.strs.size(); i++){
			const char *s = val.strs.getitem(i)->get();
			if (s[0] != '\0'){
				ldapo.at_add (ptid,s);
				ldapo.oc_add (oclass);
			}
		}
	}else if (type == FLD_TYPE_BOOL){
		ldapo.at_add (ptid,val.sel);
		ldapo.oc_add (oclass);
	}else if (type == FLD_TYPE_NUM || type == FLD_TYPE_ENUM){
		ldapo.at_add (ptid,val.num);
		ldapo.oc_add (oclass);
	}else // Other fields are not for data and should not be saved
		return;
}

PUBLIC void FIELD_DEF::set(const char *s)
{
	if (type == FLD_TYPE_STRING || type == FLD_TYPE_COMBO || type == FLD_TYPE_LIST){
		val.strs.remove_all();
		val.strs.add (s);
	}else if (type == FLD_TYPE_BOOL){
		val.sel = atoi(s);
	}else if (type == FLD_TYPE_NUM || type == FLD_TYPE_ENUM){
		val.num = atoi(s);
	}else // Other fields are not for data and should not be saved
		return;
}

/* Delete the value of a field for a given key */
PUBLIC void FIELD_DEF::delval(CONFDB &c_data, const char *key)
{
	c_data.removeall (key,id.get());
}

/*
	Returns the first string value.
*/
PUBLIC const char *FIELD_DEF::getvalstr() const
{
	const char *ret = "";
	if (type == FLD_TYPE_STRING || type == FLD_TYPE_COMBO
		|| type == FLD_TYPE_LIST){
		if (val.strs.size() == 1){
			ret = val.strs.getitem(0)->get();
		}
	}
	return ret;
}

/* Find numbered field */
PUBLIC FIELD_DEF *FIELD_DEFS::getitem(int no) const
{
	return (FIELD_DEF*)ARRAY::getitem(no);
}

/* Get items for this key from the dataobject */
PUBLIC void FIELD_DEFS::loadval(CONFDB *c_data, const char *key)
{
	for (int i=0; i<getnb(); i++) getitem(i)->loadval(c_data,key);
}

/* Save items for this key in the dataobject */
PUBLIC void FIELD_DEFS::saveval(CONFDB &c_data, const char *key)
{	
	// Remove the old entry
	delval(c_data,key);
	for (int i=0; i<getnb(); i++) getitem(i)->saveval(c_data,key);
}
PUBLIC void FIELD_DEFS::saveval(LDAPOBJECT &ldapo)
{
	for (int i=0; i<getnb(); i++) getitem(i)->saveval(ldapo);
}
#if 0
/* Save items for this key in the dataobject */
PUBLIC void FIELD_DEFS::saveval(SSTRING_KEYS &c_data)
{	
	for (int i=0; i<getnb(); i++) getitem(i)->saveval(c_data);
}
#endif

/* Delete items for this key in the dataobject */
PUBLIC void FIELD_DEFS::delval(CONFDB &c_data, const char *key)
{
	for (int i=0; i<getnb(); i++) getitem(i)->delval(c_data,key);
}

PUBLIC FIELD_DEFS::FIELD_DEFS()
{

}

/* Init from confdb object */
PUBLIC FIELD_DEFS::FIELD_DEFS(CONFDB *formconfig)
{
	c_form = formconfig;
}

/* Init from config file */
PUBLIC FIELD_DEFS::FIELD_DEFS(CONFIG_FILE *formfile)
{
	c_form = new CONFDB(*formfile);
}

/* Init from filename */
PUBLIC FIELD_DEFS::FIELD_DEFS(const char *filename)
{	
	f_form = new CONFIG_FILE(filename,help_field
							 ,CONFIGF_MANAGED|CONFIGF_OPTIONAL
							 ,"root","root",0600);	
	c_form = new CONFDB(*f_form);
}

/*
  
  Read from form config

*/

PUBLIC int FIELD_DEFS::read()
{
	SSTRINGS tb;
	c_form->getall (K_FORMCONF,K_ID,tb,false);
	for (int i=0; i<tb.getnb(); i++){
		FIELD_DEF *d = new FIELD_DEF;
		add (d);
		const char *id = tb.getitem(i)->get();
		d->id.setfrom (id);
		char key[100];
		snprintf (key,sizeof(key)-1,"%s",id);
		d->title.setfrom (c_form->getval (key,K_TITLE));
		d->type = c_form->getvalnum (key,K_TYPE,FLD_TYPE_STRING);
		d->must_fill = c_form->getvalnum (key,K_MUSTFILL,0);
		d->minimum = c_form->getvalnum (key,K_MINIMUM,0);
		d->maximum = c_form->getvalnum (key,K_MAXIMUM,8000000);
		d->fdefault.setfrom (c_form->getval (key,K_DEFAULT));
		if (d->fdefault.getlen()>0) {
        		D(debugf(4,">>>FIELDS_DEFS::read key=%s, default=%s\n",key,d->fdefault.get()));
		}
		d->order = c_form->getvalnum (key,K_ORDER,100);
		d->browse = c_form->getvalnum (key,K_BROWSE,0);
		d->multi = c_form->getvalnum (key,K_MULTIVAL,0);
		d->oclass.setfrom (c_form->getval (key,K_OBJECTCLASS));

		c_form->getall (key,K_VALUE,d->values,true);
	}
	return 0;
}

/*
	Update form config file
*/

PUBLIC int FIELD_DEFS::write()
{
	SSTRINGS tb;
	c_form->getall (K_FORMCONF,K_ID,tb,false);
	for (int i=0; i<tb.getnb(); i++){
		char key[100];
		snprintf (key,sizeof(key)-1,"%s",tb.getitem(i)->get());
		c_form->removeall (key,K_TITLE);
		c_form->removeall (key,K_TYPE);
		c_form->removeall (key,K_MUSTFILL);
		c_form->removeall (key,K_MINIMUM);
		c_form->removeall (key,K_MAXIMUM);
		c_form->removeall (key,K_VALUE);
		c_form->removeall (key,K_ORDER);
		c_form->removeall (key,K_BROWSE);
		c_form->removeall (key,K_DEFAULT);
		c_form->removeall (key,K_MULTIVAL);
		c_form->removeall (key,K_OBJECTCLASS);
	}
	c_form->removeall (K_FORMCONF,K_ID);
	for (int i=0; i<getnb(); i++){
		FIELD_DEF *d = getitem(i);
		c_form->add (K_FORMCONF,K_ID,d->id);
		char key[100];
		snprintf (key,sizeof(key)-1,"%s",d->id.get());
		c_form->add (key,K_TITLE,d->title);
		c_form->add (key,K_TYPE,d->type);
		c_form->add (key,K_MUSTFILL,d->must_fill);
		c_form->add (key,K_MINIMUM,d->minimum);
		c_form->add (key,K_MAXIMUM,d->maximum);
		c_form->add (key,K_ORDER,d->order);
		c_form->add (key,K_BROWSE,d->browse);
		c_form->add (key,K_DEFAULT,d->fdefault);
		c_form->add (key,K_MULTIVAL,d->multi);
		c_form->add (key,K_OBJECTCLASS,d->oclass);
		c_form->replace (key,K_VALUE,d->values);
	}
	return c_form->save();
}

<mod>
PUBLIC int FIELD_DEFS::edit()
{
	glocal FIELD_DEFS *f = this;
	tbtype[0] = MSG_U(I_STRING,"Text");        // String value
	tbtype[1] = MSG_U(I_BOOL,"Checkbox");      // Checkbox value
	tbtype[2] = MSG_U(I_NUM,"Numeric");        // Numeric value
	tbtype[3] = MSG_U(I_ENUM,"Enumeration");   // Enum value
	tbtype[4] = MSG_U(I_PAD,"Pad");            // Insert a pad
	tbtype[5] = MSG_U(I_TITLE,"Title");        // Insert a title
	tbtype[6] = MSG_U(I_COMBO,"Combo");        // String value from picklist or user
	tbtype[7] = MSG_U(I_LIST,"List");          // String value from picklist only

	<call editrecords>(MSG_U(T_FIELDDEFS,"Field definitions")
		 ,MSG_U(I_FIELDDEFS,"Define all the fields to be used in this form")
		 ,help_field);
	<f head>
		newf_head (MSG_U(H_FIELDDEF,"Title\tType\tOrder\tMulti\tMandatory\tObjectClass"));
		sethdispo ("llrccl");
		sortable  ();
		sortpolicy ("naaaaa");
		addwhat (MSG_U(I_ADDF,"a new field"));
	</f>
	<f load>
		for (int i=0; i<glocal.f->size(); i++){
			FIELD_DEF *d = glocal.f->getitem(i);
			new_menuitemf (d->title.get(),"%s\t%d\t%s\t%s\t%s"
				,tbtype[d->type]
				,d->order
				,d->multi ? "X" : ""
				,d->must_fill ? "X" : ""
				,d->oclass.get());
		}
	</f>
	<f add>
		FIELD_DEF *d = new FIELD_DEF;
		if (glocal.f->editone(d)==0) {
		}
	</f>
	<f editone>
		glocal.f->editone(no); 
	</f>
	</call>
	return 0;
}
</mod>
PUBLIC SSTRING * FIELD_DEFS::getdefault(const char *sid)
{
// NOTE : we must compare with the id, not the title because the title may have been customized by user
  for (int i=0; i<getnb(); i++){
    FIELD_DEF *d = getitem(i);
    if (d && !strcasecmp(d->id.get(),sid)){
      if (d->fdefault.getlen()>0) {
        D(debugf(6,"FIELD_DEF::getdefault FOUND default for key %s : %s\n",sid,d->fdefault.get()));
        return &d->fdefault;
      }
    }
  }
  return NULL; // not found : this attribute is not defined in the form
// or the value was empty so we didn't return in the loop
}

PUBLIC void FIELD_DEFS::setupdia(DIALOG &dia)
{
	for (int i=0; i<getnb(); i++){
		FIELD_DEF *d = getitem(i);
		int type = d->type;
		const char *title = d->title.get();
		int str_size = d->val.strs.size();
		if (str_size == 0 || d->multi){
			str_size++;
			d->val.strs.add ("");
		}
		d->field_num = dia.getnb();
		if (type == FLD_TYPE_STRING){
			for (int i=0; i<str_size; i++){
				dia.newf_str (title,*d->val.strs.getitem(i));
				title = "";
				if (i==0 && d->must_fill) dia.last_noempty();
			}
		}else if (type == FLD_TYPE_BOOL){
			dia.newf_chk (title,d->val.sel,"");
		}else if (type == FLD_TYPE_NUM){
			dia.newf_num (title,d->val.num);
		}else if (type == FLD_TYPE_ENUM){
			FIELD_ENUM *fenum = dia.newf_enum (title,d->val.num);
			for (int j=0; j<d->values.getnb(); j++){
				fenum->addopt (d->values.getitem(j)->get());
			}		
		}else if (type == FLD_TYPE_COMBO){
			for (int i=0; i<str_size; i++){
				FIELD_COMBO *fcombo = dia.newf_combo (title,*d->val.strs.getitem(i));
				title = "";
				for (int j=0; j<d->values.getnb(); j++){
					fcombo->addopt (d->values.getitem(j)->get());
				}
			}
		}else if (type == FLD_TYPE_LIST){
			for (int i=0; i<str_size; i++){
				FIELD_LIST *flist = dia.newf_list (title,*d->val.strs.getitem(i));
				title = "";
				for (int j=0; j<d->values.getnb(); j++){
					flist->addopt (d->values.getitem(j)->get());
				}
			}
		}else if (type == FLD_TYPE_PAD){
			dia.newf_title(title,1,"",title);
		}else if (type == FLD_TYPE_TITLE){
			dia.newf_title("",title);
		}
	}
}	

PUBLIC int FIELD_DEFS::set (const char *id, const char *val)
{
	int ret = -1;
	for (int i=0; i<size(); i++){
		FIELD_DEF *d = getitem(i);
		if (d->id.cmp(id)==0){
			d->set (val);
		}
	}
	return ret;
}