/*
 * This file is part of the CMaNGOS Project. See AUTHORS file for Copyright information
 *
 * 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
 */

#ifndef SQLSTORAGE_H
#define SQLSTORAGE_H

#include "Common.h"
#include "Database/DatabaseEnv.h"
#include "DBCFileLoader.h"

class SQLStorageBase
{
 template<class DerivedLoader, class StorageClass> friend class SQLStorageLoaderBase;

 public:
 char const* GetTableName() const { return m_tableName; }
 char const* EntryFieldName() const { return m_entry_field; }

 FieldFormat GetDstFormat(uint32 idx) const { return (FieldFormat)m_dst_format[idx]; };
 const char* GetDstFormat() const { return m_dst_format; };
 FieldFormat GetSrcFormat(uint32 idx) const { return (FieldFormat)m_src_format[idx]; };
 const char* GetSrcFormat() const { return m_src_format; };

 uint32 GetMaxEntry() const { return m_maxEntry; };
 uint32 GetRecordCount() const { return m_recordCount; };

 template<typename T>
 class SQLSIterator
 {
 friend class SQLStorageBase;

 public:
 T const* getValue() const { return reinterpret_cast<T const*>(pointer); }

 void operator ++() { pointer += recordSize; }
 T const* operator *() const { return getValue(); }
 T const* operator ->() const { return getValue(); }
 bool operator <(const SQLSIterator& r) const { return pointer < r.pointer; }
 inline bool operator == (const SQLSIterator& r) const { return pointer == r.pointer; }
 inline bool operator != (const SQLSIterator& r) const { return !operator ==(r); }
 void operator =(const SQLSIterator& r) { pointer = r.pointer; recordSize = r.recordSize; }

 private:
 SQLSIterator(char* ptr, uint32 _recordSize) : pointer(ptr), recordSize(_recordSize) {}
 char* pointer;
 uint32 recordSize;
 };

 template<typename T>
 SQLSIterator<T> begin() const { return SQLSIterator<T>(m_data, m_recordSize); }
 template<typename T>
 SQLSIterator<T> end() const { return SQLSIterator<T>(m_data + m_recordCount * m_recordSize, m_recordSize); }

 protected:
 SQLStorageBase();
 virtual ~SQLStorageBase() { Free(); }

 void Initialize(const char* tableName, const char* entry_field, const char* src_format, const char* dst_format);

 uint32 GetDstFieldCount() const { return m_dstFieldCount; }
 uint32 GetSrcFieldCount() const { return m_srcFieldCount; }
 uint32 GetRecordSize() const { return m_recordSize; }

 virtual void prepareToLoad(uint32 maxRecordId, uint32 recordCount, uint32 recordSize);
 virtual void JustCreatedRecord(uint32 recordId, char* record) = 0;
 virtual void Free();

 private:
 char* createRecord(uint32 recordId);

 // Information about the table
 const char* m_tableName;
 const char* m_entry_field;
 const char* m_src_format;
 const char* m_dst_format;

 // Information about the records
 uint32 m_dstFieldCount;
 uint32 m_srcFieldCount;
 uint32 m_recordCount;
 uint32 m_maxEntry;
 uint32 m_recordSize;

 // Data Storage
 char* m_data;
};

class SQLStorage : public SQLStorageBase
{
 template<class DerivedLoader, class StorageClass> friend class SQLStorageLoaderBase;

 public:
 SQLStorage(const char* fmt, const char* _entry_field, const char* sqlname);

 SQLStorage(const char* src_fmt, const char* dst_fmt, const char* _entry_field, const char* sqlname);

 ~SQLStorage() { Free(); }

 template<class T>
 T const* LookupEntry(uint32 id) const
 {
 if (id >= GetMaxEntry())
 return nullptr;
 return reinterpret_cast<T const*>(m_Index[id]);
 }

 void Load(bool error_at_empty = true);
 void LoadProgressive(uint8 wow_patch, bool error_at_empty = true);

 void EraseEntry(uint32 id);

 protected:
 void prepareToLoad(uint32 maxRecordId, uint32 recordCount, uint32 recordSize) override;
 void JustCreatedRecord(uint32 recordId, char* record) override
 {
 m_Index[recordId] = record;
 }

 void Free() override;

 private:
 // Lookup access
 char** m_Index;
};

class SQLHashStorage : public SQLStorageBase
{
 template<class DerivedLoader, class StorageClass> friend class SQLStorageLoaderBase;

 public:
 SQLHashStorage(const char* fmt, const char* _entry_field, const char* sqlname);
 SQLHashStorage(const char* src_fmt, const char* dst_fmt, const char* _entry_field, const char* sqlname);

 ~SQLHashStorage() { Free(); }

 template<class T>
 T const* LookupEntry(uint32 id) const
 {
 RecordMap::const_iterator itr = m_indexMap.find(id);
 if (itr != m_indexMap.end())
 return reinterpret_cast<T const*>(itr->second);
 return nullptr;
 }

 void Load();

 void EraseEntry(uint32 id);

 protected:
 void prepareToLoad(uint32 maxRecordId, uint32 recordCount, uint32 recordSize) override;
 void JustCreatedRecord(uint32 recordId, char* record) override
 {
 m_indexMap[recordId] = record;
 }

 void Free() override;

 private:
 typedef UNORDERED_MAP<uint32 /*recordId*/, char* /*record*/> RecordMap;
 RecordMap m_indexMap;
};

class SQLMultiStorage : public SQLStorageBase
{
 template<class DerivedLoader, class StorageClass> friend class SQLStorageLoaderBase;
 template<typename T> friend class SQLMultiSIterator;
 template<typename T> friend class SQLMSIteratorBounds;

 private:
 typedef std::multimap<uint32 /*recordId*/, char* /*record*/> RecordMultiMap;

 public:
 SQLMultiStorage(const char* fmt, const char* _entry_field, const char* sqlname);
 SQLMultiStorage(const char* src_fmt, const char* dst_fmt, const char* _entry_field, const char* sqlname);

 ~SQLMultiStorage() { Free(); }

 // forward declaration
 template<typename T> class SQLMSIteratorBounds;

 template<typename T>
 class SQLMultiSIterator
 {
 friend class SQLMultiStorage;
 friend class SQLMSIteratorBounds<T>;

 public:
 T const* getValue() const { return reinterpret_cast<T const*>(citerator->second); }
 uint32 getKey() const { return citerator->first; }

 void operator ++() { ++citerator; }
 T const* operator *() const { return getValue(); }
 T const* operator ->() const { return getValue(); }
 bool operator !=(const SQLMultiSIterator& r) const { return citerator != r.citerator; }
 bool operator ==(const SQLMultiSIterator& r) const { return citerator == r.citerator; }

 private:
 SQLMultiSIterator(RecordMultiMap::const_iterator _itr) : citerator(_itr) {}
 RecordMultiMap::const_iterator citerator;
 };

 template<typename T>
 class SQLMSIteratorBounds
 {
 friend class SQLMultiStorage;

 public:
 const SQLMultiSIterator<T> first;
 const SQLMultiSIterator<T> second;

 private:
 SQLMSIteratorBounds(std::pair<RecordMultiMap::const_iterator, RecordMultiMap::const_iterator> pair) : first(pair.first), second(pair.second) {}
 };

 template<typename T>
 SQLMSIteratorBounds<T> getBounds(uint32 key) const { return SQLMSIteratorBounds<T>(m_indexMultiMap.equal_range(key)); }

 void Load();

 void EraseEntry(uint32 id);

 protected:
 void prepareToLoad(uint32 maxRecordId, uint32 recordCount, uint32 recordSize) override;
 void JustCreatedRecord(uint32 recordId, char* record) override
 {
 m_indexMultiMap.insert(RecordMultiMap::value_type(recordId, record));
 }

 void Free() override;

 private:
 RecordMultiMap m_indexMultiMap;
};

template <class DerivedLoader, class StorageClass>
class SQLStorageLoaderBase
{
 public:
 void Load(StorageClass& storage, bool error_at_empty = true);
 void LoadProgressive(StorageClass& storage, uint8 wow_patch, bool error_at_empty = true);

 template<class S, class D>
 void convert(uint32 field_pos, S src, D& dst);
 template<class S>
 void convert_to_bool(uint32 field_pos, S src, bool& dst);
 template<class S>
 void convert_to_str(uint32 field_pos, S src, char*& dst);
 template<class D>
 void convert_from_str(uint32 field_pos, char const* src, D& dst);
 void convert_str_to_bool(uint32 field_pos, char const* src, bool& dst);
 void convert_str_to_str(uint32 field_pos, char const* src, char*& dst);
 template<class S, class D>
 void default_fill(uint32 field_pos, S src, D& dst);
 void default_fill_to_str(uint32 field_pos, char const* src, char*& dst);

 // trap, no body
 template<class D>
 void convert_from_str(uint32 field_pos, char* src, D& dst);
 void convert_str_to_str(uint32 field_pos, char* src, char*& dst);

 private:
 template<class V>
 void storeValue(V value, StorageClass& store, char* record, uint32 field_pos, uint32& offset);
 void storeValue(char const* value, StorageClass& store, char* record, uint32 field_pos, uint32& offset);

 // trap, no body
 void storeValue(char* value, StorageClass& store, char* record, uint32 field_pos, uint32& offset);
};

class SQLStorageLoader : public SQLStorageLoaderBase<SQLStorageLoader, SQLStorage>
{
};

class SQLHashStorageLoader : public SQLStorageLoaderBase<SQLHashStorageLoader, SQLHashStorage>
{
};

class SQLMultiStorageLoader : public SQLStorageLoaderBase<SQLMultiStorageLoader, SQLMultiStorage>
{
};

#include "SQLStorageImpl.h"

#endif