/* -*- 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 <formula/token.hxx>

#include <rtl/ref.hxx>

#include "document.hxx"

#include "scdllapi.h"

#include "types.hxx"

#include "calcmacros.hxx"

#include "address.hxx"

#include "global.hxx"

#include <formula/tokenarray.hxx>

namespace sc {

struct RefUpdateContext;

struct RefUpdateInsertTabContext;

struct RefUpdateDeleteTabContext;

struct RefUpdateMoveTabContext;

struct RefUpdateResult;

struct TokenStringContext;

class ColRowReorderMapType;

/** If the target tab was inserted, or an existing tab was used. */

enum class TargetTabState

{

    Existing,

    Inserted,

};

}

struct ScRawToken;

struct ScSingleRefData;

struct ScComplexRefData;

class SAL_WARN_UNUSED SAL_DLLPUBLIC_RTTI ScTokenArray final : public formula::FormulaTokenArray

{

    friend class ScCompiler;

    bool ImplGetReference( ScRange& rRange, const ScAddress& rPos, bool bValidOnly ) const;

    // hold a reference to the limits because sometimes our lifetime exceeds the lifetime of the associated ScDocument

    rtl::Reference<ScSheetLimits> mxSheetLimits;

    size_t mnHashValue;

    ScFormulaVectorState meVectorState : 4; // Only 4 bits

    bool mbOpenCLEnabled : 1;

    bool mbThreadingEnabled : 1;

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

public:

    SC_DLLPUBLIC ScTokenArray(const ScDocument& rDoc);

    ScTokenArray(ScSheetLimits&);

    /** Assignment with incrementing references of FormulaToken entries

        (not copied!) */

    ScTokenArray( const ScTokenArray& ) = default;

    ScTokenArray( ScTokenArray&& ) = default;

    SC_DLLPUBLIC virtual ~ScTokenArray() override;

    bool EqualTokens( const ScTokenArray* pArr2 ) const;

    SC_DLLPUBLIC virtual void Clear() override;

    SC_DLLPUBLIC std::unique_ptr<ScTokenArray> Clone() const;    /// True copy!

    SC_DLLPUBLIC ScTokenArray CloneValue() const;    /// True copy!

    SC_DLLPUBLIC void GenHash();

    size_t GetHash() const { return mnHashValue;}

    ScFormulaVectorState GetVectorState() const { return meVectorState;}

    void ResetVectorState();

    bool IsFormulaVectorDisabled() const;

    /**

     * If the array contains at least one relative row reference or named

     * expression, it's variant. Otherwise invariant.

     */

    bool IsInvariant() const;

    /// Exactly and only one range (valid or deleted)

    SC_DLLPUBLIC bool IsReference( ScRange& rRange, const ScAddress& rPos ) const;

    /// Exactly and only one valid range (no #REF!s)

    SC_DLLPUBLIC bool IsValidReference( ScRange& rRange, const ScAddress& rPos ) const;

                            /** Determines the extent of direct adjacent

                                references. Only use with real functions, e.g.

                                GetOuterFuncOpCode() == ocSum ! */

    bool                    GetAdjacentExtendOfOuterFuncRefs(

                                SCCOLROW& nExtend,

                                const ScAddress& rPos, ScDirection );

    formula::FormulaToken* AddRawToken( const ScRawToken& );

    SC_DLLPUBLIC virtual bool AddFormulaToken(

        const css::sheet::FormulaToken& rToken,

        svl::SharedStringPool& rSPool,

        formula::ExternalReferenceHelper* _pRef) override;

    SC_DLLPUBLIC virtual void CheckToken( const formula::FormulaToken& r ) override;

    SC_DLLPUBLIC virtual formula::FormulaToken* AddOpCode( OpCode eCode ) override;

    /** ScSingleRefToken with ocPush. */

    SC_DLLPUBLIC formula::FormulaToken* AddSingleReference( const ScSingleRefData& rRef );

    /** ScSingleRefOpToken with ocMatRef. */

    formula::FormulaToken* AddMatrixSingleReference( const ScSingleRefData& rRef );

    SC_DLLPUBLIC formula::FormulaToken* AddDoubleReference( const ScComplexRefData& rRef );

    SC_DLLPUBLIC void      AddRangeName( sal_uInt16 n, sal_Int16 nSheet );

    formula::FormulaToken* AddDBRange( sal_uInt16 n );

    SC_DLLPUBLIC formula::FormulaToken* AddTableRef( sal_uInt16 n );

    SC_DLLPUBLIC formula::FormulaToken* AddExternalName( sal_uInt16 nFileId, const svl::SharedString& rName );

    SC_DLLPUBLIC void AddExternalSingleReference( sal_uInt16 nFileId, const svl::SharedString& rTabName, const ScSingleRefData& rRef );

    SC_DLLPUBLIC formula::FormulaToken* AddExternalDoubleReference( sal_uInt16 nFileId, const svl::SharedString& rTabName, const ScComplexRefData& rRef );

    SC_DLLPUBLIC formula::FormulaToken* AddMatrix( const ScMatrixRef& p );

    /** ScSingleRefOpToken with ocColRowName. */

    SC_DLLPUBLIC formula::FormulaToken* AddColRowName( const ScSingleRefData& rRef );

    SC_DLLPUBLIC virtual formula::FormulaToken* MergeArray( ) override;

    /** Merge very last SingleRef+ocRange+SingleRef combination into DoubleRef

        and adjust pCode array, or do nothing if conditions not met. */

    void MergeRangeReference( const ScAddress & rPos );

    /// Assign XML string placeholder to the array

    void AssignXMLString( const OUString &rText, const OUString &rFormulaNmsp );

    /** Assignment with incrementing references of FormulaToken entries

        (not copied!) */

    ScTokenArray& operator=( const ScTokenArray& );

    ScTokenArray& operator=( ScTokenArray&& );

    /**

     * Make all absolute references external references pointing to the old document

     *

     * @param rOldDoc old document

     * @param rNewDoc new document

     * @param rPos position of the cell to determine if the reference is in the copied area

     * @param bRangeName set for range names, range names have special handling for absolute sheet ref + relative col/row ref

     */

    void ReadjustAbsolute3DReferences( const ScDocument& rOldDoc, ScDocument& rNewDoc, const ScAddress& rPos, bool bRangeName = false );

    /**

     * Make all absolute references pointing to the copied range if the range is copied too

     * @param bCheckCopyArea should reference pointing into the copy area be adjusted independently from being absolute, should be true only for copy&paste between documents

     */

    void AdjustAbsoluteRefs( const ScDocument& rOldDoc, const ScAddress& rOldPos, const ScAddress& rNewPos, bool bCheckCopyArea );

    /** Adjust relative tab references when copying a formula to a new table.

        Non-zero relative tab offsets are recalculated so they still resolve

        to the original target sheet from the new position. Same-sheet

        relative refs (offset 0) are not modified.

        If the target tab was newly inserted, the references pointing to

        tabs at or after the insertion point are additionally shifted by

        one. */

    void AdjustRelativeTabRefs(SCTAB nOldTab, SCTAB nNewTab,

        sc::TargetTabState eMode = sc::TargetTabState::Existing);

    /** When copying a sheet-local named expression, move sheet references that

        point to the originating sheet to point to the new sheet instead.

     */

    void AdjustSheetLocalNameReferences( SCTAB nOldTab, SCTAB nNewTab );

    /** Returns true if the sheet nTab is referenced in code. Relative sheet

        references are evaluated using nPosTab.

     */

    bool ReferencesSheet( SCTAB nTab, SCTAB nPosTab ) const;

    /**

     * Adjust all references in response to shifting of cells during cell

     * insertion and deletion.

     *

     * @param rCxt context that stores details of shifted region.

     * @param rOldPos old cell position prior to shifting.

     */

    sc::RefUpdateResult AdjustReferenceOnShift( const sc::RefUpdateContext& rCxt, const ScAddress& rOldPos );

    sc::RefUpdateResult AdjustReferenceOnMove(

        const sc::RefUpdateContext& rCxt, const ScAddress& rOldPos, const ScAddress& rNewPos );

    /**

     * Move reference positions in response to column reordering.  A range

     * reference gets moved only when the whole range fits in a single column.

     *

     * @param rPos position of this formula cell

     * @param nTab sheet where columns are reordered.

     * @param nRow1 top row of reordered range.

     * @param nRow2 bottom row of reordered range.

     * @param rColMap old-to-new column mapping.

     */

    void MoveReferenceColReorder(

        const ScAddress& rPos, SCTAB nTab, SCROW nRow1, SCROW nRow2,

        const sc::ColRowReorderMapType& rColMap );

    void MoveReferenceRowReorder(

        const ScAddress& rPos, SCTAB nTab, SCCOL nCol1, SCCOL nCol2,

        const sc::ColRowReorderMapType& rRowMap );

    /**

     * Adjust all references in named expression. In named expression, we only

     * update absolute positions, and leave relative positions intact.

     *

     * @param rCxt context that stores details of shifted region

     *

     * @return update result.

     */

    sc::RefUpdateResult AdjustReferenceInName( const sc::RefUpdateContext& rCxt, const ScAddress& rPos );

    sc::RefUpdateResult AdjustReferenceInMovedName( const sc::RefUpdateContext& rCxt, const ScAddress& rPos );

    /**

     * Adjust all references on sheet deletion.

     *

     * @param nDelPos position of sheet being deleted.

     * @param nSheets number of sheets to delete.

     * @param rOldPos position of formula cell prior to the deletion.

     *

     * @return true if at least one reference has changed its sheet reference.

     */

    sc::RefUpdateResult AdjustReferenceOnDeletedTab( const sc::RefUpdateDeleteTabContext& rCxt, const ScAddress& rOldPos );

    sc::RefUpdateResult AdjustReferenceOnInsertedTab( const sc::RefUpdateInsertTabContext& rCxt, const ScAddress& rOldPos );

    sc::RefUpdateResult AdjustReferenceOnMovedTab( const sc::RefUpdateMoveTabContext& rCxt, const ScAddress& rOldPos );

    /**

     * Adjust all internal references on base position change.

     */

    void AdjustReferenceOnMovedOrigin( const ScAddress& rOldPos, const ScAddress& rNewPos );

    /**

     * Adjust all internal references on base position change if they point to

     * a sheet other than the one of rOldPos.

     */

    void AdjustReferenceOnMovedOriginIfOtherSheet( const ScAddress& rOldPos, const ScAddress& rNewPos );

    /**

     * Adjust internal range references on base position change to justify /

     * put in order the relative references.

     */

    void AdjustReferenceOnCopy( const ScAddress& rNewPos );

    /**

     * Clear sheet deleted flag from internal reference tokens if the sheet

     * index falls within specified range.  Note that when a reference is on a

     * sheet that's been deleted, its referenced sheet index retains the

     * original index of the deleted sheet.

     *

     * @param rPos position of formula cell

     * @param nStartTab index of first sheet, inclusive.

     * @param nEndTab index of last sheet, inclusive.

     */

    void ClearTabDeleted( const ScAddress& rPos, SCTAB nStartTab, SCTAB nEndTab );

    void CheckRelativeReferenceBounds(

        const sc::RefUpdateContext& rCxt, const ScAddress& rPos, SCROW nGroupLen, std::vector<SCROW>& rBounds ) const;

    void CheckRelativeReferenceBounds(

        const ScAddress& rPos, SCROW nGroupLen, const ScRange& rRange, std::vector<SCROW>& rBounds ) const;

    void CheckExpandReferenceBounds(

        const sc::RefUpdateContext& rCxt, const ScAddress& rPos, SCROW nGroupLen, std::vector<SCROW>& rBounds ) const;

    /**

     * Create a string representation of formula token array without modifying

     * the internal state of the token array.

     */

    SC_DLLPUBLIC OUString CreateString( sc::TokenStringContext& rCxt, const ScAddress& rPos ) const;

    SC_DLLPUBLIC void WrapReference( const ScAddress& rPos, SCCOL nMaxCol, SCROW nMaxRow );

    sal_Int32 GetWeight() const;

    bool IsEnabledForOpenCL() const { return mbOpenCLEnabled; }

    bool IsEnabledForThreading() const { return mbThreadingEnabled; }

#if DEBUG_FORMULA_COMPILER

    void Dump() const;

#endif

};

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