///////////////////////////////////////////////////////////////////////////////////
//
// Microsoft WMIOLE DB Provider
// (C) Copyright 1999 Microsoft Corporation. All Rights Reserved.
//
// CInstanceRowFetchObj object implementation
// 
//
///////////////////////////////////////////////////////////////////////////////////

#include "headers.h"
#include "WmiOleDBMap.h"

///////////////////////////////////////////////////////////////////////////////////////
// Function which fetches required number of rows
///////////////////////////////////////////////////////////////////////////////////////
HRESULT CInstanceRowFetchObj::FetchRows(CRowset *	 pRowset,
								HCHAPTER		hChapter,        // IN  The Chapter handle.
								DBROWOFFSET		lRowOffset,      // IN  Rows to skip before reading
								DBROWCOUNT		cRows,           // IN  Number of rows to fetch
								DBCOUNTITEM*	pcRowsObtained, // OUT Number of rows obtained
								HROW       **	prghRows)       // OUT Array of Hrows obtained)

{
    DBCOUNTITEM	cRowsTmp				= 0;
    HROW		irow(0), ih(0);
    PROWBUFF	prowbuff				= NULL;
    HRESULT		hr						= S_OK;
	HROW		*prghRowsTemp			= NULL;
	HROW		hRowCurrent				= 0;
	HSLOT		hSlot					= -1;
	BOOL		bAlreadyDataRetrieved	= FALSE;
	BOOL		bAlreadyFetched			= FALSE;
	CVARIANT	varKey;
	BOOL		bFetchBack				= FALSE;
	HROW		hRowTemp				= 0;
	CBSTR		strKey;
	LONG_PTR	lFetchPos				= 0;
	DBROWCOUNT	ulMax					= 0;
	BOOL		bMaxRowsExceed			= FALSE;
	DBSTATUS	dwStat					= DBSTATUS_S_OK;
	BOOL		bHRowsAllocated			= FALSE;
	CWbemClassWrapper *pInst = NULL;


	if(cRows != 0)
	{
		{
			VARIANT		varTemp;
			VariantInit(&varTemp);
			pRowset->GetRowsetProperty(DBPROP_MAXOPENROWS,varTemp);

			ulMax	= varTemp.lVal;
			VariantClear(&varTemp);
		}


		//=======================================================
		// If already maximum rows are opened then return
		//=======================================================
		if( pRowset->m_ulRowRefCount >= (DBROWCOUNT)ulMax)
		{
			hr =  DB_S_ROWLIMITEXCEEDED;
		}
		else
		{
			//========================
			// Fetch Data
			//========================
			 if (lRowOffset)
			{
				//===================================
				// Calculate the new position
				//===================================
				hr = pRowset->ResetRowsetToNewPosition(lRowOffset,pInst);
				if( FAILED(hr))
				{
					pRowset->SetStatus(hChapter , STAT_ENDOFCURSOR);
					hr =  DB_S_ENDOFROWSET ;
				}
			}
			// 07/11/00
			 //141938
			if(hr == S_OK)
			{
				if(0 >( lFetchPos = GetFirstFetchPos(pRowset,cRows,lRowOffset)))
				{
					hr = DB_E_BADSTARTPOSITION;
				}
				else
				{
					cRowsTmp	= cRows >= 0 ? cRows : cRows * (-1);
					ulMax	= ulMax - pRowset->m_ulRowRefCount;
					if(ulMax < (DBROWCOUNT)cRowsTmp)
					{
						bMaxRowsExceed = TRUE;
					}
					else
					{
						ulMax = cRowsTmp;
					}
					cRowsTmp = 0;

					//=======================================================================
					// If any rows is to be retrieved then allocate memory for the HROWS
					//=======================================================================
					if (ulMax )
					{
						try
						{
							prghRowsTemp = (HROW *) g_pIMalloc->Alloc( ulMax * sizeof( HROW ));
						}
						catch(...)
						{
							if(prghRowsTemp != NULL)
							{
								g_pIMalloc->Free(prghRowsTemp);
							}
							throw;
						}
					}
					if(prghRowsTemp == NULL)
					{
						hr = E_OUTOFMEMORY;
					}
					else
					{
						memset(prghRowsTemp,0,ulMax * sizeof(HROW));

						pRowset->m_FetchDir = (LONG_PTR)cRows < 0 ? FETCHDIRBACKWARD : FETCHDIRFORWARD;
						bFetchBack			= (LONG_PTR)cRows < 0 ? TRUE : FALSE;

						hRowTemp = pRowset->m_hRowLastFetched;
						for (irow =1; irow <= (ULONG)ulMax; irow++)
						{
							bAlreadyFetched			= FALSE;
							bAlreadyDataRetrieved	= FALSE;
							dwStat					= DBSTATUS_S_OK;

							//============================================================
							// Get the pointer to the next instance
							//============================================================
							if (S_OK != ( hr = pRowset->GetNextInstance(pInst,strKey,bFetchBack)))
							{
								pRowset->SetStatus(hChapter , STAT_ENDOFCURSOR);
								hr = DB_S_ENDOFROWSET;
								break;
							}
						
							//==========================================================================
							// If the instance is a deleted instance and deleted instance is to be
							// removed then continue to the next instance 
							// If the rowset is opened in dyanamic cursor mode then skipping of
							// deleted row doesn't depend on REMOVEDELETED
							//==========================================================================
							if(pRowset->IsInstanceDeleted(pInst) &&
								(pRowset->m_ulProps & OTHERINSERT)  || 
								 ( pRowset->m_ulProps & REMOVEDELETED) )
							{
								irow--;
								continue;
							}

							//=================================================================
							// Check if instance already exist 
							//=================================================================
							bAlreadyFetched  = pRowset->m_InstMgr->IsInstanceExist(strKey);
						
							//==========================================================================
							// If not able to find the instance by key ( key might change sometime
							// in some cases if all the properties are keys) So check if the instance
							// is already fetched by the instance pointers
							//==========================================================================
							if(bAlreadyFetched == FALSE)
							{
								bAlreadyFetched  = pRowset->m_InstMgr->IsInstanceExist(pInst );
								
								//==========================================================================
								// if found the instance has to be refreshed
								//==========================================================================
								if(bAlreadyFetched == TRUE)
								{
									pRowset->RefreshInstance(pInst);
								}
							}


							//==================================================================
							// if already exists get the HROW and slot number for the instance
							//==================================================================
							if(bAlreadyFetched == TRUE)
							{
								hRowCurrent = pRowset->m_InstMgr->GetHRow(strKey);
								
								if((pRowset->GetRowStatus(hRowCurrent) & DBROWSTATUS_E_DELETED) && ( pRowset->m_ulProps & REMOVEDELETED))
								{
									continue;
								}

								//=================================================================
								// if the slot number for the instance exist this means thet
								// data is already retrieved for the row
								//=================================================================
								if((hSlot = pRowset->m_InstMgr->GetSlot(hRowCurrent)) != -1)
								{
									bAlreadyDataRetrieved = TRUE;
								}

							}
							else
							{
								hRowCurrent = pRowset->GetNextHRow();
							}
							//=====================================================
							// Get the data if data is already not fetched
							//=====================================================
							if(bAlreadyDataRetrieved == FALSE)
							{
								

								hSlot		= -1;
								//============================================
								// Get the next slot for retrieving data and 
								// bind it to the column mem manager
								//============================================
								if (FAILED( hr = GetNextSlots( pRowset->m_pIBuffer, 1, &hSlot )))
								{
									break;
								}
								
								if (FAILED( pRowset->Rebind((BYTE *) pRowset->GetRowBuffFromSlot( hSlot, TRUE ))))
								{
									hr = E_FAIL;
									break;
								}

								hRowCurrent = hSlot;

								//=========================================================
								// fill the bookmark with keyvalue of the instance
								//=========================================================
								varKey.SetStr(strKey);
								//=================================================================================================
								// if the other updates visible property is set to false ,then get the data to the local buffer
								//=================================================================================================
								if(!( pRowset->m_ulProps & OTHERUPDATEDELETE))
								{

									if(FAILED(hr = pRowset->GetInstanceDataToLocalBuffer(pInst,hSlot)))
									{
										break;
									}
							
									//===========================================================================
									// if there is atleast one row retrieved and there are neseted columns
									// then allocate rows for the child recordsets
									//===========================================================================
									if(pRowset->m_cNestedCols > 0 )

									{
										if(pRowset->m_ppChildRowsets == NULL)
										{
											pRowset->AllocateAndInitializeChildRowsets();
										}

										//=====================================================================
										// Fill the HCHAPTERS for the column
										//=====================================================================
										if(FAILED(hr = pRowset->FillHChaptersForRow(pInst,strKey)))
										{
											break;
										}
									}

								}


								//=================================================
								// add instance pointer to instance manager
								//=================================================
								if(FAILED(hr = pRowset->m_InstMgr->AddInstanceToList(hRowCurrent,pInst,strKey,hSlot)))
								{
									break;
								}

								//=====================================================
								// if the row is deleted then set the row status
								//=====================================================
								if(pRowset->IsInstanceDeleted(pInst) && SUCCEEDED(hr))
								{
									pRowset->SetRowStatus(hRowCurrent,DBROWSTATUS_E_DELETED);
								}

								varKey.Clear();
							}
							
							prghRowsTemp[irow-1] = hSlot;

							strKey.Clear();
							strKey.Unbind();
						}
						
						if(SUCCEEDED(hr))
						{
							cRowsTmp = irow - 1; //Irow will be +1 because of For Loop


							//=====================================================================
							// Through fetching many rows of data
							//
							// Allocate row handles for client. Note that we need to use IMalloc 
							// for this. Should only malloc cRowsTmp, instead of cRows.
							// Should malloc cRows, since client will assume it's that big.
							//=====================================================================


							if ( *prghRows == NULL && cRowsTmp )
							{
								try
								{
									*prghRows = (HROW *) g_pIMalloc->Alloc( cRowsTmp * sizeof( HROW ));
								}
								catch(...)
								{
									if(*prghRows)
									{
										g_pIMalloc->Free(*prghRows);
									}
									throw;
								}
								bHRowsAllocated = TRUE;
							}

							if ( *prghRows == NULL  && cRowsTmp )
							{
								hr =  E_OUTOFMEMORY ;
								
							}
							else
							{
								memset(*prghRows,0,cRowsTmp * sizeof( HROW ));
								//=====================================================================
								// Fill in the status information: Length, IsNull. May be able to wait 
								// until first call to GetData, but have to do it sometime.
								//
								// Suggest keeping an array of structs of accessor info. One element is
								// whether accessor requires any status info or length info.
								//
								// Then we could skip this whole section.
								//
								// Added check for cRowsTmp to MarkRows call. Don't want to call if 
								// cRowsTmp==0.
								// (Range passed to MarkRows is inclusive, so can't specify marking 0 rows.)
								//
								// Note that SetSlots is a CBitArray member function -- not an IBuffer function.
								//
								// Bits are [0...n-1], row handles are [1...n].
								//
								// Cleanup. Row handles, bits, indices are the same [m....(m+n)], where 
								// m is some # >0,
								//
								// Added row-wise reference counts and cursor-wise reference counts.
								//
								// Set row handles, fix data length field and compute data status field.
								//=======================================================================
								pRowset->m_cRows   = cRowsTmp;
								

								for (ih =0; ih < (ULONG) pRowset->m_cRows; ih++) 
								{


									//=============================================================================
									// Increment the rows-read count,
									// then store it as the bookmark in the very first DWORD of the row.
									//=============================================================================
									prowbuff = pRowset->GetRowBuff( prghRowsTemp[ih], TRUE );

									//=======================================================================================
									// Insert the bookmark and its row number (from 1...n) into a hash table.
									// This allows us to quickly determine the presence of a row in mem, given the bookmark.
									// The bookmark is contained in the row buffer, at the very beginning.
									// Bookmark is the row number within the entire result set [1...num_rows_read].

									// This was a new Bookmark, not in memory,
									// so return to user (in *prghRows) the hRow we stored.
									//=======================================================================================
									prowbuff->ulRefCount++;
									pRowset->m_ulRowRefCount++;
									(*prghRows)[ih] = prghRowsTemp[ih]; // (HROW) ( irow );
									pRowset->m_hRowLastFetched	= prghRowsTemp[ih];

									if(pRowset->m_ulProps & BOOKMARKPROP)
									{
										if(ih != 0)
										{
											lFetchPos = (pRowset->m_FetchDir == FETCHDIRFORWARD ) ?  lFetchPos + 1  : lFetchPos -1;
										}
        
										prowbuff->dwBmk				= lFetchPos;
										prowbuff->cbBmk				= BOOKMARKSIZE;
										pRowset->m_lLastFetchPos	= lFetchPos;

										// Add bookmark to the hashtable
										pRowset->m_pHashTblBkmark->InsertFindBmk(FALSE,prghRowsTemp[ih],prowbuff->cbBmk,(BYTE *)&(prowbuff->dwBmk),(ULONG_PTR*)&hSlot);

										
									}
        
								}
							}		// If proper allocation of *prghRows if required
						}		// If succeeded(hr) after the loop
						
						if(SUCCEEDED(hr))
						{
							*pcRowsObtained = cRowsTmp;
						}

						//=====================================================
						// if the number of rows asked is more than
						// the max number of open rows and if there 
						// is no error then set the error number
						//=====================================================
						if( hr == S_OK && bMaxRowsExceed == TRUE)
						{
							hr = DB_S_ROWLIMITEXCEEDED;
						}
					}	// Else for check for proper allocation prghRowsTemp

				}	// Else for check for DB_E_BADSTARTPOSITION

			}

		}
	
	}		// if cRow > 0


	// IF failed clean up
	if( FAILED(hr))
	{
		for (ih =0; ih < (ULONG) cRowsTmp; ih++) 
		{
			if(prghRowsTemp[ih] != 0)
			{
				pRowset->m_InstMgr->DeleteInstanceFromList(prghRowsTemp[ih]);
			}
		}

		if(pcRowsObtained)
		{
			*pcRowsObtained = 0;
		}

		if(prghRows && bHRowsAllocated == TRUE)
		{
			g_pIMalloc->Free(prghRows);
			prghRows = NULL;
		}
		else
		if(prghRows)
		{
			*prghRows = NULL;
		}
		if(pcRowsObtained)
		{
			*pcRowsObtained = 0;
		}

	}

	//==============================================
	// free the temporary memory allocated
	//==============================================
	if(prghRowsTemp)
	{
		g_pIMalloc->Free(prghRowsTemp);
		prghRowsTemp = NULL;
	}

	// reset the starting position to the original position
	if(lRowOffset && (FAILED(hr) || (hr != S_OK && cRowsTmp == 0)))
	{
		pRowset->ResetRowsetToNewPosition(lRowOffset * (-1),pInst);
	}

	return hr;


}