#ifndef SPINI_H
#define SPINI_H

#pragma once

#include "SpBase.h"
#include "ListEntry.h"

struct IIniMappingEntry
{
	LIST_ENTRY entry;
	IIniMappingEntry(const char *section, const char *key) : m_section(section), m_key(key) {}
	const char *m_section;
	const char *m_key;
	virtual ErrorCodeEnum Load(const CSmartPointer<IConfigInfo> &pConfig) = 0;
	virtual ErrorCodeEnum Save(const CSmartPointer<IConfigInfo> &pConfig) = 0;
};

struct SpIniMappingEntryInt : public IIniMappingEntry
{
	int &m_dest;
	int m_default;
	SpIniMappingEntryInt(const char *section, const char *key, int &dest, int defaultVal)
		: IIniMappingEntry(section, key), m_dest(dest), m_default(defaultVal)
	{
	}
	virtual ErrorCodeEnum Load(const CSmartPointer<IConfigInfo> &pConfig)
	{
		CSimpleStringA strValue;
		ErrorCodeEnum Error = pConfig->ReadConfigValue(m_section, m_key, strValue);
		if (Error == Error_Succeed) {
			m_dest = atoi(strValue);
		} else {
			m_dest = m_default;
		}
		return Error;
	}
	virtual ErrorCodeEnum Save(const CSmartPointer<IConfigInfo> &pConfig)
	{
		CSimpleStringA strValue = CSimpleStringA::Format("%d", m_dest);
		return pConfig->WriteConfigValue(m_section, m_key, strValue);
	}
};

struct SpIniMappingEntryUInt : public IIniMappingEntry
{
	UINT &m_dest;
	UINT m_default;
	SpIniMappingEntryUInt(const char *section, const char *key, UINT &dest, UINT defaultVal)
		: IIniMappingEntry(section, key), m_dest(dest), m_default(defaultVal)
	{
	}
	virtual ErrorCodeEnum Load(const CSmartPointer<IConfigInfo> &pConfig)
	{
		CSimpleStringA strValue;
		ErrorCodeEnum Error = pConfig->ReadConfigValue(m_section, m_key, strValue);
		if (Error == Error_Succeed) {
			m_dest = strtoul(strValue, NULL, 10);
        } else {
            m_dest = m_default;
        }
		return Error;
	}
	virtual ErrorCodeEnum Save(const CSmartPointer<IConfigInfo> &pConfig)
	{
		CSimpleStringA strValue = CSimpleStringA::Format("%u", m_dest);
		return pConfig->WriteConfigValue(m_section, m_key, strValue);
	}
};

struct SpIniMappingEntryDouble : public IIniMappingEntry
{
	double &m_dest;
	double m_default;
	SpIniMappingEntryDouble(const char *section, const char *key, double &dest, double defaultVal)
		: IIniMappingEntry(section, key), m_dest(dest), m_default(defaultVal)
	{
	}
	virtual ErrorCodeEnum Load(const CSmartPointer<IConfigInfo> &pConfig)
	{
		CSimpleStringA strValue;
		ErrorCodeEnum Error = pConfig->ReadConfigValue(m_section, m_key, strValue);
		if (Error == Error_Succeed) {
			m_dest = atof(strValue);
        } else {
            m_dest = m_default;
        }
		return Error;
	}
	virtual ErrorCodeEnum Save(const CSmartPointer<IConfigInfo> &pConfig)
	{
		CSimpleStringA strValue = CSimpleStringA::Format("%f", m_dest);
		return pConfig->WriteConfigValue(m_section, m_key, strValue);
	}
};

struct SpIniMappingEntryFloat : public IIniMappingEntry
{
	float &m_dest;
	float m_default;
	SpIniMappingEntryFloat(const char *section, const char *key, float &dest, float defaultVal)
		: IIniMappingEntry(section, key), m_dest(dest), m_default(defaultVal)
	{
	}
	virtual ErrorCodeEnum Load(const CSmartPointer<IConfigInfo> &pConfig)
	{
		CSimpleStringA strValue;
		ErrorCodeEnum Error = pConfig->ReadConfigValue(m_section, m_key, strValue);
		if (Error == Error_Succeed) {
			m_dest = (float)atof(strValue);
        } else {
            m_dest = m_default;
        }
		return Error;
	}
	virtual ErrorCodeEnum Save(const CSmartPointer<IConfigInfo> &pConfig)
	{
		CSimpleStringA strValue = CSimpleStringA::Format("%f", m_dest);
		return pConfig->WriteConfigValue(m_section, m_key, strValue);
	}
};

struct SpIniMappingEntryString : public IIniMappingEntry
{
	SpIniMappingEntryString(const char *section, const char *key, CSimpleStringA &dest, CSimpleStringA defaultVal)
		: IIniMappingEntry(section, key), m_dest(dest), m_default(defaultVal)
	{
	}
	CSimpleStringA &m_dest;
	CSimpleStringA m_default;
	virtual ErrorCodeEnum Load(const CSmartPointer<IConfigInfo> &pConfig)
	{
		ErrorCodeEnum Error = pConfig->ReadConfigValue(m_section, m_key, m_dest);
		if (Error != Error_Succeed) {
			m_dest = m_default;
		}
		return Error;
	}
	virtual ErrorCodeEnum Save(const CSmartPointer<IConfigInfo> &pConfig)
	{
		return pConfig->WriteConfigValue(m_section, m_key, m_dest);
	}
};

struct SpIniMappingEntryBoolean : public IIniMappingEntry
{
	SpIniMappingEntryBoolean(const char *section, const char *key, bool &dest, bool defaultVal)
		: IIniMappingEntry(section, key), m_dest(dest), m_default(defaultVal)
	{
	}
	bool &m_dest;
	bool m_default;
	virtual ErrorCodeEnum Load(const CSmartPointer<IConfigInfo> &pConfig)
	{
		CSimpleStringA strValue;
		ErrorCodeEnum Error = pConfig->ReadConfigValue(m_section, m_key, strValue);
		if (Error == Error_Succeed) {
			if (_stricmp(strValue, "false") == 0 || _stricmp(strValue, "0") == 0) {
				m_dest = false;
			} else if (_stricmp(strValue, "true") == 0  || _stricmp(strValue, "1") == 0) {
				m_dest = true;
			}
		} else {
			m_dest = m_default;
		}
		return Error;
	}
	virtual ErrorCodeEnum Save(const CSmartPointer<IConfigInfo> &pConfig)
	{
		return pConfig->WriteConfigValue(m_section, m_key, m_dest ? "true" : "false");
	}
};

struct SpIniMappingTable
{
	SpIniMappingTable() 
	{
		ListEntry_InitHead(&m_entrylist);
	}

	~SpIniMappingTable() 
	{
		Clear();
	}

	void Clear()
	{
		IIniMappingEntry *pos, *n;
		ListEntry_ForEachSafe(pos, n, &m_entrylist, IIniMappingEntry, entry) {
			ListEntry_DeleteNode(&pos->entry);
			delete pos;
		}
	}

	ErrorCodeEnum AddEntryInt(const char *section, const char *key, int &dest, int defaultVal)
	{
		SpIniMappingEntryInt *pEntry = new SpIniMappingEntryInt(section, key, dest, defaultVal);
		ListEntry_AddTail(&m_entrylist, &pEntry->entry);
		return Error_Succeed;
	}

	ErrorCodeEnum AddEntryUInt(const char *section, const char *key, UINT &dest, UINT defaultVal)
	{
		SpIniMappingEntryUInt *pEntry = new SpIniMappingEntryUInt(section, key, dest, defaultVal);
		ListEntry_AddTail(&m_entrylist, &pEntry->entry);
		return Error_Succeed;
	}

	ErrorCodeEnum AddEntryDouble(const char *section, const char *key, double &dest, double defaultVal)
	{
		SpIniMappingEntryDouble *pEntry = new SpIniMappingEntryDouble(section, key, dest, defaultVal);
		ListEntry_AddTail(&m_entrylist, &pEntry->entry);
		return Error_Succeed;
	}

	ErrorCodeEnum AddEntryFloat(const char *section, const char *key, float &dest, float defaultVal)
	{
		SpIniMappingEntryFloat *pEntry = new SpIniMappingEntryFloat(section, key, dest, defaultVal);
		ListEntry_AddTail(&m_entrylist, &pEntry->entry);
		return Error_Succeed;
	}

	ErrorCodeEnum AddEntryString(const char *section, const char *key, CSimpleStringA &dest, const char *defaultVal)
	{
		SpIniMappingEntryString *pEntry = new SpIniMappingEntryString(section, key, dest, defaultVal);
		ListEntry_AddTail(&m_entrylist, &pEntry->entry);
		return Error_Succeed;
	}

	ErrorCodeEnum AddEntryBoolean(const char *section, const char *key, bool &dest, bool defaultVal)
	{
		SpIniMappingEntryBoolean *pEntry = new SpIniMappingEntryBoolean(section, key, dest, defaultVal);
		ListEntry_AddTail(&m_entrylist, &pEntry->entry);
		return Error_Succeed;
	}

	ErrorCodeEnum Load(const CSmartPointer<IConfigInfo> &pConfig)
	{
		ErrorCodeEnum Error = Error_Succeed;
		IIniMappingEntry *pos;
		ListEntry_ForEach(pos, &m_entrylist, IIniMappingEntry, entry) {
			Error = pos->Load(pConfig);
			if (Error != Error_Succeed)
				break;
		}
		return Error;
	}

	ErrorCodeEnum Save(const CSmartPointer<IConfigInfo> &pConfig)
	{
		ErrorCodeEnum Error = Error_Succeed;
		IIniMappingEntry *pos;
		ListEntry_ForEach(pos, &m_entrylist, IIniMappingEntry, entry) {
			Error = pos->Save(pConfig);
			if (Error != Error_Succeed)
				break;
		}
		return Error;
	}

private:
	LIST_ENTRY m_entrylist;
};

#endif // SPINI_H