/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   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 .
 */
 
#include <consoli.hxx>
#include <document.hxx>
#include <olinetab.hxx>
#include <subtotal.hxx>
#include <formula/errorcodes.hxx>
#include <formulacell.hxx>
#include <tokenarray.hxx>
#include <osl/diagnose.h>
#include <refdata.hxx>
 
#include <string.h>
#include <memory>
 
#define SC_CONS_NOTFOUND    -1
 
const OpCode eOpCodeTable[] = {      //  order as for enum ScSubTotalFunc
        ocBad,                              //  none
        ocAverage,
        ocCount,
        ocCount2,
        ocMax,
        ocMin,
        ocProduct,
        ocStDev,
        ocStDevP,
        ocSum,
        ocVar,
        ocVarP };
 
template< typename T >
static void lcl_AddString( ::std::vector<OUString>& rData, T& nCount, const OUString& rInsert )
{
    rData.push_back( rInsert);
    ++nCount;
}
 
ScConsData::ScConsData() :
    eFunction(SUBTOTAL_FUNC_SUM),
    bReference(false),
    bColByName(false),
    bRowByName(false),
    nColCount(0),
    nRowCount(0),
    nDataCount(0),
    bCornerUsed(false)
{
}
 
ScConsData::~ScConsData()
{
}
 
void ScConsData::DeleteData()
{
    ppRefs.reset();
    ppFunctionData.reset();
    ppUsed.reset();
    ppTitlePos.reset();
    ::std::vector<OUString>().swap( maColHeaders);
    ::std::vector<OUString>().swap( maRowHeaders);
    ::std::vector<OUString>().swap( maTitles);
    nDataCount = 0;
 
    if (bColByName) nColCount = 0;                  // otherwise maColHeaders is wrong
    if (bRowByName) nRowCount = 0;
 
    bCornerUsed = false;
    aCornerText.clear();
}
 
void ScConsData::InitData()
{
    if (bReference && nColCount && !ppRefs)
    {
        ppRefs.reset(new std::unique_ptr<ScReferenceList[]>[nColCount]);
        for (SCSIZE i=0; i<nColCount; i++)
            ppRefs[i].reset(new ScReferenceList[nRowCount]);
    }
    else if (nColCount && !ppFunctionData)
    {
        ppFunctionData.reset( new std::unique_ptr<ScFunctionData[]>[nColCount] );
        for (SCSIZE i=0; i<nColCount; i++)
        {
            ppFunctionData[i].reset( new ScFunctionData[nRowCount] );
        }
    }
 
    if (nColCount && !ppUsed)
    {
        ppUsed.reset( new std::unique_ptr<bool[]>[nColCount] );
        for (SCSIZE i=0; i<nColCount; i++)
        {
            ppUsed[i].reset( new bool[nRowCount] );
            memset( ppUsed[i].get(), 0, nRowCount * sizeof(bool) );
        }
    }
 
    if (nRowCount && nDataCount && !ppTitlePos)
    {
        ppTitlePos.reset( new std::unique_ptr<SCSIZE[]>[nRowCount] );
        for (SCSIZE i=0; i<nRowCount; i++)
        {
            ppTitlePos[i].reset( new SCSIZE[nDataCount] );
            memset( ppTitlePos[i].get(), 0, nDataCount * sizeof(SCSIZE) );    //TODO: not necessary ?
        }
    }
 
    //  CornerText: single String
}
 
void ScConsData::DoneFields()
{
    InitData();
}
 
void ScConsData::SetSize( SCCOL nCols, SCROW nRows )
{
    DeleteData();
    nColCount = static_cast<SCSIZE>(nCols);
    nRowCount = static_cast<SCSIZE>(nRows);
}
 
void ScConsData::GetSize( SCCOL& rCols, SCROW& rRows ) const
{
    rCols = static_cast<SCCOL>(nColCount);
    rRows = static_cast<SCROW>(nRowCount);
}
 
void ScConsData::SetFlags( ScSubTotalFunc eFunc, bool bColName, bool bRowName, bool bRef )
{
    DeleteData();
    bReference = bRef;
    bColByName = bColName;
    if (bColName) nColCount = 0;
    bRowByName = bRowName;
    if (bRowName) nRowCount = 0;
    eFunction = eFunc;
}
 
void ScConsData::AddFields( const ScDocument* pSrcDoc, SCTAB nTab,
                            SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
{
    ++nDataCount;
 
    OUString aTitle;
 
    SCCOL nStartCol = nCol1;
    SCROW nStartRow = nRow1;
    if (bColByName) ++nStartRow;
    if (bRowByName) ++nStartCol;
 
    if (bColByName)
    {
        for (SCCOL nCol=nStartCol; nCol<=nCol2; nCol++)
        {
            aTitle = pSrcDoc->GetString(nCol, nRow1, nTab);
            if (!aTitle.isEmpty())
            {
                bool bFound = false;
                for (SCSIZE i=0; i<nColCount && !bFound; i++)
                    if ( maColHeaders[i] == aTitle )
                        bFound = true;
                if (!bFound)
                    lcl_AddString( maColHeaders, nColCount, aTitle );
            }
        }
    }
 
    if (!bRowByName)
        return;
 
    for (SCROW nRow=nStartRow; nRow<=nRow2; nRow++)
    {
        aTitle = pSrcDoc->GetString(nCol1, nRow, nTab);
        if (!aTitle.isEmpty())
        {
            bool bFound = false;
            for (SCSIZE i=0; i<nRowCount && !bFound; i++)
                if ( maRowHeaders[i] == aTitle )
                    bFound = true;
            if (!bFound)
                lcl_AddString( maRowHeaders, nRowCount, aTitle );
        }
    }
}
 
void ScConsData::AddName( const OUString& rName )
{
    SCSIZE nArrX;
    SCSIZE nArrY;
 
    if (!bReference)
        return;
 
    maTitles.push_back( rName);
    size_t nTitleCount = maTitles.size();
 
    for (nArrY=0; nArrY<nRowCount; nArrY++)
    {
        //  set all data to same length
 
        SCSIZE nMax = 0;
        for (nArrX=0; nArrX<nColCount; nArrX++)
            nMax = std::max( nMax, ppRefs[nArrX][nArrY].size() );
 
        for (nArrX=0; nArrX<nColCount; nArrX++)
        {
            ppUsed[nArrX][nArrY] = true;
            ppRefs[nArrX][nArrY].resize( nMax, { SC_CONS_NOTFOUND, SC_CONS_NOTFOUND, SC_CONS_NOTFOUND });
        }
 
        //  store positions
 
        if (ppTitlePos)
            if (nTitleCount < nDataCount)
                ppTitlePos[nArrY][nTitleCount] = nMax;
    }
}
 
void ScConsData::AddData( ScDocument* pSrcDoc, SCTAB nTab,
                            SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
{
    PutInOrder(nCol1,nCol2);
    PutInOrder(nRow1,nRow2);
    if ( nCol2 >= sal::static_int_cast<SCCOL>(nCol1 + nColCount) && !bColByName )
    {
        OSL_FAIL("range too big");
        nCol2 = sal::static_int_cast<SCCOL>( nCol1 + nColCount - 1 );
    }
    if ( nRow2 >= sal::static_int_cast<SCROW>(nRow1 + nRowCount) && !bRowByName )
    {
        OSL_FAIL("range too big");
        nRow2 = sal::static_int_cast<SCROW>( nRow1 + nRowCount - 1 );
    }
 
    SCCOL nCol;
    SCROW nRow;
 
    // left top corner
 
    if ( bColByName && bRowByName )
    {
        OUString aThisCorner = pSrcDoc->GetString(nCol1, nRow1, nTab);
        if (bCornerUsed)
        {
            if (aCornerText != aThisCorner)
                aCornerText.clear();
        }
        else
        {
            aCornerText = aThisCorner;
            bCornerUsed = true;
        }
    }
 
    // search title
 
    SCCOL nStartCol = nCol1;
    SCROW nStartRow = nRow1;
    if (bColByName) ++nStartRow;
    if (bRowByName) ++nStartCol;
    OUString aTitle;
    std::unique_ptr<SCCOL[]> pDestCols;
    std::unique_ptr<SCROW[]> pDestRows;
    if (bColByName)
    {
        pDestCols.reset(new SCCOL[nCol2-nStartCol+1]);
        for (nCol=nStartCol; nCol<=nCol2; nCol++)
        {
            aTitle = pSrcDoc->GetString(nCol, nRow1, nTab);
            SCCOL nPos = SC_CONS_NOTFOUND;
            if (!aTitle.isEmpty())
            {
                bool bFound = false;
                for (SCSIZE i=0; i<nColCount && !bFound; i++)
                    if ( maColHeaders[i] == aTitle )
                    {
                        nPos = static_cast<SCCOL>(i);
                        bFound = true;
                    }
                OSL_ENSURE(bFound, "column not found");
            }
            pDestCols[nCol-nStartCol] = nPos;
        }
    }
    if (bRowByName)
    {
        pDestRows.reset(new SCROW[nRow2-nStartRow+1]);
        for (nRow=nStartRow; nRow<=nRow2; nRow++)
        {
            aTitle = pSrcDoc->GetString(nCol1, nRow, nTab);
            SCROW nPos = SC_CONS_NOTFOUND;
            if (!aTitle.isEmpty())
            {
                bool bFound = false;
                for (SCSIZE i=0; i<nRowCount && !bFound; i++)
                    if ( maRowHeaders[i] == aTitle )
                    {
                        nPos = static_cast<SCROW>(i);
                        bFound = true;
                    }
                OSL_ENSURE(bFound, "row not found");
            }
            pDestRows[nRow-nStartRow] = nPos;
        }
    }
    nCol1 = nStartCol;
    nRow1 = nStartRow;
 
    // data
 
    bool bAnyCell = ( eFunction == SUBTOTAL_FUNC_CNT2 );
    for (nCol=nCol1; nCol<=nCol2; nCol++)
    {
        SCCOL nArrX = nCol-nCol1;
        if (bColByName) nArrX = pDestCols[nArrX];
        if (nArrX != SC_CONS_NOTFOUND)
        {
            for (nRow=nRow1; nRow<=nRow2; nRow++)
            {
                SCROW nArrY = nRow-nRow1;
                if (bRowByName) nArrY = pDestRows[nArrY];
                if ( nArrY != SC_CONS_NOTFOUND && (
                        bAnyCell ? pSrcDoc->HasData( nCol, nRow, nTab )
                                 : pSrcDoc->HasValueData( nCol, nRow, nTab ) ) )
                {
                    if (bReference)
                    {
                        ppUsed[nArrX][nArrY] = true;
                        ppRefs[nArrX][nArrY].push_back( { nCol, nRow, nTab } );
                    }
                    else
                    {
                        double nVal = pSrcDoc->GetValue( nCol, nRow, nTab );
                        if (!ppUsed[nArrX][nArrY])
                        {
                            ppUsed[nArrX][nArrY] = true;
                            ppFunctionData[nArrX][nArrY] = ScFunctionData( eFunction);
                        }
                        ppFunctionData[nArrX][nArrY].update( nVal);
                    }
                }
            }
        }
    }
}
 
// check before, how many rows to insert (for Undo)
 
SCROW ScConsData::GetInsertCount() const
{
    SCROW nInsert = 0;
    SCSIZE nArrX;
    SCSIZE nArrY;
    if ( ppRefs && ppUsed )
    {
        for (nArrY=0; nArrY<nRowCount; nArrY++)
        {
            SCSIZE nNeeded = 0;
            for (nArrX=0; nArrX<nColCount; nArrX++)
                nNeeded = std::max( nNeeded, ppRefs[nArrX][nArrY].size() );
 
            nInsert += nNeeded;
        }
    }
    return nInsert;
}
 
// store completed data to document
//TODO: optimize on columns?
 
void ScConsData::OutputToDocument( ScDocument& rDestDoc, SCCOL nCol, SCROW nRow, SCTAB nTab )
{
    OpCode eOpCode = eOpCodeTable[eFunction];
 
    SCSIZE nArrX;
    SCSIZE nArrY;
 
    // left top corner
 
    if ( bColByName && bRowByName && !aCornerText.isEmpty() )
        rDestDoc.SetString( nCol, nRow, nTab, aCornerText );
 
    // title
 
    SCCOL nStartCol = nCol;
    SCROW nStartRow = nRow;
    if (bColByName) ++nStartRow;
    if (bRowByName) ++nStartCol;
 
    if (bColByName)
        for (SCSIZE i=0; i<nColCount; i++)
            rDestDoc.SetString( sal::static_int_cast<SCCOL>(nStartCol+i), nRow, nTab, maColHeaders[i] );
    if (bRowByName)
        for (SCSIZE j=0; j<nRowCount; j++)
            rDestDoc.SetString( nCol, sal::static_int_cast<SCROW>(nStartRow+j), nTab, maRowHeaders[j] );
 
    nCol = nStartCol;
    nRow = nStartRow;
 
    // data
 
    if ( ppFunctionData && ppUsed )    // insert values directly
    {
        for (nArrX=0; nArrX<nColCount; nArrX++)
            for (nArrY=0; nArrY<nRowCount; nArrY++)
                if (ppUsed[nArrX][nArrY])
                {
                    double fVal = ppFunctionData[nArrX][nArrY].getResult();
                    if (ppFunctionData[nArrX][nArrY].getError())
                        rDestDoc.SetError( sal::static_int_cast<SCCOL>(nCol+nArrX),
                                           sal::static_int_cast<SCROW>(nRow+nArrY), nTab, FormulaError::NoValue );
                    else
                        rDestDoc.SetValue( sal::static_int_cast<SCCOL>(nCol+nArrX),
                                           sal::static_int_cast<SCROW>(nRow+nArrY), nTab, fVal );
                }
    }
 
    if ( !(ppRefs && ppUsed) )     // insert Reference
                                return;
 
                            //TODO: differentiate, if split into categories
    OUString aString;
 
    ScSingleRefData aSRef;  // data for Reference formula cells
    aSRef.InitFlags();      // this reference is absolute at all times
    aSRef.SetFlag3D(true);
 
    ScComplexRefData aCRef; // data for Sum cells
    aCRef.InitFlags();
    aCRef.Ref1.SetColRel(true); aCRef.Ref1.SetRowRel(true); aCRef.Ref1.SetTabRel(true);
    aCRef.Ref2.SetColRel(true); aCRef.Ref2.SetRowRel(true); aCRef.Ref2.SetTabRel(true);
 
    for (nArrY=0; nArrY<nRowCount; nArrY++)
    {
        SCSIZE nNeeded = 0;
        for (nArrX=0; nArrX<nColCount; nArrX++)
            nNeeded = std::max( nNeeded, ppRefs[nArrX][nArrY].size() );
 
        if (nNeeded)
        {
            rDestDoc.InsertRow( 0,nTab, rDestDoc.MaxCol(),nTab, nRow+nArrY, nNeeded );
 
            for (nArrX=0; nArrX<nColCount; nArrX++)
                if (ppUsed[nArrX][nArrY])
                {
                    SCSIZE nCount = ppRefs[nArrX][nArrY].size();
                    if (nCount)
                    {
                        for (SCSIZE nPos=0; nPos<nCount; nPos++)
                        {
                            ScReferenceEntry aRef = ppRefs[nArrX][nArrY][nPos];
                            if (aRef.nTab != SC_CONS_NOTFOUND)
                            {
                                // insert reference (absolute, 3d)
 
                                aSRef.SetAddress(rDestDoc.GetSheetLimits(), ScAddress(aRef.nCol,aRef.nRow,aRef.nTab), ScAddress());
 
                                ScTokenArray aRefArr(rDestDoc);
                                aRefArr.AddSingleReference(aSRef);
                                aRefArr.AddOpCode(ocStop);
                                ScAddress aDest( sal::static_int_cast<SCCOL>(nCol+nArrX),
                                                 sal::static_int_cast<SCROW>(nRow+nArrY+nPos), nTab );
                                ScFormulaCell* pCell = new ScFormulaCell(rDestDoc, aDest, aRefArr);
                                rDestDoc.SetFormulaCell(aDest, pCell);
                            }
                        }
 
                        // insert sum (relative, not 3d)
 
                        ScAddress aDest( sal::static_int_cast<SCCOL>(nCol+nArrX),
                                         sal::static_int_cast<SCROW>(nRow+nArrY+nNeeded), nTab );
 
                        ScRange aRange(sal::static_int_cast<SCCOL>(nCol+nArrX), nRow+nArrY, nTab);
                        aRange.aEnd.SetRow(nRow+nArrY+nNeeded-1);
                        aCRef.SetRange(rDestDoc.GetSheetLimits(), aRange, aDest);
 
                        ScTokenArray aArr(rDestDoc);
                        aArr.AddOpCode(eOpCode);            // selected function
                        aArr.AddOpCode(ocOpen);
                        aArr.AddDoubleReference(aCRef);
                        aArr.AddOpCode(ocClose);
                        aArr.AddOpCode(ocStop);
                        ScFormulaCell* pCell = new ScFormulaCell(rDestDoc, aDest, aArr);
                        rDestDoc.SetFormulaCell(aDest, pCell);
                    }
                }
 
            // insert outline
 
            ScOutlineArray& rOutArr = rDestDoc.GetOutlineTable( nTab, true )->GetRowArray();
            SCROW nOutStart = nRow+nArrY;
            SCROW nOutEnd = nRow+nArrY+nNeeded-1;
            bool bSize = false;
            rOutArr.Insert( nOutStart, nOutEnd, bSize );
            for (SCROW nOutRow=nOutStart; nOutRow<=nOutEnd; nOutRow++)
                rDestDoc.ShowRow( nOutRow, nTab, false );
            rDestDoc.SetDrawPageSize(nTab);
            rDestDoc.UpdateOutlineRow( nOutStart, nOutEnd, nTab, false );
 
            // sub title
 
            if (ppTitlePos && !maTitles.empty() && !maRowHeaders.empty())
            {
                for (SCSIZE nPos=0; nPos<nDataCount; nPos++)
                {
                    SCSIZE nTPos = ppTitlePos[nArrY][nPos];
                    bool bDo = true;
                    if (nPos+1<nDataCount)
                        if (ppTitlePos[nArrY][nPos+1] == nTPos)
                            bDo = false;                                    // empty
                    if ( bDo && nTPos < nNeeded )
                    {
                        aString = maRowHeaders[nArrY] + " / " + maTitles[nPos];
                        rDestDoc.SetString( nCol-1, nRow+nArrY+nTPos, nTab, aString );
                    }
                }
            }
 
            nRow += nNeeded;
        }
    }
}
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */