/*
 *  Copyright (C) 2000-2002  The Exult Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include "common_types.h"
#include "Configuration.h"
#include "exceptions.h"
#include "utils.h"

#ifndef ALPHA_LINUX_CXX
#  include <cassert>
#  include <cstdio>
#endif
#include <stdio.h>
#include <iostream>
#include <fstream>
#ifdef HAVE_SSTREAM
#include <sstream>
#endif

#ifndef UNDER_CE
using std::atoi;
using std::cerr;
using std::endl;
using std::string;
using std::ostream;
#endif

// isspace could be a macro
#ifndef UNDER_CE
#ifndef isspace
using std::isspace;
#endif
#endif

#define TRACE_CONF 0

#if TRACE_CONF
	#define CTRACE(X) cerr << X << endl
#else
	#define CTRACE(X)
#endif

void	Configuration::value(const string &key, string &ret,const char *defaultvalue) const
{
	const XMLnode *sub=xmltree->subtree(key);
	if(sub)
		ret = sub->value();
	else
		ret = defaultvalue;
}

void	Configuration::value(const string &key,bool &ret,bool defaultvalue) const
{
	const XMLnode *sub=xmltree->subtree(key);
	if(sub)
		ret = (to_uppercase(sub->value()) == "YES");
	else
		ret = defaultvalue;
}

void	Configuration::value(const string &key,int &ret,int defaultvalue) const
{
	const XMLnode *sub=xmltree->subtree(key);
	if(sub)
		ret = atoi(sub->value().c_str());
	else
		ret = defaultvalue;
}

void	Configuration::set(const string &key, const string &value, bool write_out)
{
	// Break k up into '/' separated elements.
	// start advancing walk, one element at a time, creating nodes
	// as needed.
	// At the end of that, walk is the target node, and we
	// can set the value.

	// We must also properly encode the value before writing it out.
	// Must remember that.

	xmltree->xmlassign(key,value);
	if(write_out)
		write_back();
}

void	Configuration::set(const char *key, const char *value, bool write_out)
{
	string	k(key), v(value);
	set(k, v, write_out);
}

void	Configuration::set(const char *key, const string &value, bool write_out)
{
	string	k(key);
	set(k, value, write_out);
}

void	Configuration::set(const char *key, int value,bool write_out)
{
	string	k(key),v;
	char	buf[32];

	snprintf(buf,32,"%d",value);
	v=buf;
	set(k,v,write_out);
}


bool	Configuration::read_config_string(const string &s)
{
	string	sbuf(s);
	size_t	nn=0;
	while(isspace(s[nn])) ++nn;
	
	assert(s[nn]=='<');
	++nn;
	
	xmltree->xmlparse(sbuf,nn);
	is_file=false;
	return true;
}

bool	Configuration::read_config_file(const string &input_filename, const string &root)
{
	string fname;

	CTRACE("Configuration::read_config_file");
	
	fname=input_filename;
	// Don't frob the filename if it starts with a dot and
	// a slash.
	// Or if it's not a relative path.
	if((fname.find("./")!=0) && (fname[0]!='/'))
	{
#if ((defined XWIN) || (defined BEOS) || (defined MACOSX))
		const char *f1=getenv("HOME");
		if(f1)
		{
			// User has a home directory
			fname=f1;
#if defined(BEOS)
			fname+="/config/settings/";
#elif defined(MACOSX)
			fname+="/Library/Preferences/";
#else
			fname+="/.";
#endif
			fname+=input_filename;
		}
		else
			fname=input_filename;
#else
		// Probably something to do with determining the username
		// and generating a filename in their personal setup area.

		// For now, just read file from current directory
		fname=input_filename;
#endif
	}

	return read_abs_config_file(fname, root);
}


// read config from file, without pre-processing the filename
bool Configuration::read_abs_config_file(const string &input_filename, const string &root)
{
	filename = input_filename;

	CTRACE("Configuration::read_abs_config_file");

	clear(root);

	is_file=true; // set to file, even if file not found

	std::ifstream ifile;
	try {
	   U7open(ifile, filename.c_str(), true);
	}
	catch(exult_exception &) {
		// configuration file not found
		return false;
	}

	if(ifile.fail())
		return false;

	string	sbuf, line;
	// copies the entire contents of the input file into sbuf
	getline(ifile, line);
	while (ifile.good())
	{
	    sbuf += line + "\n";
	    getline(ifile, line);
	}
	
	ifile.close();
	
	CTRACE("Configuration::read_config_file - file read");
	
	read_config_string(sbuf);
	
	is_file=true;
	return true;
}


string	Configuration::dump(void)
{
	return xmltree->dump();
}

ostream &Configuration::dump(ostream &o, const string &indentstr)
{
	xmltree->dump(o, indentstr);
	return o;
}

void Configuration::write_back(void)
{
	if(!is_file)
		return;	// Don't write back if not from a file
	
	std::ofstream ofile;
	try {
	U7open(ofile, filename.c_str(), true);
	} catch (const file_open_exception &)
	{
		std::perror("Failed to write configuration file");
		return;
	}
	if(ofile.fail())
	{
		std::perror("Failed to write configuration file");
		return;
	}
	ofile << dump() << endl;
	ofile.close();
}


std::vector<string>	Configuration::listkeys(const string &key, bool longformat)
{
	std::vector<string>	vs;
	const XMLnode *sub=xmltree->subtree(key);
	if(sub)
		sub->listkeys(key,vs,longformat);
	
	return vs;
}

std::vector<string>	Configuration::listkeys(const char *key, bool longformat)
{
	string s(key);
	return listkeys(s,longformat);
}

void Configuration::clear(const string &new_root)
{
	CTRACE("Configuration::clear");
	
	if(xmltree!=0)
		delete xmltree;
	CTRACE("Configuration::clear - xmltree deleted");
	if(new_root.size())
		rootname=new_root;
	CTRACE("Configuration::clear - new root specified");
	xmltree = new XMLnode(rootname);
	CTRACE("Configuration::clear - fin");
}

void Configuration::getsubkeys(KeyTypeList &ktl, const string &basekey)
{
	xmltree->searchpairs(ktl, basekey, string(), 0);
}