#ifndef __GUIDEDB_H_
#define __GUIDEDB_H_

#include "resource.h"       // main symbols
#include "stdprop.h"
#include "SharedMemory.h"

// External classes
class CObject;
class CObjectType;
class CObjectTypes;

class CGuideDB;

/////////////////////////////////////////////////////////////////////////////
// CGuideDB
class ATL_NO_VTABLE CGuideDB : 
	public CComObjectRootEx<CComObjectThreadModel>,
	public IConnectionPointContainerImpl<CGuideDB>,
	public CategoriesPropSet,
	public ChannelPropSet,
	public ChannelsPropSet,
	public CopyrightPropSet,
	public TimePropSet,
	public DescriptionPropSet,
	public ProviderPropSet,
	public RatingsPropSet,
	public MPAARatingsPropSet,
	public ScheduleEntryPropSet,
	public ServicePropSet
{
public:
	CGuideDB() : m_cacheObj(128), m_cacheObjs(0)
	{
#if defined(_ATL_FREE_THREADED)
		m_pUnkMarshaler = NULL;
#endif
		m_fSQLServer = FALSE;

		m_pobjtypes = NULL;

		m_pobjtypeGeneric = NULL;
		m_pobjtypeGuideDataProvider = NULL;
		m_pobjtypeService = NULL;
		m_pobjtypeScheduleEntry = NULL;
		m_pobjtypeProgram = NULL;
		m_pobjtypeChannel = NULL;
		m_pobjtypeChannelLineup = NULL;

		m_hwnd = NULL;
		m_rgmsgItemEvent[Added] = NULL;
		m_rgmsgItemEvent[Removed] = NULL;
		m_rgmsgItemEvent[Changed] = NULL;

		m_iTransLevel = 0;
	}

	~CGuideDB()
		{
		if (m_hwnd != NULL)
			DestroyWindow(m_hwnd);
		}

	HRESULT GetDB(CGuideDB **ppdb)
		{
		*ppdb = this;
		return S_OK;
		}
	
	_bstr_t & get_UUID()
		{
		return m_bstrUUID;
		}

DECLARE_GET_CONTROLLING_UNKNOWN()

#if defined(_ATL_FREE_THREADED)
DECLARE_PROTECT_FINAL_CONSTRUCT()
#endif

BEGIN_COM_MAP(CGuideDB)
	COM_INTERFACE_ENTRY(IConnectionPointContainer)
#if defined(_ATL_FREE_THREADED)
	COM_INTERFACE_ENTRY_AGGREGATE(IID_IMarshal, m_pUnkMarshaler.p)
#endif
END_COM_MAP()
BEGIN_CONNECTION_POINT_MAP(CGuideDB)
END_CONNECTION_POINT_MAP()


#if defined(_ATL_FREE_THREADED)
	HRESULT FinalConstruct()
	{
		return CoCreateFreeThreadedMarshaler(
			GetControllingUnknown(), &m_pUnkMarshaler.p);
	}

	void FinalRelease()
	{
		m_pUnkMarshaler.Release();
	}

	CComPtr<IUnknown> m_pUnkMarshaler;
#endif

public:
	HRESULT CreateDB(const TCHAR *szDBName, const TCHAR *szDBFileName, const TCHAR *szConnection);
	HRESULT CreateSQLDB(const TCHAR *szDBName, const TCHAR *szDBFileName, const TCHAR *szConnection);
	HRESULT InitDB(ADOX::_Catalog *pcatalog);
	HRESULT InitSQLDB(SQLDMO::_Database *pdb);
	HRESULT OpenDB(IGuideStore *pgs, const TCHAR *szDBName);

	boolean FSQLServer()
		{
		return m_fSQLServer;
		}

	enum ItemEvent {Added = 0, Removed, Changed};
	UINT m_rgmsgItemEvent[3];
	void Broadcast_ItemEvent(enum ItemEvent ev, long idObj, long idType);
	void Broadcast_ItemAdded(long idObj, long idType)
		{
		Broadcast_ItemEvent(Added, idObj, idType);
		}
	void Broadcast_ItemRemoved(long idObj, long idType)
		{
		Broadcast_ItemEvent(Removed, idObj, idType);
		}
	void Broadcast_ItemChanged(long idObj, long idType)
		{
		Broadcast_ItemEvent(Changed, idObj, idType);
		}
	void Broadcast_ItemChanged(long idObj);
	void Broadcast_ItemsChanged(long idType)
		{
		Broadcast_ItemEvent(Changed, 0, idType);
		}
	void Fire_ItemEvent(enum ItemEvent ev, long idObj, long lExtra);
	static ATOM s_atomWindowClass;

	static LRESULT _WindowProc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
		{
		CGuideDB *pdb = (CGuideDB *) GetWindowLongPtr(hwnd, GWLP_USERDATA);

		if (msg == WM_CREATE)
		    {
		    LPCREATESTRUCT pcreatestruct = (LPCREATESTRUCT) lparam;

		    pdb = (CGuideDB *) pcreatestruct->lpCreateParams;

		    SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR) pdb);
		    }

		if (pdb == NULL)
			return DefWindowProc(hwnd, msg, wparam, lparam);;
		
		return pdb->WindowProc(msg, wparam, lparam);
		}

	LRESULT WindowProc(UINT msg, WPARAM wparam, LPARAM lparam)
		{
		if (msg == m_rgmsgItemEvent[Added])
			Fire_ItemEvent(Added, wparam, lparam);
		else if (msg == m_rgmsgItemEvent[Removed])
			Fire_ItemEvent(Removed, wparam, lparam);
		else if (msg == m_rgmsgItemEvent[Changed])
			Fire_ItemEvent(Changed, wparam, lparam);
		else
			return DefWindowProc(m_hwnd, msg, wparam, lparam);
		
		return 0;
		}
	
	HRESULT CreateEventSinkWindow()
		{
		if (s_atomWindowClass == NULL)
			{
			WNDCLASS wndclass;

			wndclass.style = 0;
			wndclass.lpfnWndProc = _WindowProc;
			wndclass.cbClsExtra = 0; 
			wndclass.cbWndExtra = 0; 
			wndclass.hInstance = _Module.GetModuleInstance(); 
			wndclass.hIcon = NULL; 
			wndclass.hCursor = NULL; 
			wndclass.hbrBackground = NULL; 
			wndclass.lpszMenuName = NULL; 
			wndclass.lpszClassName = _T("GuideStoreEventSink"); 

			s_atomWindowClass = RegisterClass(&wndclass);
			if (s_atomWindowClass == NULL)
				return HRESULT_FROM_WIN32(GetLastError());
			}
		
		if (m_rgmsgItemEvent[Added] == 0)
			{
			TCHAR szMsg[128];
			_bstr_t bstrUUID = get_UUID();

			wsprintf(szMsg, _T("ItemAdded(%s)"), (LPCTSTR) bstrUUID);
			m_rgmsgItemEvent[Added] = RegisterWindowMessage(szMsg);

			wsprintf(szMsg, _T("ItemRemoved(%s)"), (LPCTSTR) bstrUUID);
			m_rgmsgItemEvent[Removed] = RegisterWindowMessage(szMsg);

			wsprintf(szMsg, _T("ItemChanged(%s)"), (LPCTSTR) bstrUUID);
			m_rgmsgItemEvent[Changed] = RegisterWindowMessage(szMsg);
			}
		
		m_hwnd = CreateWindow( (LPCTSTR)(LONG_PTR)MAKELONG(s_atomWindowClass, 0),	// registered class name
								_T(""),				// window name
								WS_POPUP,			// window style
								0, 0, 0, 0,			// window size and position
								NULL,				// handle to parent or owner window
								NULL,				// menu handle or child identifier
								_Module.GetModuleInstance(),
								(LPVOID) this			// window-creation data
								);

		if (m_hwnd == NULL)
			return HRESULT_FROM_WIN32(GetLastError());

		return S_OK;
		}
	
	CComPtr<IGuideDataProvider> m_pdataprovider;

	long GetIDGuideDataProvider();
	HRESULT get_GuideDataProvider(IGuideDataProvider **ppdataprovider);
	HRESULT putref_GuideDataProvider(IGuideDataProvider *pdataprovider);

	HRESULT BeginTrans()
		{
		HRESULT hr;
		long iLevel;
		hr = m_pdb->BeginTrans(&iLevel);
		if (FAILED(hr))
			return hr;
		
		m_iTransLevel++;
		if (m_iTransLevel != iLevel)
			return E_FAIL;

		return S_OK;
		}

	HRESULT CommitTrans()
		{
		HRESULT hr;
		hr =  m_pdb->CommitTrans();
		if (FAILED(hr))
			return hr;
		//UNDONE: Fire a bulk update event.
		m_iTransLevel--;
		if (m_iTransLevel == 0)
			TransactionDone(TRUE);
		return S_OK;
		}

	HRESULT RollbackTrans()
		{
		HRESULT hr;
		hr = m_pdb->RollbackTrans();
		if (FAILED(hr))
			return hr;
		m_iTransLevel--;
		if (m_iTransLevel == 0)
			TransactionDone(FALSE);
		return S_OK;
		}
	
	void TransactionDone(boolean fCommit);

	HRESULT NewQuery(_bstr_t bstrQuery, ADODB::_Recordset **pprs)
		{
        _variant_t varDB((IDispatch *)m_pdb);
		_variant_t varQuery(bstrQuery);
        ADODB::_RecordsetPtr prs;
        HRESULT hr;
		DeclarePerfTimer("CGuideDB::NewQuery");

		PerfTimerReset();
        hr = prs.CreateInstance(__uuidof(ADODB::Recordset));
        if (FAILED(hr))
            return hr;
        hr = prs->Open(varQuery,
             varDB, ADODB::adOpenUnspecified, ADODB::adLockPessimistic, ADODB::adCmdText);
        if (FAILED(hr))
            return hr;

        *pprs = prs;
        if (*pprs != NULL)
            (*pprs)->AddRef();
		
		PerfTimerDump("Succeeded");
        return S_OK;
		}

	HRESULT Execute(BSTR bstrCmd, VARIANT *pvarCount = NULL,
			long lOptions = ADODB::adExecuteNoRecords, ADODB::_Recordset **pprs = NULL)
		{
		HRESULT hr;
        hr = m_pdb->Execute(bstrCmd, pvarCount, lOptions, pprs);
		if (FAILED(hr))
			{
			DumpObjsCache(_T("CGuideDB::Execute() - After Fail\n"), TRUE);
			CloseRels();
			hr = m_pdb->Execute(bstrCmd, pvarCount, lOptions, pprs);
			DumpObjsCache(_T("CGuideDB::Execute() - After Retry\n"), FALSE);
			}
		return hr;
		}
	
	HRESULT get_StringsRS(ADODB::_Recordset **pprs)
		{
		*pprs = m_prsStrings;
		if (*pprs != NULL)
			(*pprs)->AddRef();
		return S_OK;
		}
	
	HRESULT get_PropSetsRS(ADODB::_Recordset **pprs)
		{
		*pprs = m_prsPropSets;
		if (*pprs != NULL)
			(*pprs)->AddRef();
		return S_OK;
		}
	
	HRESULT get_PropTypesRS(ADODB::_Recordset **pprs)
		{
		*pprs = m_prsPropTypes;
		if (*pprs != NULL)
			(*pprs)->AddRef();
		return S_OK;
		}
	
	HRESULT get_PropsRS(ADODB::_Recordset **pprs)
		{
		*pprs = m_prsProps;
		if (*pprs != NULL)
			(*pprs)->AddRef();
		return S_OK;
		}

	HRESULT get_PropsIndexed(ADODB::_Recordset **pprs)
		{
		*pprs = m_prsPropsIndexed;

		if (*pprs != NULL)
			(*pprs)->AddRef();
		return S_OK;
		}
	
	HRESULT get_ObjTypesRS(ADODB::_Recordset **pprs)
		{
		*pprs = m_prsObjTypes;
		if (*pprs != NULL)
			(*pprs)->AddRef();
		return S_OK;
		}
	
	void RequeryObjectsTables()
		{
		m_prsObjs = NULL;
		m_prsObjsByID = NULL;
		m_prsObjsByType = NULL;
		}
	HRESULT get_ObjsRS(ADODB::_Recordset **pprs);
	HRESULT get_ObjsByType(ADODB::_Recordset **pprs);
	HRESULT get_ObjsByID(ADODB::_Recordset **pprs);

	HRESULT get_RelsByID1Rel(ADODB::_Recordset **pprs);
	HRESULT get_RelsByID2Rel(ADODB::_Recordset **pprs);
	void CloseRels()
		{
		if (m_prsRelsByID1Rel != NULL)
			m_prsRelsByID1Rel.Release();
		if (m_prsRelsByID2Rel != NULL)
			m_prsRelsByID2Rel.Release();
		}
	
	HRESULT get_MetaPropertySet(BSTR bstrName, IMetaPropertySet **pppropset)
		{
		return m_ppropsets->get_AddNew(bstrName, pppropset);
		}

	HRESULT get_MetaPropertyType(BSTR bstrName, IMetaPropertyType **ppproptype)
		{
		if (m_ppropsets == NULL)
			return E_INVALIDARG;
		
		return m_ppropsets->get_Lookup(bstrName, ppproptype);
		}
	HRESULT get_MetaPropertyType(long idPropType, IMetaPropertyType **ppproptype);
	HRESULT put_MetaPropertyType(long idPropType, IMetaPropertyType *pproptype);

	HRESULT SaveObject(IUnknown *punk, long *pid);

	void DumpObjsCache(const TCHAR *psz, boolean fPurge);
	HRESULT CacheCollection(IObjects *pobjs)
		{
		return m_cacheObjs.Cache((LONG_PTR)pobjs, pobjs);
		}

	HRESULT CacheObject(long idObj, long idObjType, IUnknown **ppobj);
	HRESULT CacheObject(long idObj, CObjectType *pobjtype, IUnknown **ppobj);
	HRESULT UncacheObject(long idObj);
	HRESULT get_Object(long idObj, IUnknown **ppobj);
	HRESULT get_IdOf(IUnknown *pobj, long *pid);
	HRESULT get_MetaPropertiesOf(long id, IMetaProperties **ppprops);
	STDMETHOD(get_MetaPropertiesOf)(/*[in]*/ IUnknown *punk, /*[out, retval]*/ IMetaProperties **ppprops)
		{
		ENTER_API
			{
			long idObj;
			HRESULT hr;

			hr = get_IdOf(punk, &idObj);
			if (FAILED(hr))
				return hr;
			
			return get_MetaPropertiesOf(idObj, ppprops);
			}
		LEAVE_API
		}

	HRESULT get_ObjectsWithType(long idType, IObjects **ppobjs);
	HRESULT get_ObjectsWithType(CObjectType *pobjtype, IObjects **ppobjs);
	HRESULT get_ObjectsWithType(CLSID clsid, IObjects **ppobjs)
		{
		CObjectType *pobjtype;

		get_ObjectType(clsid, &pobjtype);

		return get_ObjectsWithType(pobjtype, ppobjs);
		}

	HRESULT get_ObjectType(long idObjType, CObjectType **ppobjtype);
	HRESULT put_ObjectType(long idObjType, CObjectType *pobjtype);

	HRESULT get_ObjectTypes(CObjectTypes **ppobjtypes);
	HRESULT get_ObjectType(BSTR bstrCLSID, CObjectType **ppobjtype);
	HRESULT get_ObjectType(CLSID clsid, CObjectType **ppobjtype);

	HRESULT get_GenericObjectType(CObjectType **ppobjtype)
		{
		HRESULT hr;

		if (m_pobjtypeGeneric == NULL)
			{
			hr = get_ObjectType(__uuidof(IUnknown), &m_pobjtypeGeneric);
			if (FAILED(hr))
				return hr;
			}

		if ((*ppobjtype = m_pobjtypeGeneric) == NULL)
			return E_FAIL;

		return S_OK;
		}

	HRESULT get_GuideDataProviderObjectType(CObjectType **ppobjtype)
		{
		HRESULT hr;

		if (m_pobjtypeGuideDataProvider == NULL)
			{
			hr = get_ObjectType(CLSID_GuideDataProvider, &m_pobjtypeGuideDataProvider);
			if (FAILED(hr))
				return hr;
			}

		if ((*ppobjtype = m_pobjtypeGuideDataProvider) == NULL)
			return E_FAIL;

		return S_OK;
		}

	HRESULT get_ServiceObjectType(CObjectType **ppobjtype)
		{
		HRESULT hr;

		if (m_pobjtypeService == NULL)
			{
			hr = get_ObjectType(CLSID_Service, &m_pobjtypeService);
			if (FAILED(hr))
				return hr;
			}

		if ((*ppobjtype = m_pobjtypeService) == NULL)
			return E_FAIL;

		return S_OK;
		}

	HRESULT get_ProgramObjectType(CObjectType **ppobjtype)
		{
		HRESULT hr;

		if (m_pobjtypeProgram == NULL)
			{
			hr = get_ObjectType(CLSID_Program, &m_pobjtypeProgram);
			if (FAILED(hr))
				return hr;
			}

		if ((*ppobjtype = m_pobjtypeProgram) == NULL)
			return E_FAIL;

		return S_OK;
		}

	HRESULT get_ScheduleEntryObjectType(CObjectType **ppobjtype)
		{
		HRESULT hr;

		if (m_pobjtypeScheduleEntry == NULL)
			{
			hr = get_ObjectType(CLSID_ScheduleEntry, &m_pobjtypeScheduleEntry);
			if (FAILED(hr))
				return hr;
			}

		if ((*ppobjtype = m_pobjtypeScheduleEntry) == NULL)
			return E_FAIL;

		return S_OK;
		}

	HRESULT get_ChannelObjectType(CObjectType **ppobjtype)
		{
		HRESULT hr;

		if (m_pobjtypeChannel == NULL)
			{
			hr = get_ObjectType(CLSID_Channel, &m_pobjtypeChannel);
			if (FAILED(hr))
				return hr;
			}

		if ((*ppobjtype = m_pobjtypeChannel) == NULL)
			return E_FAIL;

		return S_OK;
		}

	HRESULT get_ChannelLineupObjectType(CObjectType **ppobjtype)
		{
		HRESULT hr;

		if (m_pobjtypeChannelLineup == NULL)
			{
			hr = get_ObjectType(CLSID_ChannelLineup, &m_pobjtypeChannelLineup);
			if (FAILED(hr))
				return hr;
			}

		if ((*ppobjtype = m_pobjtypeChannelLineup) == NULL)
			return E_FAIL;

		return S_OK;
		}
	
	long ObjectCount()
		{
		return m_cacheObj.Count();
		}
	
	IUnknown * Object(long i)
		{
		return m_cacheObj.Item(i);
		}
	
	long CachedObjectCount()
		{
		return m_cacheObj.CachedCount();
		}
	
	HRESULT PurgeCachedObjects()
		{
		m_cacheObj.Keep(0);
		m_cacheObj.Keep(128);
		return S_OK;
		}
	CComObjectCacheByID  & CacheObjs() { return m_cacheObjs; }


protected:
	CComPtr<IMetaPropertySets> m_ppropsets;
	ADODB::_ConnectionPtr m_pdb;
	boolean m_fSQLServer;
	ADODB::_RecordsetPtr m_prsStrings;
	ADODB::_RecordsetPtr m_prsPropSets;
	ADODB::_RecordsetPtr m_prsPropTypes;
	ADODB::_RecordsetPtr m_prsProps;
	ADODB::_RecordsetPtr m_prsPropsIndexed;
	ADODB::_RecordsetPtr m_prsObjTypes;
	ADODB::_RecordsetPtr m_prsObjs;
	ADODB::_RecordsetPtr m_prsObjsByType;
	ADODB::_RecordsetPtr m_prsObjsByID;
	ADODB::_RecordsetPtr m_prsRelsByID1Rel;
	ADODB::_RecordsetPtr m_prsRelsByID2Rel;

	typedef map<long, IMetaPropertyType *> t_mapPropTypes;
	t_mapPropTypes m_mapPropTypes;

	CComObjectCacheByID m_cacheObj;
	CComObjectCacheByID m_cacheObjs;

	typedef map<long, IMetaProperties *> t_mapIdProps;
	t_mapIdProps m_mapIdProps;

	typedef map<long, IObjects *> t_mapObjsWithType;
	t_mapObjsWithType m_mapObjsWithType;

	typedef map<long, CObjectType *> t_mapObjTypes;
	t_mapObjTypes m_mapObjTypes;

	CObjectTypes *m_pobjtypes;

	CObjectType *m_pobjtypeGeneric;
	CObjectType *m_pobjtypeGuideDataProvider;
	CObjectType *m_pobjtypeService;
	CObjectType *m_pobjtypeScheduleEntry;
	CObjectType *m_pobjtypeProgram;
	CObjectType *m_pobjtypeChannel;
	CObjectType *m_pobjtypeChannelLineup;

	_bstr_t m_bstrUUID;

	HWND m_hwnd;
	long m_iTransLevel;
};

ATOM __declspec(selectany) CGuideDB::s_atomWindowClass = NULL;

#endif //__GUIDEDB_H_