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

 */

#include <operation/MoveBlockOperation.hxx>

#include <osl/diagnose.h>

#include <sfx2/app.hxx>

#include <clipparam.hxx>

#include <docsh.hxx>

#include <docfunc.hxx>

#include <document.hxx>

#include <drwlayer.hxx>

#include <editable.hxx>

#include <globstr.hrc>

#include <markdata.hxx>

#include <undoblk.hxx>

namespace sc

{

MoveBlockOperation::MoveBlockOperation(ScDocShell& rDocShell, const ScRange& rSource,

                                       const ScAddress& rDestPos, bool bCut, bool bRecord,

                                       bool bPaint, bool bApi)

    : Operation(OperationType::MoveBlock, bRecord, bApi)

    , mrDocShell(rDocShell)

    , maSource(rSource)

    , maDestPos(rDestPos)

    , mbCut(bCut)

    , mbPaint(bPaint)

{

}

bool MoveBlockOperation::canRunTheOperation() const

{

    return !isInputOnSheetViewAutoFilter(maSource)

           && !isInputOnSheetViewAutoFilter(ScRange(maDestPos));

}

bool MoveBlockOperation::runImplementation()

{

    ScDocShellModificator aModificator(mrDocShell);

    ScRange aSource = convertRange(maSource);

    ScAddress aDestPos = convertAddress(maDestPos);

    SCCOL nStartCol = aSource.aStart.Col();

    SCROW nStartRow = aSource.aStart.Row();

    SCTAB nStartTab = aSource.aStart.Tab();

    SCCOL nEndCol = aSource.aEnd.Col();

    SCROW nEndRow = aSource.aEnd.Row();

    SCTAB nEndTab = aSource.aEnd.Tab();

    SCCOL nDestCol = aDestPos.Col();

    SCROW nDestRow = aDestPos.Row();

    SCTAB nDestTab = aDestPos.Tab();

    ScDocument& rDoc = mrDocShell.GetDocument();

    if (!rDoc.ValidRow(nStartRow) || !rDoc.ValidRow(nEndRow) || !rDoc.ValidRow(nDestRow))

    {

        OSL_FAIL("invalid row in MoveBlock");

        return false;

    }

    //  adjust related scenarios too - but only when moved within one sheet

    bool bScenariosAdded = false;

    if (mbRecord && !rDoc.IsUndoEnabled())

        mbRecord = false;

    SCTAB nTabCount = rDoc.GetTableCount();

    if (nDestTab == nStartTab && !rDoc.IsScenario(nEndTab))

        while (nEndTab + 1 < nTabCount && rDoc.IsScenario(nEndTab + 1))

        {

            ++nEndTab;

            bScenariosAdded = true;

        }

    SCTAB nSrcTabCount = nEndTab - nStartTab + 1;

    SCTAB nDestEndTab = nDestTab + nSrcTabCount - 1;

    SCTAB nTab;

    ScDocumentUniquePtr pClipDoc(new ScDocument(SCDOCMODE_CLIP));

    ScMarkData aSourceMark(rDoc.GetSheetLimits());

    for (nTab = nStartTab; nTab <= nEndTab; nTab++)

        aSourceMark.SelectTable(nTab, true); // select source

    aSourceMark.SetMarkArea(aSource);

    ScDocShellRef aDragShellRef;

    if (rDoc.HasOLEObjectsInArea(aSource))

    {

        aDragShellRef = new ScDocShell; // DocShell needs a Ref immediately

        aDragShellRef->DoInitNew();

    }

    ScDrawLayer::SetGlobalDrawPersist(aDragShellRef.get());

    ScClipParam aClipParam(ScRange(nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nStartTab),

                           mbCut);

    rDoc.CopyToClip(aClipParam, pClipDoc.get(), &aSourceMark, bScenariosAdded, true);

    ScDrawLayer::SetGlobalDrawPersist(nullptr);

    SCCOL nOldEndCol = nEndCol;

    SCROW nOldEndRow = nEndRow;

    bool bClipOver = false;

    for (nTab = nStartTab; nTab <= nEndTab; nTab++)

    {

        SCCOL nTmpEndCol = nOldEndCol;

        SCROW nTmpEndRow = nOldEndRow;

        if (rDoc.ExtendMerge(nStartCol, nStartRow, nTmpEndCol, nTmpEndRow, nTab))

            bClipOver = true;

        if (nTmpEndCol > nEndCol)

            nEndCol = nTmpEndCol;

        if (nTmpEndRow > nEndRow)

            nEndRow = nTmpEndRow;

    }

    SCCOL nDestEndCol = nDestCol + (nOldEndCol - nStartCol);

    SCROW nDestEndRow = nDestRow + (nOldEndRow - nStartRow);

    SCCOL nUndoEndCol = nDestCol + (nEndCol - nStartCol); // extended in destination block

    SCROW nUndoEndRow = nDestRow + (nEndRow - nStartRow);

    bool bIncludeFiltered = mbCut;

    if (!bIncludeFiltered)

    {

        //  adjust sizes to include only non-filtered rows

        SCCOL nClipX;

        SCROW nClipY;

        pClipDoc->GetClipArea(nClipX, nClipY, false);

        SCROW nUndoAdd = nUndoEndRow - nDestEndRow;

        nDestEndRow = nDestRow + nClipY;

        nUndoEndRow = nDestEndRow + nUndoAdd;

    }

    if (!rDoc.ValidCol(nUndoEndCol) || !rDoc.ValidRow(nUndoEndRow))

    {

        if (!mbApi)

            mrDocShell.ErrorMessage(STR_PASTE_FULL);

        return false;

    }

    //  Test for cell protection

    ScEditableTester aTester;

    for (nTab = nDestTab; nTab <= nDestEndTab; nTab++)

        aTester.TestBlock(rDoc, nTab, nDestCol, nDestRow, nUndoEndCol, nUndoEndRow);

    if (mbCut)

        for (nTab = nStartTab; nTab <= nEndTab; nTab++)

            aTester.TestBlock(rDoc, nTab, nStartCol, nStartRow, nEndCol, nEndRow);

    if (!aTester.IsEditable())

    {

        if (!mbApi)

            mrDocShell.ErrorMessage(aTester.GetMessageId());

        return false;

    }

    //  Test for merged cells- when moving after delete

    if (bClipOver && !mbCut)

        if (rDoc.HasAttrib(nDestCol, nDestRow, nDestTab, nUndoEndCol, nUndoEndRow, nDestEndTab,

                           HasAttrFlags::Merged | HasAttrFlags::Overlapped))

        { // "Merge of already merged cells not possible"

            if (!mbApi)

                mrDocShell.ErrorMessage(STR_MSSG_MOVEBLOCKTO_0);

            return false;

        }

    //  Are there borders in the cells? (for painting)

    sal_uInt16 nSourceExt = 0;

    mrDocShell.UpdatePaintExt(nSourceExt, nStartCol, nStartRow, nStartTab, nEndCol, nEndRow,

                              nEndTab);

    sal_uInt16 nDestExt = 0;

    mrDocShell.UpdatePaintExt(nDestExt, nDestCol, nDestRow, nDestTab, nDestEndCol, nDestEndRow,

                              nDestEndTab);

    //  do it

    ScDocumentUniquePtr pUndoDoc;

    if (mbRecord)

    {

        bool bWholeCols = (nStartRow == 0 && nEndRow == rDoc.MaxRow());

        bool bWholeRows = (nStartCol == 0 && nEndCol == rDoc.MaxCol());

        InsertDeleteFlags nUndoFlags = (InsertDeleteFlags::ALL & ~InsertDeleteFlags::OBJECTS)

                                       | InsertDeleteFlags::NOCAPTIONS;

        pUndoDoc.reset(new ScDocument(SCDOCMODE_UNDO));

        pUndoDoc->InitUndo(rDoc, nStartTab, nEndTab, bWholeCols, bWholeRows);

        if (mbCut)

        {

            rDoc.CopyToDocument(nStartCol, nStartRow, nStartTab, nEndCol, nEndRow, nEndTab,

                                nUndoFlags, false, *pUndoDoc);

        }

        if (nDestTab != nStartTab)

            pUndoDoc->AddUndoTab(nDestTab, nDestEndTab, bWholeCols, bWholeRows);

        rDoc.CopyToDocument(nDestCol, nDestRow, nDestTab, nDestEndCol, nDestEndRow, nDestEndTab,

                            nUndoFlags, false, *pUndoDoc);

        rDoc.BeginDrawUndo();

    }

    bool bSourceHeight = false; // adjust heights?

    if (mbCut)

    {

        ScMarkData aDelMark(rDoc.GetSheetLimits()); // only for tables

        for (nTab = nStartTab; nTab <= nEndTab; nTab++)

        {

            rDoc.DeleteAreaTab(nStartCol, nStartRow, nOldEndCol, nOldEndRow, nTab,

                               InsertDeleteFlags::ALL);

            aDelMark.SelectTable(nTab, true);

        }

        rDoc.DeleteObjectsInArea(nStartCol, nStartRow, nOldEndCol, nOldEndRow, aDelMark);

        //  Test for merged cells

        if (bClipOver)

            if (rDoc.HasAttrib(nDestCol, nDestRow, nDestTab, nUndoEndCol, nUndoEndRow, nDestEndTab,

                               HasAttrFlags::Merged | HasAttrFlags::Overlapped))

            {

                rDoc.CopyFromClip(aSource, aSourceMark, InsertDeleteFlags::ALL, nullptr,

                                  pClipDoc.get());

                for (nTab = nStartTab; nTab <= nEndTab; nTab++)

                {

                    SCCOL nTmpEndCol = nEndCol;

                    SCROW nTmpEndRow = nEndRow;

                    rDoc.ExtendMerge(nStartCol, nStartRow, nTmpEndCol, nTmpEndRow, nTab, true);

                }

                // Report error only after restoring content

                if (!mbApi) // "Merge of already merged cells not possible"

                    mrDocShell.ErrorMessage(STR_MSSG_MOVEBLOCKTO_0);

                return false;

            }

        bSourceHeight = mrDocShell.GetDocFunc().AdjustRowHeight(aSource, false, mbApi);

    }

    ScRange aPasteDest(nDestCol, nDestRow, nDestTab, nDestEndCol, nDestEndRow, nDestEndTab);

    ScMarkData aDestMark(rDoc.GetSheetLimits());

    for (nTab = nDestTab; nTab <= nDestEndTab; nTab++)

        aDestMark.SelectTable(nTab, true); // select destination

    aDestMark.SetMarkArea(aPasteDest);

    /*  Do not copy drawing objects here. While pasting, the

        function ScDocument::UpdateReference() is called which calls

        ScDrawLayer::MoveCells() which may move away inserted objects to wrong

        positions (e.g. if source and destination range overlaps).*/

    rDoc.CopyFromClip(aPasteDest, aDestMark, InsertDeleteFlags::ALL & ~InsertDeleteFlags::OBJECTS,

                      pUndoDoc.get(), pClipDoc.get(), true, false, bIncludeFiltered);

    // skipped rows and merged cells don't mix

    if (!bIncludeFiltered && pClipDoc->HasClipFilteredRows())

        mrDocShell.GetDocFunc().UnmergeCells(aPasteDest, false, nullptr);

    bool bDestHeight = mrDocShell.GetDocFunc().AdjustRowHeight(

        ScRange(0, nDestRow, nDestTab, rDoc.MaxCol(), nDestEndRow, nDestEndTab), false, mbApi);

    /*  Paste drawing objects after adjusting formula references

        and row heights. There are no cell notes or drawing objects, if the

        clipdoc does not contain a drawing layer.*/

    if (pClipDoc->GetDrawLayer())

        rDoc.CopyFromClip(aPasteDest, aDestMark, InsertDeleteFlags::OBJECTS, nullptr,

                          pClipDoc.get(), true, false, bIncludeFiltered);

    if (mbRecord)

    {

        ScRange aUndoRange(nStartCol, nStartRow, nStartTab, nOldEndCol, nOldEndRow, nEndTab);

        ScAddress aDestPosUndo(nDestCol, nDestRow, nDestTab);

        mrDocShell.GetUndoManager()->AddUndoAction(std::make_unique<ScUndoDragDrop>(

            mrDocShell, aUndoRange, aDestPosUndo, mbCut, std::move(pUndoDoc), bScenariosAdded));

    }

    SCCOL nDestPaintEndCol = nDestEndCol;

    SCROW nDestPaintEndRow = nDestEndRow;

    for (nTab = nDestTab; nTab <= nDestEndTab; nTab++)

    {

        SCCOL nTmpEndCol = nDestEndCol;

        SCROW nTmpEndRow = nDestEndRow;

        rDoc.ExtendMerge(nDestCol, nDestRow, nTmpEndCol, nTmpEndRow, nTab, true);

        if (nTmpEndCol > nDestPaintEndCol)

            nDestPaintEndCol = nTmpEndCol;

        if (nTmpEndRow > nDestPaintEndRow)

            nDestPaintEndRow = nTmpEndRow;

    }

    if (mbCut)

        for (nTab = nStartTab; nTab <= nEndTab; nTab++)

            rDoc.RefreshAutoFilter(nStartCol, nStartRow, nEndCol, nEndRow, nTab);

    if (mbPaint)

    {

        //  destination range:

        SCCOL nPaintStartX = nDestCol;

        SCROW nPaintStartY = nDestRow;

        SCCOL nPaintEndX = nDestPaintEndCol;

        SCROW nPaintEndY = nDestPaintEndRow;

        PaintPartFlags nFlags = PaintPartFlags::Grid;

        if (nStartRow == 0 && nEndRow == rDoc.MaxRow()) // copy widths too?

        {

            nPaintEndX = rDoc.MaxCol();

            nPaintStartY = 0;

            nPaintEndY = rDoc.MaxRow();

            nFlags |= PaintPartFlags::Top;

        }

        if (bDestHeight || (nStartCol == 0 && nEndCol == rDoc.MaxCol()))

        {

            nPaintEndY = rDoc.MaxRow();

            nPaintStartX = 0;

            nPaintEndX = rDoc.MaxCol();

            nFlags |= PaintPartFlags::Left;

        }

        if (bScenariosAdded)

        {

            nPaintStartX = 0;

            nPaintStartY = 0;

            nPaintEndX = rDoc.MaxCol();

            nPaintEndY = rDoc.MaxRow();

        }

        mrDocShell.PostPaint(nPaintStartX, nPaintStartY, nDestTab, nPaintEndX, nPaintEndY,

                             nDestEndTab, nFlags, nSourceExt | nDestExt);

        if (mbCut)

        {

            //  source range:

            nPaintStartX = nStartCol;

            nPaintStartY = nStartRow;

            nPaintEndX = nEndCol;

            nPaintEndY = nEndRow;

            nFlags = PaintPartFlags::Grid;

            if (bSourceHeight)

            {

                nPaintEndY = rDoc.MaxRow();

                nPaintStartX = 0;

                nPaintEndX = rDoc.MaxCol();

                nFlags |= PaintPartFlags::Left;

            }

            if (bScenariosAdded)

            {

                nPaintStartX = 0;

                nPaintStartY = 0;

                nPaintEndX = rDoc.MaxCol();

                nPaintEndY = rDoc.MaxRow();

            }

            mrDocShell.PostPaint(nPaintStartX, nPaintStartY, nStartTab, nPaintEndX, nPaintEndY,

                                 nEndTab, nFlags, nSourceExt);

        }

    }

    syncSheetViews();

    aModificator.SetDocumentModified();

    SfxGetpApp()->Broadcast(SfxHint(SfxHintId::ScAreaLinksChanged));

    mrDocShell.ResolveSpilledOutputs();

    return true;

}

}

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