/*       +------------------------------------+
 *       | Inspire Internet Relay Chat Daemon |
 *       +------------------------------------+
 *
 *  Inspire is copyright (C) 2002-2004 ChatSpike-Dev.
 *                       E-mail:
 *                <brain@chatspike.net>
 *           	  <Craig@chatspike.net>
 *     
 * Written by Craig Edwards, Craig McLure, and others.
 * This program is free but copyrighted software; see
 *            the file COPYING for details.
 *
 * ---------------------------------------------------
 */


#include <stdio.h>
#include <string>
#include <mysql/mysql.h>
#include "users.h"
#include "channels.h"
#include "modules.h"

/* $ModDesc: m_filter with regexps */
/* $CompileFlags: -I/usr/local/include -L/usr/local/lib/mysql -L/usr/lib/mysql -lmysqlclient */

/** SQLConnection represents one mysql session.
 * Each session has its own persistent connection to the database.
 */
class SQLConnection
{
 protected:

	MYSQL connection;
	MYSQL_RES *res;
	MYSQL_ROW row;
	std::string host;
	std::string user;
	std::string pass;
	std::string db;
	std::map<std::string,std::string> thisrow;

 public:

	// This constructor creates an SQLConnection object with the given credentials, and creates the underlying
	// MYSQL struct, but does not connect yet.
	SQLConnection(std::string thishost, std::string thisuser, std::string thispass, std::string thisdb)
	{
		this->host = thishost;
		this->user = thisuser;
		this->pass = thispass;
		this->db = thisdb;
		mysql_init(&connection);
	}

	// This method connects to the database using the credentials supplied to the constructor, and returns
	// true upon success.
	bool Connect()
	{
		return mysql_real_connect(&connection, host.c_str(), user.c_str(), pass.c_str(), db.c_str(), 0, NULL, 0);
	}

	// This method issues a query that expects multiple rows of results. Use GetRow() and QueryDone() to retrieve
	// multiple rows.
	bool QueryResult(std::string query)
	{
		char escaped_query[query.length()+1];
		mysql_real_escape_string(&connection, escaped_query, query.c_str(), query.length());
		int r = mysql_query(&connection, escaped_query);
		if (!r)
		{
			res = mysql_use_result(&connection);
		}
		return (!r);
	}

	// This method issues a query that just expects a number of 'effected' rows (e.g. UPDATE or DELETE FROM).
	// the number of effected rows is returned in the return value.
	unsigned long QueryCount(std::string query)
	{
		char escaped_query[query.length()+1];
		mysql_real_escape_string(&connection, escaped_query, query.c_str(), query.length());
	        int r = mysql_query(&connection, escaped_query);
	        if (!r)
	        {
	                res = mysql_store_result(&connection);
	                unsigned long rows = mysql_affected_rows(&connection);
	                mysql_free_result(res);
	                return rows;
	        }
	        return 0;
	}

	// This method fetches a row, if available from the database. You must issue a query
	// using QueryResult() first! The row's values are returned as a map of std::string
	// where each item is keyed by the column name.
	std::map<std::string,std::string> GetRow()
	{
		thisrow.clear();
		if (res)
		{
			row = mysql_fetch_row(res);
			if (row)
			{
				unsigned int field_count = 0;
				if(mysql_field_count(&connection) == 0)
					return thisrow;
				MYSQL_FIELD *fields = mysql_fetch_fields(res);
				while (field_count < mysql_field_count(&connection))
				{
					thisrow[std::string(fields[field_count].name)] = std::string(row[field_count]);
					field_count++;
				}
				return thisrow;
			}
		}
		return thisrow;
	}

	bool QueryDone()
	{
		if (res)
		{
			mysql_free_result(res);
			return true;
		}
		else return false;
	}

	std::string GetError()
	{
		return mysql_error(&connection);
	}

	~SQLConnection()
	{
		mysql_close(&connection);
	}
};


class ModuleSQL : public Module
{
	Server *Srv;
	ConfigReader *Conf;
 
 public:
	ModuleSQL()
	{
	}
	
	virtual ~ModuleSQL()
	{
	}
	
	virtual int OnUserPreMessage(userrec* user,void* dest,int target_type, std::string &text)
	{
	}
	
	virtual int OnUserPreNotice(userrec* user,void* dest,int target_type, std::string &text)
	{
	}
	
	virtual void OnRehash()
	{
	}
	
	virtual Version GetVersion()
	{
		return Version(1,0,0,0,VF_VENDOR|VF_SERVICEPROVIDER);
	}
	
};

// stuff down here is the module-factory stuff. For basic modules you can ignore this.

class ModuleSQLFactory : public ModuleFactory
{
 public:
	ModuleSQLFactory()
	{
	}
	
	~ModuleSQLFactory()
	{
	}
	
	virtual Module * CreateModule()
	{
		return new ModuleSQL;
	}
	
};


extern "C" void * init_module( void )
{
	return new ModuleSQLFactory;
}