// mysqlwrap.h :
//

#if !defined(AGD_MYSQLWRAP_H__0FDF8710_B26A_4631_A025_705731DF316E__INCLUDED_)
#define AGD_MYSQLWRAP_H__0FDF8710_B26A_4631_A025_705731DF316E__INCLUDED_

#include <stdint.h>
#include <mysql/mysql.h>
#include <string>
#include <unordered_map>
#include <functional>
#include "debug.h"

/////////////////////////////////////////////////////////////////////////////
// mysqlwrap.h - Declarations:

class CMySqlVar
{
public:
	CMySqlVar(void);
	CMySqlVar(CMySqlVar &&o);
	CMySqlVar(const MYSQL_FIELD &rField, const char *pszVal);
	virtual ~CMySqlVar(void);

	void Clear(void);

	bool FromField(const MYSQL_FIELD &rField, const char *pszVal);

	inline bool IsValid(void) const {
		return m_bValid;}

	inline bool IsNumeric(void) const {
		return m_bValid && (m_bInteger || m_bReal);}

	inline bool IsReal(void) const {
		return m_bValid && m_bReal;}

	inline bool IsUnsigned(void) const {
		return m_bValid && m_bUnsigned;}

	inline bool IsNull(void) const {
		return m_sqlFt == MYSQL_TYPE_NULL;}
		
	inline enum enum_field_types GetSqlFieldType(void) const {
		return m_sqlFt;}

	inline const char* StrVal(void) const {
		ASSERT(!IsNull());
		return m_strVal.c_str();}

	inline size_t CopyStrVal(char *s, size_t len, size_t pos = 0) const {
		return m_strVal.copy(s, len, pos);}

	inline const char* Fieldname(void) const {
		return m_strFieldname.c_str();}

	inline int FieldnameCmp(const char *pszName) const {
		return m_strFieldname.compare(pszName);}

	operator int64_t (void) const {
		ASSERT(m_bInteger && !IsNull());
		return m_bInteger ? m_numVal.iVal : 0;}

	operator uint64_t (void) const {
		ASSERT(m_bInteger && !IsNull());
		return m_bInteger ? m_numVal.uVal : 0;}

#ifndef _TARGET_BUILD
	operator long long (void) const {
		ASSERT(m_bInteger && !IsNull());
		return m_bInteger ? (long long)m_numVal.iVal : 0;}

	operator unsigned long long (void) const {
		ASSERT(m_bInteger && !IsNull());
		return m_bInteger ? (unsigned long long)m_numVal.uVal : 0;}
#endif  //  _TARGET_BUILD

	operator bool (void) const {
		ASSERT(m_bInteger && !IsNull());
		return m_bInteger ? !!m_numVal.uVal : false;}

	operator double (void) const {
		ASSERT(m_bReal && !IsNull());
		return m_bReal ? m_numVal.fVal : 0.0;}

private:
	bool m_bValid;
	bool m_bInteger;
	bool m_bReal;
	bool m_bUnsigned;
	bool m_bString;
	std::string m_strVal;
	std::string m_strFieldname;
	enum enum_field_types m_sqlFt;
	union
	{
		int64_t		iVal;
		uint64_t	uVal;
		double		fVal;
	}m_numVal;
};

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

class CMySqlRow
{
public:
	typedef std::unordered_map<std::string, CMySqlVar> CMySqlFieldMap;

public:
	CMySqlRow(void);
	~CMySqlRow(void);

public:
	void Clear(void);
	bool Create(unsigned int nFieldCount, const MYSQL_FIELD *pFields, MYSQL_ROW row);
	const CMySqlVar& Value(const char *pszFieldname) const;

	inline const CMySqlVar& operator [](const char *pszFieldname) const {
		return Value(pszFieldname);}

	inline bool IsValid(void) const {
		return m_bValid;}
		
	CMySqlFieldMap::const_iterator begin(void);
	CMySqlFieldMap::const_iterator end(void);

private:
	bool FindField(const char *pszFieldname, CMySqlFieldMap::const_iterator &it) const;

private:
	bool m_bValid;
	unsigned int m_nFieldCount;
	CMySqlFieldMap m_fields;
	static const CMySqlVar m_vNul;
};

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

class CMySqlResult
{
public:
	CMySqlResult(MYSQL_RES *pRes, bool err);
	virtual ~CMySqlResult(void);

public:
	void Free(void);

	my_ulonglong RowCount(void) const;
	unsigned int FieldCount(void) const;
	MYSQL_ROW FetchRow(void);
	bool FetchRow(CMySqlRow &row) const;
	const MYSQL_FIELD * FetchFields(void) const;

	inline bool error(void) const {
		return m_bError;}

private:
	MYSQL_RES *m_pRes;
	bool m_bError;
};

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

class CMySqlDB
{
public:
	CMySqlDB(void);
	virtual ~CMySqlDB(void);

public:
	bool Init(void) throw();
	void Close(void) throw();

	bool Connect(const char *host, const char *user, const char *pass, const char *db, unsigned int port = 0, const char *unix_socket = NULL, unsigned long client_flag = 0);
	CMySqlResult Query(const char *sql);
	int SelectDB(const char *db);
	int SetCharSet(const char *pszCharset);
	int Options(enum mysql_option option, const void *arg);

	std::string EscapeStringQuote(const char *from, char quote);
	std::string EscapeString(const char *from);
	std::string LastError(void);
	unsigned int LastErrno(void);

private:
	MYSQL m_mySql;
	bool m_fIsInit;
};

/////////////////////////////////////////////////////////////////////////////
#endif	//	!defined(AGD_MYSQLWRAP_H__0FDF8710_B26A_4631_A025_705731DF316E__INCLUDED_)