/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/


// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sc.hxx"

#include "dpcachetable.hxx"
#include "document.hxx"
#include "address.hxx"
#include "cell.hxx"
#include "dptabdat.hxx"
#include "dptabsrc.hxx"
#include "dpobject.hxx"
#include "queryparam.hxx"

#include <com/sun/star/i18n/LocaleDataItem.hpp>
#include <com/sun/star/sdbc/DataType.hpp>
#include <com/sun/star/sdbc/XRow.hpp>
#include <com/sun/star/sdbc/XRowSet.hpp>
#include <com/sun/star/sdbc/XResultSetMetaData.hpp>
#include <com/sun/star/sdbc/XResultSetMetaDataSupplier.hpp>
#include <com/sun/star/util/Date.hpp>
#include <com/sun/star/sheet/DataPilotFieldFilter.hpp>
#include <com/sun/star/sheet/DataPilotFieldGroupBy.hpp>

#include <memory>

using namespace ::com::sun::star;

using ::rtl::OUString;
using ::std::vector;
using ::std::pair;
using ::std::hash_map;
using ::std::hash_set;
using ::std::auto_ptr;
using ::com::sun::star::i18n::LocaleDataItem;
using ::com::sun::star::uno::Exception;
using ::com::sun::star::uno::Reference;
using ::com::sun::star::uno::Sequence;
using ::com::sun::star::uno::Any;
using ::com::sun::star::uno::UNO_QUERY;
using ::com::sun::star::uno::UNO_QUERY_THROW;
using ::com::sun::star::sheet::DataPilotFieldFilter;


static sal_Bool lcl_HasQueryEntry( const ScQueryParam& rParam )
{
    return rParam.GetEntryCount() > 0 &&
            rParam.GetEntry(0).bDoQuery;
}

// ----------------------------------------------------------------------------

ScDPCacheTable::FilterItem::FilterItem() :
    mfValue(0.0),
    mbHasValue(false)
{
}
bool  ScDPCacheTable::FilterItem::match( const  ScDPItemData& rCellData ) const
{
	if (rCellData.GetString()!= maString &&
		(!rCellData.IsValue()|| rCellData.GetValue()!=  mfValue))
	        return false;
	return true;
}
// ----------------------------------------------------------------------------

ScDPCacheTable::SingleFilter::SingleFilter(String aString, double fValue, bool bHasValue) 
{
    maItem.maString = aString;
    maItem.mfValue      = fValue;
    maItem.mbHasValue   = bHasValue;
}

bool ScDPCacheTable::SingleFilter::match( const  ScDPItemData& rCellData ) const
{
      return maItem.match(rCellData);
}

const String ScDPCacheTable::SingleFilter::getMatchString()
{
    return maItem.maString;
}

double ScDPCacheTable::SingleFilter::getMatchValue() const
{
    return maItem.mfValue;
}

bool ScDPCacheTable::SingleFilter::hasValue() const
{
    return maItem.mbHasValue;
}

// ----------------------------------------------------------------------------

ScDPCacheTable::GroupFilter::GroupFilter() 
{
}

bool ScDPCacheTable::GroupFilter::match( const  ScDPItemData& rCellData ) const
{
	vector<FilterItem>::const_iterator itrEnd = maItems.end();
	    for (vector<FilterItem>::const_iterator itr = maItems.begin(); itr != itrEnd; ++itr)
	    {
	        bool bMatch = itr->match( rCellData);
	        if (bMatch)
	            return  true;
	    }
	    return false;
}

void ScDPCacheTable::GroupFilter::addMatchItem(const String& rStr, double fVal, bool bHasValue)
{
    FilterItem aItem;
    aItem.maString = rStr;
    aItem.mfValue = fVal;
    aItem.mbHasValue = bHasValue;
    maItems.push_back(aItem);
}

size_t ScDPCacheTable::GroupFilter::getMatchItemCount() const
{
    return maItems.size();
}

// ----------------------------------------------------------------------------

ScDPCacheTable::Criterion::Criterion() :
    mnFieldIndex(-1),
    mpFilter(static_cast<FilterBase*>(NULL))
{
}

// ----------------------------------------------------------------------------

ScDPCacheTable::ScDPCacheTable( ScDocument* pDoc,long nId ) : 
	mpCache( NULL ), 
	mpNoneCache( NULL )
{
 	if ( nId >= 0 )
		mpCache = pDoc->GetDPObjectCache( nId );
	else
	{ //create a temp cache object
		InitNoneCache( NULL );
	}
}

ScDPCacheTable::~ScDPCacheTable()
{
}

sal_Int32 ScDPCacheTable::getRowSize() const
{
	return GetCache()->GetRowCount();
}

sal_Int32 ScDPCacheTable::getColSize() const
{
	return GetCache()->GetColumnCount();
}

void ScDPCacheTable::fillTable(  const ScQueryParam& rQuery, sal_Bool* pSpecial,
                               bool bIgnoreEmptyRows, bool bRepeatIfEmpty )
{
	if ( mpCache == NULL )
		InitNoneCache( NULL );
//check cache
   const SCROW	nRowCount = getRowSize();
   const SCCOL  nColCount = (SCCOL) getColSize();
   if ( nRowCount <= 0 || nColCount <= 0)
        return;

    maRowsVisible.clear();
    maRowsVisible.reserve(nRowCount);


    // Initialize field entries container.
    maFieldEntries.clear();
    maFieldEntries.reserve(nColCount);
    
    // Data rows
    for (SCCOL nCol = 0; nCol < nColCount; ++nCol)
    {
		SCROW nMemCount = GetCache()->GetDimMemberCount( nCol );
		if ( nMemCount )
		{
			std::vector< SCROW > pAdded( nMemCount, -1 );

			for (SCROW nRow = 0; nRow < nRowCount; ++nRow )
			{
				SCROW nIndex = GetCache()->GetItemDataId( nCol, nRow, bRepeatIfEmpty );
				SCROW nOrder = GetCache()->GetOrder( nCol, nIndex );
                
                if ( nCol == 0 )
                         maRowsVisible.push_back(false);

				if ( lcl_HasQueryEntry(rQuery) &&  
					!GetCache()->ValidQuery( nRow , rQuery, pSpecial ) )
					continue;
				if ( bIgnoreEmptyRows &&  GetCache()->IsRowEmpty( nRow ) )
					continue;
				// Insert a new row into cache table.
				if ( nCol == 0 )
					 maRowsVisible.back() = true;

				pAdded[nOrder] = nIndex;
			}
			maFieldEntries.push_back( vector<SCROW>() );
			for ( SCROW nRow = 0; nRow < nMemCount; nRow++ )
			{
				if ( pAdded[nRow] != -1 )
					maFieldEntries.back().push_back( pAdded[nRow] );
			}
        }
    }
}

void ScDPCacheTable::fillTable()
{
	if ( mpCache == NULL )
		InitNoneCache( NULL );
//check cache
   const SCROW	nRowCount = getRowSize();
   const SCCOL  nColCount = (SCCOL) getColSize();
   if ( nRowCount <= 0 || nColCount <= 0)
        return;

    maRowsVisible.clear();
    maRowsVisible.reserve(nRowCount);


    // Initialize field entries container.
    maFieldEntries.clear();
    maFieldEntries.reserve(nColCount);
    
    // Data rows
    for (SCCOL nCol = 0; nCol < nColCount; ++nCol)
    {
		SCROW nMemCount = GetCache()->GetDimMemberCount( nCol );
		if ( nMemCount )
		{
			std::vector< SCROW > pAdded( nMemCount, -1 );

			for (SCROW nRow = 0; nRow < nRowCount; ++nRow )
			{
				SCROW nIndex = GetCache()->GetItemDataId( nCol, nRow, false );
				SCROW nOrder = GetCache()->GetOrder( nCol, nIndex );
                
				if ( nCol == 0 )
				     maRowsVisible.push_back(true);


				pAdded[nOrder] = nIndex;
			}
			maFieldEntries.push_back( vector<SCROW>() );
			for ( SCROW nRow = 0; nRow < nMemCount; nRow++ )
			{
				if ( pAdded[nRow] != -1 )
					maFieldEntries.back().push_back( pAdded[nRow] );
			}
        }
    }
        return;
}

bool ScDPCacheTable::isRowActive(sal_Int32 nRow) const
{
    if (nRow < 0 || static_cast<size_t>(nRow) >= maRowsVisible.size())
        // row index out of bound
        return false;

    return maRowsVisible[nRow];
}

void ScDPCacheTable::filterByPageDimension(const vector<Criterion>& rCriteria, const hash_set<sal_Int32>& rRepeatIfEmptyDims)
{
    sal_Int32 nRowSize = getRowSize();
    if (nRowSize != static_cast<sal_Int32>(maRowsVisible.size()))
    {
        // sizes of the two tables differ!
        return;
    }

    // #i117661# If maRowsVisible is already false from source filtering, don't set to true again.
    // filterByPageDimension is called only once after initializing with fillTable
    // (this is enforced in ScDPSource::FilterCacheTableByPageDimensions).

    for (sal_Int32 nRow = 0; nRow < nRowSize; ++nRow)
        maRowsVisible[nRow] = maRowsVisible[nRow] && isRowQualified(nRow, rCriteria, rRepeatIfEmptyDims);
}

const ScDPItemData* ScDPCacheTable::getCell(SCCOL nCol, SCROW nRow, bool bRepeatIfEmpty) const
{ 
   SCROW nId= GetCache()->GetItemDataId(nCol, nRow, bRepeatIfEmpty);
   return GetCache()->GetItemDataById( nCol, nId );
}

void  ScDPCacheTable::getValue( ScDPValueData& rVal, SCCOL nCol, SCROW nRow, bool bRepeatIfEmpty) const
{
	const ScDPItemData* pData = getCell( nCol, nRow, bRepeatIfEmpty );
	   
	if (pData)
	{
		rVal.fValue = pData->IsValue() ? pData->GetValue() : 0.0;
		rVal.nType = pData->GetType();
	}
	else
		rVal.Set(0.0, SC_VALTYPE_EMPTY);
}
String ScDPCacheTable::getFieldName(SCCOL  nIndex) const
{
	return (GetCache()->GetDimensionName( nIndex ));
}

sal_Int32 ScDPCacheTable::getFieldIndex(const String& rStr) const
{
	return GetCache()->GetDimensionIndex( rStr );
}

const ::std::vector<SCROW>&  ScDPCacheTable::getFieldEntries( sal_Int32 nColumn ) const
{
	 if (nColumn < 0 || static_cast<size_t>(nColumn) >= maFieldEntries.size())
    {
        // index out of bound.  Hopefully this code will never be reached.
        static const ::std::vector<SCROW> emptyEntries;
        return emptyEntries;
    }
	 return maFieldEntries[nColumn];
}

void ScDPCacheTable::filterTable(const vector<Criterion>& rCriteria, Sequence< Sequence<Any> >& rTabData, 
                                 const hash_set<sal_Int32>& rRepeatIfEmptyDims)
{
    sal_Int32 nRowSize = getRowSize();
    sal_Int32 nColSize = getColSize();

    if (!nRowSize)
        // no data to filter.
        return;

    // Row first, then column.
    vector< Sequence<Any> > tableData;
    tableData.reserve(nRowSize+1);

    // Header first.
    Sequence<Any> headerRow(nColSize);
    for (SCCOL  nCol = 0; nCol < nColSize; ++nCol)
    {
        OUString str;
		str = getFieldName( nCol);
        Any any;
        any <<= str;
        headerRow[nCol] = any;
    }
    tableData.push_back(headerRow);


    for (sal_Int32 nRow = 0; nRow < nRowSize; ++nRow)
    {
        if (!maRowsVisible[nRow])
            // This row is filtered out.
            continue;

        if (!isRowQualified(nRow, rCriteria, rRepeatIfEmptyDims))
            continue;

        // Insert this row into table.

        Sequence<Any> row(nColSize);
        for (SCCOL nCol = 0; nCol < nColSize; ++nCol)
        {
            Any any;
            bool bRepeatIfEmpty = rRepeatIfEmptyDims.count(nCol) > 0;
            // Wang Xu Ming - DataPilot migration
			const ScDPItemData* pData= getCell(nCol, nRow, bRepeatIfEmpty);
			if ( pData->IsValue() )
                any <<= pData->GetValue();
            else
            {
            	  OUString string (pData->GetString() );
                  any <<= string;
            }
            row[nCol] = any;
        }
        tableData.push_back(row);
    }

    // convert vector to Seqeunce
    sal_Int32 nTabSize = static_cast<sal_Int32>(tableData.size());
    rTabData.realloc(nTabSize);
    for (sal_Int32 i = 0; i < nTabSize; ++i)
        rTabData[i] = tableData[i];
}

void ScDPCacheTable::clear()
{
	maFieldEntries.clear();
	maRowsVisible.clear();
}

void ScDPCacheTable::swap(ScDPCacheTable& rOther)
{
    maFieldEntries.swap(rOther.maFieldEntries);
    maRowsVisible.swap(rOther.maRowsVisible);
}

bool ScDPCacheTable::empty() const
{
	return ( mpCache == NULL&& mpNoneCache == NULL ) || maFieldEntries.size()==0;
}

bool ScDPCacheTable::isRowQualified(sal_Int32 nRow, const vector<Criterion>& rCriteria,
                                    const hash_set<sal_Int32>& rRepeatIfEmptyDims) const
{
    sal_Int32 nColSize = getColSize();
    vector<Criterion>::const_iterator itrEnd = rCriteria.end();
    for (vector<Criterion>::const_iterator itr = rCriteria.begin(); itr != itrEnd; ++itr)
    {
        if (itr->mnFieldIndex >= nColSize)
            // specified field is outside the source data columns.  Don't
            // use this criterion.
            continue;

        // Check if the 'repeat if empty' flag is set for this field.
        bool bRepeatIfEmpty = rRepeatIfEmptyDims.count(itr->mnFieldIndex) > 0;
		const ScDPItemData* pCellData = getCell(static_cast<SCCOL>(itr->mnFieldIndex), nRow, bRepeatIfEmpty);
        if (!itr->mpFilter->match(*pCellData))
            return false;
    }
    return true;
}


void ScDPCacheTable::InitNoneCache( ScDocument* pDoc )
{
	mpCache = NULL;
	if ( mpNoneCache )
		delete mpNoneCache;
	mpNoneCache = new ScDPTableDataCache( pDoc );
}

ScDPTableDataCache* ScDPCacheTable::GetCache() const
{
	if ( mpCache )
		return mpCache;
	return mpNoneCache;
}
// End Comments