/* -*- 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 .
 */
#ifndef INCLUDED_SW_INC_TBLSEL_HXX
#define INCLUDED_SW_INC_TBLSEL_HXX

#include "swtable.hxx"
#include "swrect.hxx"
#include "swdllapi.h"

#include <o3tl/sorted_vector.hxx>

#include <memory>
#include <deque>
#include <vector>

class SwCursorShell;
class SwCursor;
class SwTableCursor;
class SwFrame;
class SwTabFrame;
class SwLayoutFrame;
class SwPaM;
class SwNode;
class SwUndoTableMerge;
class SwCellFrame;

typedef std::deque< SwCellFrame* > SwCellFrames;

struct CompareSwSelBoxes
{
    bool operator()(const SwTableBox* const& lhs, const SwTableBox* const& rhs) const
    {
        return lhs->GetSttIdx() < rhs->GetSttIdx();
    }
};
class SwSelBoxes : public o3tl::sorted_vector<SwTableBox*, CompareSwSelBoxes> {};

// Collects all boxes in table that are selected.
// Selection gets extended in given direction according to enum-parameter.
// Boxes are collected via the Layout; works correctly if tables are split.
// (Cf. MakeSelUnions().)
enum class SwTableSearchType : sal_uInt16
{
    NONE           = 0x01, // No extension.
    Row            = 0x02, // Extend to rows.
    Col            = 0x03, // Extend to columns.

    // As flags to the other values!
    Protect        = 0x08, // Collect protected boxes too.
    NoUnionCorrect = 0x10, // Do not correct collected Union.
};
namespace o3tl {
    template<> struct typed_flags<SwTableSearchType> : is_typed_flags<SwTableSearchType, 0x1b> {};
}

SW_DLLPUBLIC void GetTableSel( const SwCursorShell& rShell, SwSelBoxes& rBoxes,
                const SwTableSearchType = SwTableSearchType::NONE );

void GetTableSel( const SwCursor& rCursor, SwSelBoxes& rBoxes,
                const SwTableSearchType = SwTableSearchType::NONE );

// As before, but don't start from selection but from Start- EndFrames.
void GetTableSel( const SwLayoutFrame* pStart, const SwLayoutFrame* pEnd,
                SwSelBoxes& rBoxes, SwCellFrames* pCells,
                const SwTableSearchType = SwTableSearchType::NONE );

// As before but directly via PaMs.
void GetTableSelCrs( const SwCursorShell& rShell, SwSelBoxes& rBoxes );
void GetTableSelCrs( const SwTableCursor& rTableCursor, SwSelBoxes& rBoxes );

// Collect boxes relevant for auto sum.
bool GetAutoSumSel( const SwCursorShell&, SwCellFrames& );

// Check if the SelBoxes contains protected Boxes.
bool HasProtectedCells( const SwSelBoxes& rBoxes );

// Check if selection is balanced.
bool ChkChartSel( const SwNode& rSttNd, const SwNode& rEndNd);

// Check if cell is part of SSelection.
// (Became a function, in order to make sure that GetTableSel() and MakeTableCursor()
// have always the same concept of the selection.
bool IsFrameInTableSel( const SwRect& rUnion, const SwFrame* pCell );

// Determine boxes to be merged.
// In this process the rectangle gets "adapted" on the base of the layout,
// i.e. boxes are added if some overlap at the sides.
// Additionally a new box is created and filled with the relevant content.
void GetMergeSel( const SwPaM& rPam, SwSelBoxes& rBoxes,
                  SwTableBox** ppMergeBox, SwUndoTableMerge* pUndo );

// Check if selected boxes allow for a valid merge.
TableMergeErr CheckMergeSel( const SwPaM& rPam );
TableMergeErr CheckMergeSel( const SwSelBoxes& rBoxes );

bool IsEmptyBox( const SwTableBox& rBox, SwPaM& rPam );

// Check if Split or InsertCol lead to a box becoming smaller than MINLAY.
bool CheckSplitCells( const SwCursorShell& rShell, sal_uInt16 nDiv,
                        const SwTableSearchType );
bool CheckSplitCells( const SwCursor& rCursor, sal_uInt16 nDiv,
                        const SwTableSearchType );

// For working on tab selection also for split tables.
class SwSelUnion
{
    SwRect   m_aUnion;        // The rectangle enclosing the selection.
    SwTabFrame *m_pTable;       // The (Follow-)Table for the Union.

public:
    SwSelUnion( const SwRect &rRect, SwTabFrame *pTab ) :
        m_aUnion( rRect ), m_pTable( pTab ) {}

    const SwRect&   GetUnion() const { return m_aUnion; }
          SwRect&   GetUnion()       { return m_aUnion; }
    const SwTabFrame *GetTable() const { return m_pTable; }
          SwTabFrame *GetTable()       { return m_pTable; }
};

// Determines tables affected by a table selection and union rectangles
// of the selection (also for split tables)
typedef std::vector<SwSelUnion> SwSelUnions;

// Gets the tables involved in a table selection and the union-rectangles of the selections
// - also for split tables.
// If a parameter is passed that != SwTableSearchType::NONE
// the selection is extended in the given direction.
void MakeSelUnions( SwSelUnions&, const SwLayoutFrame *pStart,
                    const SwLayoutFrame *pEnd,
                    const SwTableSearchType = SwTableSearchType::NONE );

// These classes copy the current table selections (rBoxes) into a
// separate structure while keeping the table structure.

class FndBox_;
class FndLine_;

typedef std::vector<std::unique_ptr<FndBox_>> FndBoxes_t;
typedef std::vector<std::unique_ptr<FndLine_>> FndLines_t;

class FndBox_
{
    SwTableBox* m_pBox;
    FndLines_t m_Lines;
    FndLine_* m_pUpper;

    SwTableLine *m_pLineBefore; ///< For deleting/restoring the layout.
    SwTableLine *m_pLineBehind; ///< For deleting/restoring the layout.

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

public:
    inline FndBox_( SwTableBox* pB, FndLine_* pFL );

    const FndLines_t&   GetLines() const    { return m_Lines; }
        FndLines_t&     GetLines()          { return m_Lines; }
    const SwTableBox*   GetBox() const      { return m_pBox; }
        SwTableBox*     GetBox()            { return m_pBox; }
    const FndLine_*     GetUpper() const    { return m_pUpper; }
        FndLine_*       GetUpper()          { return m_pUpper; }

    void SetTableLines( const SwSelBoxes &rBoxes, const SwTable &rTable );
    void SetTableLines( const SwTable &rTable );
    //Add an input param to identify if acc table should be disposed
    void DelFrames ( SwTable &rTable );
    void MakeFrames( SwTable &rTable );
    void MakeNewFrames( SwTable &rTable, const sal_uInt16 nNumber,
                                       const bool bBehind );
    bool AreLinesToRestore( const SwTable &rTable ) const;

    void ClearLineBehind() { m_pLineBehind = nullptr; }
};

class FndLine_
{
    SwTableLine* m_pLine;
    FndBoxes_t m_Boxes;
    FndBox_* m_pUpper;

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

public:
    FndLine_(SwTableLine* pL, FndBox_* pFB) : m_pLine(pL), m_pUpper(pFB) {}
    const FndBoxes_t&   GetBoxes() const    { return m_Boxes; }
        FndBoxes_t&     GetBoxes()          { return m_Boxes; }
    const SwTableLine*  GetLine() const     { return m_pLine; }
        SwTableLine*    GetLine()           { return m_pLine; }
    const FndBox_*      GetUpper() const    { return m_pUpper; }
        FndBox_*        GetUpper()          { return m_pUpper; }

    void SetUpper( FndBox_* pUp ) { m_pUpper = pUp; }
};

FndBox_::FndBox_( SwTableBox* pB, FndLine_* pFL ) :
    m_pBox(pB), m_pUpper(pFL), m_pLineBefore( nullptr ), m_pLineBehind( nullptr ) {}

struct FndPara
{
    const SwSelBoxes& rBoxes;
    FndLine_* pFndLine;
    FndBox_* pFndBox;

    FndPara( const SwSelBoxes& rBxs, FndBox_* pFB )
        : rBoxes(rBxs), pFndLine(nullptr), pFndBox(pFB) {}
    FndPara( const FndPara& rPara, FndBox_* pFB )
        : rBoxes(rPara.rBoxes), pFndLine(rPara.pFndLine), pFndBox(pFB) {}
    FndPara( const FndPara& rPara, FndLine_* pFL )
        : rBoxes(rPara.rBoxes), pFndLine(pFL), pFndBox(rPara.pFndBox) {}
};

/** This creates a structure mirroring the SwTable structure that contains all
    rows and non-leaf boxes (as pointers to SwTableBox/SwTableLine, not copies),
    plus the leaf boxes that are selected by pFndPara->rBoxes
 */
SW_DLLPUBLIC void ForEach_FndLineCopyCol(SwTableLines& rLines, FndPara* pFndPara );

#endif // INCLUDED_SW_INC_TBLSEL_HXX

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