/* -*- 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 .

 */

#pragma once

#include <memory>

#include <vector>

#include <formula/opcode.hxx>

#include "refdata.hxx"

#include "scdllapi.h"

#include <formula/token.hxx>

#include "calcmacros.hxx"

#include "types.hxx"

class ScJumpMatrix;

class ScMatrix;

struct ScSheetLimits;

typedef ::std::vector< ScComplexRefData > ScRefList;

#if DEBUG_FORMULA_COMPILER

void DumpToken(formula::FormulaToken const & rToken);

#endif

/** If rTok1 and rTok2 both are SingleRef or DoubleRef tokens, extend/merge

    ranges as needed for ocRange.

    @param rPos

        The formula's position, used to calculate absolute positions from

        relative references.

    @param bReuseDoubleRef

        If true, a DoubleRef token is reused if passed as rTok1 or rTok2,

        else a new DoubleRef token is created and returned.

    @return

        A reused or new'ed ScDoubleRefToken, or a NULL TokenRef if rTok1 or

        rTok2 are not of sv(Single|Double)Ref

*/

formula::FormulaTokenRef extendRangeReference( ScSheetLimits& rLimits, formula::FormulaToken & rTok1, formula::FormulaToken & rTok2, const ScAddress & rPos, bool bReuseDoubleRef );

class SAL_DLLPUBLIC_RTTI ScSingleRefToken final : public formula::FormulaToken

{

private:

    ScSheetLimits&    mrSheetLimits; // don't use rtl::Reference to avoid ref-counting traffic

    ScSingleRefData   aSingleRef;

public:

                                ScSingleRefToken( ScSheetLimits& rLimits, const ScSingleRefData& r, OpCode e = ocPush ) :

                                    FormulaToken( formula::svSingleRef, e ), mrSheetLimits(rLimits), aSingleRef( r ) {}

    const ScSingleRefData&      GetSingleRef() const { return aSingleRef; }

    ScSingleRefData&            GetSingleRef() { return aSingleRef; }

    virtual bool                TextEqual( const formula::FormulaToken& rToken ) const override;

    virtual bool                operator==( const formula::FormulaToken& rToken ) const override;

    virtual FormulaToken*       Clone() const override { return new ScSingleRefToken(*this); }

};

class SAL_DLLPUBLIC_RTTI ScDoubleRefToken final : public formula::FormulaToken

{

private:

    ScSheetLimits&    mrSheetLimits; // don't use rtl::Reference to avoid ref-counting traffic

    ScComplexRefData  aDoubleRef;

public:

                                ScDoubleRefToken( ScSheetLimits& rLimits, const ScComplexRefData& r, OpCode e = ocPush  ) :

                                    FormulaToken( formula::svDoubleRef, e ), mrSheetLimits(rLimits), aDoubleRef( r ) {}

    const ScSingleRefData&      GetSingleRef() const { return aDoubleRef.Ref1; }

    ScSingleRefData&            GetSingleRef() { return aDoubleRef.Ref1; }

    const ScComplexRefData&     GetDoubleRef() const { return aDoubleRef; }

    ScComplexRefData&           GetDoubleRef() { return aDoubleRef; }

    const ScSingleRefData&      GetSingleRef2() const { return aDoubleRef.Ref2; }

    ScSingleRefData&            GetSingleRef2() { return aDoubleRef.Ref2; }

    virtual bool                TextEqual( const formula::FormulaToken& rToken ) const override;

    virtual bool                operator==( const formula::FormulaToken& rToken ) const override;

    virtual FormulaToken*       Clone() const override { return new ScDoubleRefToken(*this); }

};

class SAL_DLLPUBLIC_RTTI ScMatrixToken : public formula::FormulaToken

{

private:

            ScMatrixRef         pMatrix;

public:

    ScMatrixToken( ScMatrixRef p );

    ScMatrixToken( const ScMatrixToken& );

    SC_DLLPUBLIC const ScMatrix* GetMatrix() const;

    ScMatrix*                   GetMatrix();

    virtual bool                operator==( const formula::FormulaToken& rToken ) const override;

    virtual FormulaToken*       Clone() const override { return new ScMatrixToken(*this); }

    virtual bool IsMatrixRangeToken() const { return false; }

};

/**

 * Token storing matrix that represents values in sheet range. It stores

 * both the values in matrix form, and the range address the matrix

 * represents.

 */

class ScMatrixRangeToken final : public ScMatrixToken

{

    ScComplexRefData maRef;

public:

    ScMatrixRangeToken( const sc::RangeMatrix& rMat );

    ScMatrixRangeToken( const ScMatrixRangeToken& );

    const ScComplexRefData& GetDoubleRef() const { return maRef; }

    virtual FormulaToken* Clone() const override;

    virtual bool IsMatrixRangeToken() const override { return true; }

};

class SC_DLLPUBLIC ScExternalToken : public formula::FormulaToken

{

    sal_uInt16                  mnFileId;

protected:

    ScExternalToken( formula::StackVar eTypeP, OpCode e, sal_uInt16 nFileId );

public:

    ScExternalToken() = delete;

    virtual ~ScExternalToken() override;

    ScExternalToken(ScExternalToken const &) = default;

    ScExternalToken(ScExternalToken &&) = default;

    ScExternalToken & operator =(ScExternalToken const &) = delete; // due to FormulaToken

    ScExternalToken & operator =(ScExternalToken &&) = delete; // due to FormulaToken

    sal_uInt16                  GetFileId() const { return mnFileId; }

    virtual bool                operator==( const formula::FormulaToken& rToken ) const override;

};

class SC_DLLPUBLIC ScExternalSingleRefToken final : public ScExternalToken

{

    svl::SharedString           maTabName;

    ScSingleRefData             maSingleRef;

public:

    ScExternalSingleRefToken( sal_uInt16 nFileId, svl::SharedString aTabName, const ScSingleRefData& r );

    ScExternalSingleRefToken() = delete;

    virtual ~ScExternalSingleRefToken() override;

    ScExternalSingleRefToken(ScExternalSingleRefToken const &) = default;

    ScExternalSingleRefToken(ScExternalSingleRefToken &&) = default;

    ScExternalSingleRefToken & operator =(ScExternalSingleRefToken const &) = delete; // due to FormulaToken

    ScExternalSingleRefToken & operator =(ScExternalSingleRefToken &&) = delete; // due to FormulaToken

    const svl::SharedString & GetTableName() const { return maTabName; }

    const ScSingleRefData&      GetSingleRef() const { return maSingleRef; }

    ScSingleRefData&            GetSingleRef() { return maSingleRef; }

    virtual bool                operator==( const formula::FormulaToken& rToken ) const override;

    virtual FormulaToken*       Clone() const override { return new ScExternalSingleRefToken(*this); }

};

class SC_DLLPUBLIC ScExternalDoubleRefToken final : public ScExternalToken

{

    svl::SharedString           maTabName;  // name of the first sheet

    ScComplexRefData            maDoubleRef;

public:

    ScExternalDoubleRefToken() = delete;

    ScExternalDoubleRefToken( sal_uInt16 nFileId, svl::SharedString aTabName, const ScComplexRefData& r );

    virtual ~ScExternalDoubleRefToken() override;

    ScExternalDoubleRefToken(ScExternalDoubleRefToken const &) = default;

    ScExternalDoubleRefToken(ScExternalDoubleRefToken &&) = default;

    ScExternalDoubleRefToken & operator =(ScExternalDoubleRefToken const &) = delete; // due to FormulaToken

    ScExternalDoubleRefToken & operator =(ScExternalDoubleRefToken &&) = delete; // due to FormulaToken

    const svl::SharedString & GetTableName() const { return maTabName; }

    const ScSingleRefData&      GetSingleRef() const { return maDoubleRef.Ref1; }

    ScSingleRefData&            GetSingleRef() { return maDoubleRef.Ref1; }

    const ScSingleRefData&      GetSingleRef2() const { return maDoubleRef.Ref2; }

    const ScComplexRefData&     GetDoubleRef() const { return maDoubleRef; }

    ScComplexRefData&           GetDoubleRef() { return maDoubleRef; }

    virtual bool                operator==( const formula::FormulaToken& rToken ) const override;

    virtual FormulaToken*       Clone() const override { return new ScExternalDoubleRefToken(*this); }

};

class SAL_DLLPUBLIC_RTTI ScExternalNameToken final : public ScExternalToken

{

    svl::SharedString           maName;

public:

    ScExternalNameToken() = delete;

    ScExternalNameToken( sal_uInt16 nFileId, svl::SharedString aName );

    virtual ~ScExternalNameToken() override;

    ScExternalNameToken(ScExternalNameToken const &) = default;

    ScExternalNameToken(ScExternalNameToken &&) = default;

    ScExternalNameToken & operator =(ScExternalNameToken const &) = delete; // due to FormulaToken

    ScExternalNameToken & operator =(ScExternalNameToken &&) = delete; // due to FormulaToken

    const svl::SharedString & GetName() const { return maName; }

    virtual bool                operator==( const formula::FormulaToken& rToken ) const override;

    virtual FormulaToken*       Clone() const override { return new ScExternalNameToken(*this); }

};

/** Special token to remember details of ocTableRef "structured references". */

class ScTableRefToken final : public formula::FormulaToken

{

public:

    enum Item

    {

        TABLE    =   0,

        ALL      =   1,

        HEADERS  =   2,

        DATA     =   4,

        TOTALS   =   8,

        THIS_ROW =  16,

        HEADERS_DATA = HEADERS | DATA,

        DATA_TOTALS = DATA | TOTALS

    };

    ScTableRefToken() = delete;

    ScTableRefToken( sal_uInt16 nIndex, Item eItem );

    ScTableRefToken( const ScTableRefToken& r );

    virtual ~ScTableRefToken() override;

    sal_uInt16                  GetIndex() const;

    void                        SetIndex( sal_uInt16 n );

    virtual bool                operator==( const formula::FormulaToken& rToken ) const override;

    virtual FormulaToken*       Clone() const override { return new ScTableRefToken(*this); }

            Item                GetItem() const;

            void                AddItem( Item );

            void                SetAreaRefRPN( formula::FormulaToken* pToken );

            formula::FormulaToken*  GetAreaRefRPN() const;

private:

    formula::FormulaTokenRef    mxAreaRefRPN;   ///< resulting RPN area

    sal_uInt16                  mnIndex;    ///< index into table / database range collection

    Item                        meItem;

};

// Only created from within the interpreter, no conversion from ScRawToken,

// never added to ScTokenArray!

class ScJumpMatrixToken final : public formula::FormulaToken

{

private:

    std::shared_ptr<ScJumpMatrix> mpJumpMatrix;

public:

                                ScJumpMatrixToken( std::shared_ptr<ScJumpMatrix> p );

                                ScJumpMatrixToken( const ScJumpMatrixToken & );

    virtual                     ~ScJumpMatrixToken() override;

    ScJumpMatrix*               GetJumpMatrix() const;

    virtual bool                operator==( const formula::FormulaToken& rToken ) const override;

    virtual ScJumpMatrixToken*  Clone() const override { return new ScJumpMatrixToken(*this); }

};

// Only created from within the interpreter, no conversion from ScRawToken,

// never added to ScTokenArray!

class ScRefListToken final : public formula::FormulaToken

{

private:

            ScRefList           aRefList;

            bool                mbArrayResult;  // whether RefList is an array result

public:

                                ScRefListToken() :

                                    FormulaToken( formula::svRefList ), mbArrayResult(false) {}

            explicit            ScRefListToken( bool bArrayResult ) :

                                    FormulaToken( formula::svRefList ), mbArrayResult( bArrayResult ) {}

            bool                IsArrayResult() const;

    const ScRefList*            GetRefList() const;

    ScRefList*                  GetRefList();

    virtual bool                operator==( const formula::FormulaToken& rToken ) const override;

    virtual ScRefListToken*     Clone() const override { return new ScRefListToken(*this); }

};

class ScEmptyCellToken final : public formula::FormulaToken

{

            bool                bInherited          :1;

            bool                bDisplayedAsString  :1;

public:

    explicit                    ScEmptyCellToken( bool bInheritedP, bool bDisplayAsString ) :

                                    FormulaToken( formula::svEmptyCell ),

                                    bInherited( bInheritedP ),

                                    bDisplayedAsString( bDisplayAsString ) {}

            bool                IsInherited() const { return bInherited; }

            bool                IsDisplayedAsString() const { return bDisplayedAsString; }

    virtual bool                operator==( const formula::FormulaToken& rToken ) const override;

    virtual FormulaToken*       Clone() const override { return new ScEmptyCellToken(*this); }

};

/**  Transports the result from the interpreter to the formula cell. */

class ScMatrixCellResultToken : public formula::FormulaToken

{

protected:

    ScConstMatrixRef xMatrix;

    formula::FormulaConstTokenRef     xUpperLeft;

public:

    ScMatrixCellResultToken( ScConstMatrixRef pMat, const formula::FormulaToken* pUL );

    ScMatrixCellResultToken( const ScMatrixCellResultToken& );

    virtual ~ScMatrixCellResultToken() override;

    const ScMatrix*             GetMatrix() const;

    virtual bool                operator==( const formula::FormulaToken& rToken ) const override;

    virtual FormulaToken*       Clone() const override;

    formula::StackVar           GetUpperLeftType() const

                                    {

                                        return xUpperLeft ?

                                            xUpperLeft->GetType() :

                                            formula::svUnknown;

                                    }

    const formula::FormulaConstTokenRef& GetUpperLeftToken() const { return xUpperLeft; }

    void Assign( const ScMatrixCellResultToken & r );

};

/** Stores the matrix result at the formula cell, additionally the range the

    matrix formula occupies. */

class ScMatrixFormulaCellToken final : public ScMatrixCellResultToken

{

private:

            SCROW               nRows;

            SCCOL               nCols;

public:

    ScMatrixFormulaCellToken( SCCOL nC, SCROW nR, const ScConstMatrixRef& pMat, const formula::FormulaToken* pUL );

    ScMatrixFormulaCellToken( SCCOL nC, SCROW nR );

    ScMatrixFormulaCellToken( const ScMatrixFormulaCellToken& r );

    virtual ~ScMatrixFormulaCellToken() override;

    virtual bool                operator==( const formula::FormulaToken& rToken ) const override;

    virtual FormulaToken*       Clone() const override { return new ScMatrixFormulaCellToken(*this); }

            void                SetMatColsRows( SCCOL nC, SCROW nR )

                                    {

                                        nRows = nR;

                                        nCols = nC;

                                    }

            void                GetMatColsRows( SCCOL & nC, SCROW & nR ) const

                                    {

                                        nR = nRows;

                                        nC = nCols;

                                    }

            SCCOL               GetMatCols() const  { return nCols; }

            SCROW               GetMatRows() const  { return nRows; }

    /** Assign matrix result, keep matrix formula

        dimension. */

    void Assign( const ScMatrixCellResultToken & r );

                                /** Assign any result, keep matrix formula

                                    dimension. If token is of type

                                    ScMatrixCellResultToken uses the

                                    appropriate Assign() call, other tokens

                                    are assigned to xUpperLeft and xMatrix will

                                    be assigned NULL. */

            void                Assign( const formula::FormulaToken & r );

                                /** Modify xUpperLeft if formula::svDouble, or create

                                    new formula::FormulaDoubleToken if not set yet. Does

                                    nothing if xUpperLeft is of different type! */

            void                SetUpperLeftDouble( double f);

    /** Reset matrix and upper left, keep matrix

        formula dimension. */

    void ResetResult();

private:

    /** xUpperLeft is modifiable through SetUpperLeftDouble(), so clone it

        whenever an svDouble token is assigned to. */

    void CloneUpperLeftIfNecessary();

};

class ScHybridCellToken final : public formula::FormulaToken

{

private:

    double mfDouble;

    svl::SharedString maString;

    OUString maFormula;

    bool mbEmptyDisplayedAsString;

public:

    ScHybridCellToken(

        double f, const svl::SharedString & rStr, OUString aFormula, bool bEmptyDisplayedAsString );

    const OUString& GetFormula() const  { return maFormula; }

    bool IsEmptyDisplayedAsString() const   { return mbEmptyDisplayedAsString; }

    double GetDouble() const;

    const svl::SharedString & GetString() const { return maString; }

    virtual bool operator==( const formula::FormulaToken& rToken ) const override;

    virtual FormulaToken* Clone() const override { return new ScHybridCellToken(*this); }

};

// Simplify argument passing to RefUpdate methods with ScSingleRefToken or

// ScDoubleRefToken

class SingleDoubleRefModifier

{

    ScComplexRefData    aDub;

    ScSingleRefData*  pS;

    ScComplexRefData*   pD;

                SingleDoubleRefModifier( const SingleDoubleRefModifier& ) = delete;

        SingleDoubleRefModifier& operator=( const SingleDoubleRefModifier& ) = delete;

public:

        SingleDoubleRefModifier( formula::FormulaToken& rT )

                    {

                        formula::StackVar eType = rT.GetType();

                        if ( eType == formula::svSingleRef )

                        {

                            pS = &static_cast<ScSingleRefToken&>(rT).GetSingleRef();

                            aDub.Ref1 = aDub.Ref2 = *pS;

                            pD = &aDub;

                        }

                        else if ( eType == formula::svExternalSingleRef )

                        {

                            pS = &static_cast<ScExternalSingleRefToken&>(rT).GetSingleRef();

                            aDub.Ref1 = aDub.Ref2 = *pS;

                            pD = &aDub;

                        }

                        else

                        {

                            pS = nullptr;

                            pD = &static_cast<ScDoubleRefToken&>(rT).GetDoubleRef();

                            // coverity[uninit_member] - aDub intentionally not initialized, unnecessary because unused.

                        }

                    }

                SingleDoubleRefModifier( ScSingleRefData& rS )

                    {

                        pS = &rS;

                        aDub.Ref1 = aDub.Ref2 = *pS;

                        pD = &aDub;

                    }

                ~SingleDoubleRefModifier()

                    {

                        if ( pS )

                            *pS = (*pD).Ref1;

                    }

    ScComplexRefData& Ref() { return *pD; }

};

class SingleDoubleRefProvider

{

public:

    const ScSingleRefData&    Ref1;

    const ScSingleRefData&    Ref2;

                SingleDoubleRefProvider( const formula::FormulaToken& r )

                        : Ref1( r.GetType() == formula::svSingleRef

                                ? static_cast<const ScSingleRefToken&>(r).GetSingleRef()

                                : r.GetType() == formula::svExternalSingleRef

                                ? static_cast<const ScExternalSingleRefToken&>(r).GetSingleRef()

                                : r.GetType() == formula::svDoubleRef

                                ? static_cast<const ScDoubleRefToken&>(r).GetSingleRef()

                                : static_cast<const ScExternalDoubleRefToken&>(r).GetSingleRef()

                                ),

                          Ref2( r.GetType() == formula::svDoubleRef

                                ? static_cast<const ScDoubleRefToken&>(r).GetDoubleRef().Ref2

                                : r.GetType() == formula::svExternalDoubleRef

                                ? static_cast<const ScExternalDoubleRefToken&>(r).GetDoubleRef().Ref2

                                : Ref1 )

                    {}

};

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */