/* -*- 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 "scdllapi.h"

#include "refreshtimer.hxx"

#include "address.hxx"

#include "global.hxx"

#include "rangelst.hxx"

#include <svl/listener.hxx>

#include <svl/poolitem.hxx>

#include <memory>

#include <set>

#include <vector>

class ScDocument;

struct ScSortParam;

struct ScQueryParam;

struct ScSubTotalParam;

class ScTokenArray;

class SC_DLLPUBLIC ScDatabaseSettingItem final : public SfxPoolItem

{

    bool mbHeaderRow;

    bool mbTotalRow;

    bool mbFirstCol;

    bool mbLastCol;

    bool mbStripedRows;

    bool mbStripedCols;

    bool mbShowFilters;

    OUString maStyleID;

public:

    static SfxPoolItem* CreateDefault();

    DECLARE_ITEM_TYPE_FUNCTION(ScDatabaseSettingItem)

    ScDatabaseSettingItem();

    ScDatabaseSettingItem(bool bHeaderRow, bool bTotalRow, bool bFirstCol, bool bLastCol,

                          bool bStripedRows, bool bStripedCols, bool bShowFilter,

                          const OUString& aStyleID);

    ScDatabaseSettingItem( const ScDatabaseSettingItem& rItem );

    virtual ~ScDatabaseSettingItem() override;

    virtual bool            QueryValue( css::uno::Any& rVal, sal_uInt8 nMemberId = 0 ) const override;

    virtual bool            PutValue( const css::uno::Any& rVal, sal_uInt8 nMemberId ) override;

    ScDatabaseSettingItem& operator=( const ScDatabaseSettingItem& rItem );

    virtual bool operator==( const SfxPoolItem& ) const override;

    virtual ScDatabaseSettingItem* Clone( SfxItemPool *pPool = nullptr ) const override;

    bool HasHeaderRow() const;

    bool HasTotalRow() const;

    bool HasFirstCol() const;

    bool HasLastCol() const;

    bool HasStripedRows() const;

    bool HasStripedCols() const;

    bool HasShowFilters() const;

    const OUString& GetStyleID() const;

};

/** Enum used to indicate which portion of the DBArea is to be considered. */

enum class ScDBDataPortion

{

    TOP_LEFT,   ///< top left cell of area

    AREA        ///< entire area

};

// TODO: this can be merged with struct TableColumnModel

struct TableColumnAttributes

{

    std::optional<OUString> maTotalsRowLabel = std::nullopt;

    std::optional<OUString> maTotalsFunction = std::nullopt;

    std::optional<OUString> maCustomFunction = std::nullopt;

};

// xmlColumnPr attributes

struct XmlColumnPrModel

{

    sal_uInt32          mnMapId;

    OUString            msXpath;

    OUString            msXmlDataType;

    bool                mbDenormalized;

    explicit            XmlColumnPrModel();

};

struct TableColumnModel

{

    typedef std::unique_ptr<XmlColumnPrModel> XmlColumnPrModelPtr;

    XmlColumnPrModelPtr mxXmlColumnPr; // Special settings for XML Column Properties.

    XmlColumnPrModel&   createXmlColumnPr();

    OUString            maUniqueName; // unique name of the <tableColumn>

    explicit            TableColumnModel();

};

/** Container base class to provide selected access for ScDBData. */

class ScDBDataContainerBase

{

public:

    ScDBDataContainerBase( ScDocument& rDoc ) : mrDoc(rDoc) {}

    virtual ~ScDBDataContainerBase() {}

    ScDocument& GetDocument() const;

    ScRangeList& GetDirtyTableColumnNames();

protected:

    ScDocument& mrDoc;

    ScRangeList maDirtyTableColumnNames;

};

struct SAL_DLLPUBLIC_RTTI ScTableStyleParam

{

    OUString maStyleID;

    bool mbRowStripes;

    bool mbColumnStripes;

    bool mbFirstColumn;

    bool mbLastColumn;

    SC_DLLPUBLIC ScTableStyleParam();

    bool operator== (const ScTableStyleParam& rData) const;

};

class SAL_DLLPUBLIC_RTTI ScDBData final : public SvtListener, public ScRefreshTimer

{

private:

    std::unique_ptr<ScSortParam> mpSortParam;

    std::unique_ptr<ScQueryParam> mpQueryParam;

    std::unique_ptr<ScSubTotalParam> mpSubTotal;

    std::unique_ptr<ScImportParam> mpImportParam;

    std::unique_ptr<ScTableStyleParam> mpTableStyles;

    ScDBDataContainerBase* mpContainer;

    /// DBParam

    const OUString aName;

    OUString aUpper;

    OUString        aTableType;

    SCTAB           nTable;

    SCCOL           nStartCol;

    SCROW           nStartRow;

    SCCOL           nEndCol;

    SCROW           nEndRow;

    bool            bByRow;

    bool            bHasHeader;

    bool            bHasTotals;

    bool            bDoSize;

    bool            bKeepFmt;

    bool            bStripData;

    /// QueryParam

    bool            bIsAdvanced;        ///< true if created by advanced filter

    ScRange         aAdvSource;         ///< source range

    bool            bDBSelection;       ///< not in Param: if selection, block update

    sal_uInt16      nIndex;             ///< unique index formulas

    bool            bAutoFilter;        ///< AutoFilter? (not saved)

    bool            bModified;          ///< is set/cleared for/by(?) UpdateReference

    ::std::vector< OUString > maTableColumnNames;   ///< names of table columns

    ::std::vector< TableColumnModel > maTableColumnModel;

    bool            mbTableColumnNamesDirty;

    SCSIZE          nFilteredRowCount;

    using ScRefreshTimer::operator==;

public:

    struct less

    {

        bool operator() (const std::unique_ptr<ScDBData>& left, const std::unique_ptr<ScDBData>& right) const;

    };

    SC_DLLPUBLIC ScDBData(const OUString& rName,

             SCTAB nTab,

             SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2, bool bByR = true, bool bHasH = true, bool bTotals = false,

                          const OUString& rTableType = u""_ustr,

                          const OUString& rTableStyleID = u""_ustr);

    ScDBData(const ScDBData& rData);

    ScDBData(const OUString& rName, const ScDBData& rData);

    SC_DLLPUBLIC virtual ~ScDBData() override;

    virtual void Notify( const SfxHint& rHint ) override;

    ScDBData&   operator= (const ScDBData& rData) ;

    bool        operator== (const ScDBData& rData) const;

    const OUString& GetName() const { return aName; }

    const OUString& GetUpperName() const { return aUpper; }

    SCTAB       GetTab() const                  { return nTable; }

    void        GetArea(SCTAB& rTab, SCCOL& rCol1, SCROW& rRow1, SCCOL& rCol2, SCROW& rRow2) const;

    SC_DLLPUBLIC void GetArea(ScRange& rRange) const;

    void        SetArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2);

    void SetArea(ScRange const& rRange)

    {

        SetArea(rRange.aStart.Tab(), rRange.aStart.Col(), rRange.aStart.Row(),

                rRange.aEnd.Col(), rRange.aEnd.Row());

    }

    void        MoveTo(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2,

                       SCCOL nUpdateCol = -1);

    void        SetByRow(bool bByR)             { bByRow = bByR; }

    bool        HasHeader() const               { return bHasHeader; }

    void        SetHeader(bool bHasH)           { bHasHeader = bHasH; }

    bool        HasTotals() const               { return bHasTotals; }

    void        SetTotals(bool bTotals)         { bHasTotals = bTotals; }

    void        SetIndex(sal_uInt16 nInd)           { nIndex = nInd; }

    sal_uInt16  GetIndex() const                { return nIndex; }

    bool        IsDoSize() const                { return bDoSize; }

    void        SetDoSize(bool bSet)            { bDoSize = bSet; }

    bool        IsKeepFmt() const               { return bKeepFmt; }

    void        SetKeepFmt(bool bSet)           { bKeepFmt = bSet; }

    bool        IsStripData() const             { return bStripData; }

    void        SetStripData(bool bSet)         { bStripData = bSet; }

    void        SetTableType(const OUString& sTableType) { aTableType = sTableType; }

    const OUString& GetTableType() const           { return aTableType; }

    void        SetContainer( ScDBDataContainerBase* pContainer ) { mpContainer = pContainer; }

    /** Returns header row range if has headers, else invalid range. */

    ScRange     GetHeaderArea() const;

    void        StartTableColumnNamesListener();

    void        EndTableColumnNamesListener();

    SC_DLLPUBLIC void SetTableColumnNames( ::std::vector< OUString >&& rNames );

    SC_DLLPUBLIC const ::std::vector< OUString >& GetTableColumnNames() const { return maTableColumnNames; }

    SC_DLLPUBLIC void SetTableColumnModel( TableColumnModel& rModel )

    {

        maTableColumnModel.push_back(std::move(rModel));

    }

    SC_DLLPUBLIC const ::std::vector< TableColumnModel >& GetTableColumnModel() const { return maTableColumnModel; }

    bool        AreTableColumnNamesDirty() const { return mbTableColumnNamesDirty; }

    /** Refresh/update the column names with the header row's cell contents. */

    SC_DLLPUBLIC void RefreshTableColumnNames( ScDocument* pDoc );

    /** Refresh/update the column names with the header row's cell contents

        within the given range. */

    void RefreshTableColumnNames( ScDocument& rDoc, const ScRangeList& rRangeList );

    /** Finds the column named rName and returns the corresponding offset

        within the table.

        @returns -1 if not found.

        XXX NOTE: there is no refresh of names or anything implemented yet, use

        this only during document load time.

     */

    sal_Int32   GetColumnNameOffset( const OUString& rName ) const;

    /** Returns table column name if nCol is within column range and name

        is stored, else empty string. */

    const OUString & GetTableColumnName( SCCOL nCol ) const;

    OUString GetSourceString() const;

    OUString GetOperations() const;

    SC_DLLPUBLIC void GetSortParam(ScSortParam& rSortParam) const;

    SC_DLLPUBLIC void SetSortParam(const ScSortParam& rSortParam);

    /** Remember some more settings of ScSortParam, only to be called at

        anonymous DB ranges as it at least overwrites bHasHeader. */

    void        UpdateFromSortParam( const ScSortParam& rSortParam );

    SC_DLLPUBLIC void       GetQueryParam(ScQueryParam& rQueryParam) const;

    SC_DLLPUBLIC void       SetQueryParam(const ScQueryParam& rQueryParam);

    SC_DLLPUBLIC bool       GetAdvancedQuerySource(ScRange& rSource) const;

    SC_DLLPUBLIC void       SetAdvancedQuerySource(const ScRange* pSource);

    SC_DLLPUBLIC void       GetSubTotalParam(ScSubTotalParam& rSubTotalParam) const;

    SC_DLLPUBLIC void       SetSubTotalParam(const ScSubTotalParam& rSubTotalParam);

    // Total row param handling for Table Styles

    SC_DLLPUBLIC void       ImportTotalRowParam(ScSubTotalParam& rSubTotalParam,

                                                const std::vector<TableColumnAttributes>& rAttributesVector,

                                                formula::FormulaGrammar::Grammar eGrammar) const;

    SC_DLLPUBLIC void       CreateTotalRowParam(ScSubTotalParam& rSubTotalParam) const;

    SC_DLLPUBLIC std::vector<TableColumnAttributes>

                            GetTotalRowAttributes(formula::FormulaGrammar::Grammar eGrammar) const;

    OUString    GetSimpleSubTotalFunction(const ScTokenArray* pTokens, SCCOL nCol, SCROW nHeaderRow) const;

    void        GetImportParam(ScImportParam& rImportParam) const;

    void        SetImportParam(const ScImportParam& rImportParam);

    bool        IsDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, ScDBDataPortion ePortion) const;

    bool        IsDBAtArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const;

    bool        HasImportParam() const;

    SC_DLLPUBLIC bool HasQueryParam() const;

    bool        HasSortParam() const;

    bool        HasSubTotalParam() const;

    bool        HasImportSelection() const      { return bDBSelection; }

    void        SetImportSelection(bool bSet)   { bDBSelection = bSet; }

    bool        HasAutoFilter() const       { return bAutoFilter; }

    void        SetAutoFilter(bool bSet)    { bAutoFilter = bSet; }

    bool        IsModified() const          { return bModified; }

    void        SetModified(bool bMod)      { bModified = bMod; }

    void    UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos );

    bool    UpdateReference(const ScDocument& rDoc, UpdateRefMode eUpdateRefMode, SCCOL nCol1,

                            SCROW nRow1, SCTAB nTab1, SCCOL nCol2, SCROW nRow2, SCTAB nTab2,

                            SCCOL nDx, SCROW nDy, SCTAB nDz);

    void ExtendDataArea(const ScDocument& rDoc);

    void CalcSaveFilteredCount(SCSIZE nNonFilteredRowCount);

    void GetFilterSelCount(SCSIZE& nSelected, SCSIZE& nTotal);

    SC_DLLPUBLIC void SetTableStyleInfo(const ScTableStyleParam& rParams);

    SC_DLLPUBLIC const ScTableStyleParam* GetTableStyleInfo() const;

    static ScSubTotalFunc GetSubTotalFuncFromString(std::u16string_view sFunction);

    static OUString GetStringFromSubTotalFunc(ScSubTotalFunc eFunc);

private:

    void AdjustTableColumnNames( UpdateRefMode eUpdateRefMode, SCCOL nDx, SCCOL nCol1,

            SCCOL nOldCol1, SCCOL nOldCol2, SCCOL nNewCol1, SCCOL nNewCol2 );

    void InvalidateTableColumnNames( bool bSwapToEmptyNames );

};

class ScDBCollection

{

public:

    enum RangeType { GlobalNamed, GlobalAnonymous, SheetAnonymous };

    /**

     * Stores global named database ranges.

     */

    class SC_DLLPUBLIC NamedDBs final : public ScDBDataContainerBase

    {

        friend class ScDBCollection;

        typedef ::std::set<std::unique_ptr<ScDBData>, ScDBData::less> DBsType;

        DBsType m_DBs;

        ScDBCollection& mrParent;

        NamedDBs(ScDBCollection& rParent, ScDocument& rDoc);

        NamedDBs(const NamedDBs& r, ScDBCollection& rParent);

        NamedDBs(const NamedDBs&) = delete;

        virtual ~NamedDBs() override;

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

        void initInserted( ScDBData* p );

    public:

        typedef DBsType::iterator iterator;

        typedef DBsType::const_iterator const_iterator;

        iterator begin();

        iterator end();

        const_iterator begin() const;

        const_iterator end() const;

        ScDBData* findByIndex(sal_uInt16 nIndex);

        ScDBData* findByUpperName(const OUString& rName);

        iterator findByUpperName2(const OUString& rName);

        iterator findByPointer(const ScDBData* p);

        ScDBData* findByName(const OUString& rName);

        /** Takes ownership of p and attempts to insert it into the collection.

            Deletes p if it could not be inserted, i.e. duplicate name.

            @return <TRUE/> if inserted, else <FALSE/>.

         */

        bool insert(std::unique_ptr<ScDBData> p);

        iterator erase(const iterator& itr);

        bool empty() const;

        size_t size() const;

        bool operator== (const NamedDBs& r) const;

    };

    /**

     * Stores global anonymous database ranges.

     */

    class AnonDBs

    {

        typedef ::std::vector<std::unique_ptr<ScDBData>> DBsType;

        DBsType m_DBs;

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

    public:

        AnonDBs();

        AnonDBs(AnonDBs const&);

        typedef DBsType::iterator iterator;

        typedef DBsType::const_iterator const_iterator;

        iterator begin();

        iterator end();

        const_iterator begin() const;

        const_iterator end() const;

        const ScDBData* findAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, ScDBDataPortion ePortion) const;

        const ScDBData* findByRange(const ScRange& rRange) const;

        void deleteOnTab(SCTAB nTab);

        ScDBData* getByRange(const ScRange& rRange);

        void insert(ScDBData* p);

        iterator erase(const iterator& itr);

        bool empty() const;

        bool has( const ScDBData* p ) const;

        bool operator== (const AnonDBs& r) const;

    };

private:

    Link<Timer *, void> aRefreshHandler;

    ScDocument& rDoc;

    sal_uInt16 nEntryIndex;         ///< counter for unique indices

    NamedDBs maNamedDBs;

    AnonDBs maAnonDBs;

public:

    ScDBCollection(ScDocument& rDocument);

    ScDBCollection(const ScDBCollection& r);

    NamedDBs& getNamedDBs() { return maNamedDBs;}

    const NamedDBs& getNamedDBs() const { return maNamedDBs;}

    AnonDBs& getAnonDBs() { return maAnonDBs;}

    const AnonDBs& getAnonDBs() const { return maAnonDBs;}

    const ScDBData* GetTableDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, ScDBDataPortion ePortion) const;

    ScDBData* GetTableDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, ScDBDataPortion ePortion);

    const ScDBData* GetDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, ScDBDataPortion ePortion) const;

    ScDBData* GetDBAtCursor(SCCOL nCol, SCROW nRow, SCTAB nTab, ScDBDataPortion ePortion);

    const ScDBData* GetDBAtArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2) const;

    SC_DLLPUBLIC ScDBData* GetDBAtArea(SCTAB nTab, SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2);

    SC_DLLPUBLIC ScDBData* GetDBNearCursor(SCCOL nCol, SCROW nRow, SCTAB nTab );

    SC_DLLPUBLIC std::vector<ScDBData*> GetAllDBsFromTab(SCTAB nTab);

    std::vector<const ScDBData*> GetAllNamedDBsInArea(SCCOL nCol1, SCROW nRow1, SCCOL nCol2,

                                                      SCROW nRow2, SCTAB nTab) const;

    void RefreshDirtyTableColumnNames();

    void    DeleteOnTab( SCTAB nTab );

    void    UpdateReference(UpdateRefMode eUpdateRefMode,

                                SCCOL nCol1, SCROW nRow1, SCTAB nTab1,

                                SCCOL nCol2, SCROW nRow2, SCTAB nTab2,

                                SCCOL nDx, SCROW nDy, SCTAB nDz);

    void    UpdateMoveTab( SCTAB nOldPos, SCTAB nNewPos );

    void    CopyToTable(SCTAB nOldPos, SCTAB nNewPos);

    void            SetRefreshHandler( const Link<Timer *, void>& rLink )

                        { aRefreshHandler = rLink; }

    const Link<Timer *, void>& GetRefreshHandler() const { return aRefreshHandler; }

    SC_DLLPUBLIC bool empty() const;

    bool operator== (const ScDBCollection& r) const;

};

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