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

 */

#include <string>

#include <memory>

#include <boost/property_tree/json_parser.hpp>

#include <hintids.hxx>

#include <sal/log.hxx>

#include <svl/cjkoptions.hxx>

#include <svl/ctloptions.hxx>

#include <svx/pageitem.hxx>

#include <svl/whiter.hxx>

#include <sfx2/viewfrm.hxx>

#include <svl/eitem.hxx>

#include <svl/srchitem.hxx>

#include <sfx2/bindings.hxx>

#include <sfx2/request.hxx>

#include <sfx2/lokhelper.hxx>

#include <svx/srchdlg.hxx>

#include <pamtyp.hxx>

#include <swmodule.hxx>

#include <swwait.hxx>

#include <workctrl.hxx>

#include <view.hxx>

#include <wrtsh.hxx>

#include <swundo.hxx>

#include <uitool.hxx>

#include <wview.hxx>

#include <cmdid.h>

#include <docsh.hxx>

#include <LibreOfficeKit/LibreOfficeKitEnums.h>

#include <comphelper/lok.hxx>

#include <comphelper/string.hxx>

#include <strings.hrc>

#include <SwRewriter.hxx>

#include <PostItMgr.hxx>

using namespace com::sun::star;

using namespace ::com::sun::star::lang;

//Search Parameter

struct SwSearchOptions

{

    SwDocPositions eStart, eEnd;

    bool bDontWrap;

    SwSearchOptions( SwWrtShell const * pSh, bool bBackward );

};

/// Adds rMatches using rKey as a key to the rTree tree.

static void lcl_addContainerToJson(boost::property_tree::ptree& rTree, const OString& rKey, const std::vector<OString>& rMatches)

{

    boost::property_tree::ptree aChildren;

    for (const OString& rMatch : rMatches)

    {

        boost::property_tree::ptree aChild;

        aChild.put("part", "0");

        aChild.put("rectangles", rMatch.getStr());

        aChildren.push_back(std::make_pair("", aChild));

    }

    rTree.add_child(rKey.getStr(), aChildren);

}

/// Emits LOK callbacks (count, selection) for search results.

static void lcl_emitSearchResultCallbacks(SvxSearchItem const * pSearchItem, SwWrtShell const * pWrtShell, bool bHighlightAll)

{

    // Emit a callback also about the selection rectangles, grouped by matches.

    SwPaM* pPaM = pWrtShell->GetCursor();

    if (!pPaM)

        return;

    std::vector<OString> aMatches;

    for (SwPaM& rPaM : pPaM->GetRingContainer())

    {

        if (SwShellCursor* pShellCursor = dynamic_cast<SwShellCursor*>(&rPaM))

        {

            std::vector<OString> aSelectionRectangles;

            pShellCursor->SwSelPaintRects::Show(&aSelectionRectangles);

            std::vector<OString> aRect;

            for (const OString & rSelectionRectangle : aSelectionRectangles)

            {

                if (rSelectionRectangle.isEmpty())

                    continue;

                aRect.push_back(rSelectionRectangle);

            }

            OString sRect = comphelper::string::join("; ", aRect);

            aMatches.push_back(sRect);

        }

    }

    boost::property_tree::ptree aTree;

    aTree.put("searchString", pSearchItem->GetSearchString().toUtf8().getStr());

    aTree.put("highlightAll", bHighlightAll);

    lcl_addContainerToJson(aTree, "searchResultSelection"_ostr, aMatches);

    std::stringstream aStream;

    boost::property_tree::write_json(aStream, aTree);

    OString aPayload( aStream.str() );

    SfxViewShell* pNotifySh = pWrtShell->GetSfxViewShell();

    if (pNotifySh)

        pNotifySh->libreOfficeKitViewCallback(LOK_CALLBACK_SEARCH_RESULT_SELECTION, aPayload);

    if(bHighlightAll)

    {   // FindAll disables this during find, do it once when done.

        SfxLokHelper::notifyUpdate(pNotifySh,LOK_CALLBACK_TEXT_SELECTION);

        SfxLokHelper::notifyOtherViewsUpdatePerViewId(pNotifySh, LOK_CALLBACK_TEXT_VIEW_SELECTION);

    }

}

static bool lcl_IsNotTextSearch(const SvxSearchItem* pSearchItem)

{

    if (!pSearchItem || pSearchItem->GetSearchString().isEmpty())

        return true;

    return pSearchItem->GetPattern(); // paragraph style search

}

void SwView::ExecSearch(SfxRequest& rReq)

{

    GetWrtShell().addCurrentPosition();

    const SfxItemSet* pArgs = rReq.GetArgs();

    const SfxPoolItem* pItem = nullptr;

    bool bQuiet = false;

    if(pArgs && SfxItemState::SET == pArgs->GetItemState(SID_SEARCH_QUIET, false, &pItem))

        bQuiet = static_cast<const SfxBoolItem*>( pItem)->GetValue();

    sal_uInt16 nSlot = rReq.GetSlot();

    if (nSlot == FN_REPEAT_SEARCH && !s_pSrchItem)

    {

        if(bQuiet)

        {

            rReq.SetReturnValue(SfxBoolItem(nSlot, false));

            nSlot = 0;

        }

    }

    if( m_pWrtShell->IsBlockMode() )

        m_pWrtShell->LeaveBlockMode();

    switch (nSlot)

    {

    // for now do nothing

    case SID_SEARCH_ITEM:

    {

        OSL_ENSURE(pArgs, "Args missing");

        if (pArgs)

        {

            delete s_pSrchItem;

            s_pSrchItem = pArgs->Get(SID_SEARCH_ITEM).Clone();

        }

    }

    break;

    case FID_SEARCH_ON:

    {

        s_bJustOpened = true;

        GetViewFrame().GetBindings().Invalidate(SID_SEARCH_ITEM);

        // ensure SvxSearchDialog's Format dialog uses the preferred measurement unit

        const bool bIsHtmlMode = dynamic_cast<SwWebView*>(this);

        auto nMetric = static_cast<sal_uInt16>(GetDfltMetric(bIsHtmlMode));

        SwModule::get()->PutItem(SfxUInt16Item(SID_ATTR_METRIC, nMetric));

    }

    break;

    case FID_SEARCH_OFF:

        if(pArgs)

        {

            // Unregister dialog

            delete s_pSrchItem;

            s_pSrchItem = pArgs->Get(SID_SEARCH_ITEM).Clone();

            s_xSearchList.reset();

            s_xReplaceList.reset();

            SvxSearchDialog *const pSrchDlg(GetSearchDialog());

            if (pSrchDlg)

            {

                // We will remember the search-/replace items.

                const SearchAttrItemList* pList = pSrchDlg->GetSearchItemList();

                if( nullptr != pList && pList->Count() )

                    s_xSearchList.reset(new SearchAttrItemList( *pList ));

                pList = pSrchDlg->GetReplaceItemList();

                if (nullptr != pList && pList->Count())

                    s_xReplaceList.reset(new SearchAttrItemList( *pList ));

            }

        }

        break;

        case FN_REPEAT_SEARCH:

        case FID_SEARCH_NOW:

        {

            sal_uInt16 nMoveType = SwView::GetMoveType();

            {

                if(FID_SEARCH_NOW == nSlot && !rReq.IsAPI())

                    SwView::SetMoveType(NID_SRCH_REP);

            }

            SvxSearchDialog * pSrchDlg(GetSearchDialog());

            if (pSrchDlg)

            {

                s_xSearchList.reset();

                s_xReplaceList.reset();

                const SearchAttrItemList* pList = pSrchDlg->GetSearchItemList();

                if( nullptr != pList && pList->Count() )

                    s_xSearchList.reset(new SearchAttrItemList( *pList ));

                pList = pSrchDlg->GetReplaceItemList();

                if (nullptr != pList && pList->Count())

                    s_xReplaceList.reset(new SearchAttrItemList( *pList ));

            }

            if (nSlot == FN_REPEAT_SEARCH)

            {

                OSL_ENSURE(s_pSrchItem, "SearchItem missing");

                if( !s_pSrchItem )

                    s_pSrchItem = new SvxSearchItem(SID_SEARCH_ITEM);

            }

            else

            {

                // Get SearchItem from request

                OSL_ENSURE(pArgs, "Args missing");

                if ( pArgs )

                {

                    delete s_pSrchItem;

                    s_pSrchItem = pArgs->Get(SID_SEARCH_ITEM).Clone();

                }

            }

            // tdf#115665 Format in the CTRL+H search affects the CTRL+F search

            if (pArgs)

            {

                if (const SfxBoolItem* pUseAttrItemListItem

                    = pArgs->GetItemIfSet(SID_SEARCH_USE_ATTR_ITEM_LIST, false))

                {

                    if (!pUseAttrItemListItem->GetValue())

                        s_xSearchList.reset();

                }

            }

            SvxSearchCmd eCommand = s_pSrchItem->GetCommand();

            switch (eCommand)

            {

            case SvxSearchCmd::FIND:

            {

                bool bRet = SearchAndWrap(bQuiet);

                if( bRet )

                {

                    Scroll(m_pWrtShell->GetCharRect().SVRect());

                    if (comphelper::LibreOfficeKit::isActive())

                        lcl_emitSearchResultCallbacks(s_pSrchItem, m_pWrtShell.get(), /* bHighlightAll = */ false);

                }

                rReq.SetReturnValue(SfxBoolItem(nSlot, bRet));

                GetDocShell()->Broadcast(SfxHint(SfxHintId::SwNavigatorUpdateTracking));

            }

            break;

            case SvxSearchCmd::FIND_ALL:

            {

                // Disable LOK selection notifications during search.

                m_pWrtShell->GetSfxViewShell()->setTiledSearching(true);

                const auto nFound = SearchAll();

                m_pWrtShell->GetSfxViewShell()->setTiledSearching(false);

                GetDocShell()->Broadcast(

                            SfxHint(SfxHintId::SwNavigatorUpdateTracking));

                GetDocShell()->Broadcast(

                            SfxHint(SfxHintId::SwNavigatorSelectOutlinesWithSelections));

                if (nFound == 0)

                {

#if HAVE_FEATURE_DESKTOP

                    if( !bQuiet )

                    {

                        if (SfxViewShell* pNotifySh = m_pWrtShell->GetSfxViewShell())

                            pNotifySh->libreOfficeKitViewCallback(LOK_CALLBACK_SEARCH_NOT_FOUND, s_pSrchItem->GetSearchString().toUtf8());

                        SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::NotFound);

                    }

#endif

                    s_bFound = false;

                }

                else

                {

                    if (comphelper::LibreOfficeKit::isActive())

                        lcl_emitSearchResultCallbacks(s_pSrchItem, m_pWrtShell.get(), /* bHighlightAll = */ true);

                    if (!bQuiet)

                    {

                        OUString sText(SwResId(STR_SEARCH_KEY_FOUND_TIMES, nFound));

                        sText = sText.replaceFirst("%1", OUString::number(nFound));

                        SvxSearchDialogWrapper::SetSearchLabel(sText);

                    }

                }

                rReq.SetReturnValue(SfxBoolItem(nSlot, nFound != 0));

            }

            break;

            case SvxSearchCmd::REPLACE:

                {

                    // 1) Replace selection

                    // Prevent, that the replaced string will be found again

                    // if the replacement string is containing the search string.

                    bool bBack = s_pSrchItem->GetBackward();

                    if (bBack)

                        m_pWrtShell->Push();

                    OUString aReplace( s_pSrchItem->GetReplaceString() );

                    std::optional<OUString> xBackRef = sw::ReplaceBackReferences(

                        s_pSrchItem->GetSearchOptions(), m_pWrtShell->GetCursor(),

                        m_pWrtShell->GetLayout());

                    if( xBackRef )

                        s_pSrchItem->SetReplaceString( *xBackRef );

                    Replace();

                    if( xBackRef )

                    {

                        s_pSrchItem->SetReplaceString( aReplace );

                    }

                    if (bBack)

                    {

                        m_pWrtShell->Pop();

                        m_pWrtShell->SwapPam();

                    }

                    // 2) Search further (without replacing!)

                    SvxSearchCmd nOldCmd = s_pSrchItem->GetCommand();

                    s_pSrchItem->SetCommand( SvxSearchCmd::FIND );

                    bool bRet = SearchAndWrap(bQuiet);

                    if( bRet )

                        Scroll( m_pWrtShell->GetCharRect().SVRect());

                    s_pSrchItem->SetCommand( nOldCmd );

                    rReq.SetReturnValue(SfxBoolItem(nSlot, bRet));

                }

                break;

            case SvxSearchCmd::REPLACE_ALL:

                {

                    SwSearchOptions aOpts( m_pWrtShell.get(), s_pSrchItem->GetBackward() );

                    aOpts.eStart

                        = s_pSrchItem->GetBackward() ? SwDocPositions::End : SwDocPositions::Start;

                    s_bExtra = false;

                    sal_Int32 nFound;

                    {   //Scope for SwWait-Object

                        SwWait aWait( *GetDocShell(), true );

                        m_pWrtShell->StartAllAction();

                        // i#8288 "replace all" should not change cursor

                        // position, so save current cursor

                        m_pWrtShell->Push();

                        if (!s_pSrchItem->GetSelection())

                        {

                            // if we don't want to search in the selection...

                            m_pWrtShell->KillSelection(nullptr, false);

                            if (SwDocPositions::Start == aOpts.eEnd)

                            {

                                m_pWrtShell->EndOfSection();

                            }

                            else

                            {

                                m_pWrtShell->StartOfSection();

                            }

                        }

                        nFound = FUNC_Search( aOpts );

                        // create it just to overwrite it with stack cursor

                        m_pWrtShell->CreateCursor();

                        // i#8288 restore the original cursor position

                        m_pWrtShell->Pop(SwCursorShell::PopMode::DeleteCurrent);

                        m_pWrtShell->EndAllAction();

                    }

                    rReq.SetReturnValue(SfxBoolItem(nSlot, nFound != 0 && SAL_MAX_INT32 != nFound));

                    if( !nFound )

                    {

#if HAVE_FEATURE_DESKTOP

                        if( !bQuiet )

                        {

                            if (SfxViewShell* pNotifySh = m_pWrtShell->GetSfxViewShell())

                                pNotifySh->libreOfficeKitViewCallback(LOK_CALLBACK_SEARCH_NOT_FOUND, s_pSrchItem->GetSearchString().toUtf8());

                            SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::NotFound);

                        }

#endif

                        s_bFound = false;

                        SwView::SetMoveType(nMoveType);

                        return;

                    }

                    if (!bQuiet && SAL_MAX_INT32 != nFound)

                    {

                        OUString sText( SwResId( STR_NB_REPLACED ) );

                        sText = sText.replaceFirst("XX", OUString::number( nFound ));

                        SvxSearchDialogWrapper::SetSearchLabel(sText);

                    }

                }

                break;

            }

            uno::Reference< frame::XDispatchRecorder > xRecorder =

                    GetViewFrame().GetBindings().GetRecorder();

            //prevent additional dialogs in recorded macros

            if ( xRecorder.is() )

                rReq.AppendItem(SfxBoolItem(SID_SEARCH_QUIET, true));

            rReq.Done();

            m_eLastSearchCommand = s_pSrchItem->GetCommand();

            SwView::SetMoveType(nMoveType);

        }

        break;

        case FID_SEARCH_SEARCHSET:

        case FID_SEARCH_REPLACESET:

        {

            static const WhichRangesContainer aNormalAttr(svl::Items<

                RES_CHRATR_CASEMAP,     RES_CHRATR_CASEMAP,

                RES_CHRATR_COLOR,       RES_CHRATR_POSTURE,

                RES_CHRATR_SHADOWED,    RES_CHRATR_WORDLINEMODE,

                RES_CHRATR_BLINK,       RES_CHRATR_BLINK,

                RES_CHRATR_BACKGROUND,  RES_CHRATR_BACKGROUND,

                RES_CHRATR_ROTATE,      RES_CHRATR_ROTATE,

                RES_CHRATR_SCALEW,      RES_CHRATR_OVERLINE,

                RES_PARATR_LINESPACING, RES_PARATR_HYPHENZONE,

                RES_PARATR_REGISTER,    RES_PARATR_REGISTER,

                RES_PARATR_VERTALIGN,   RES_PARATR_VERTALIGN,

                RES_MARGIN_FIRSTLINE,   RES_MARGIN_RIGHT,

                RES_UL_SPACE,           RES_UL_SPACE,

                SID_ATTR_PARA_PAGEBREAK, SID_ATTR_PARA_PAGEBREAK,

                SID_ATTR_PARA_MODEL,    SID_ATTR_PARA_MODEL,

                SID_ATTR_PARA_KEEP,     SID_ATTR_PARA_KEEP

            >);

            SfxItemSet aSet(m_pWrtShell->GetAttrPool(), aNormalAttr);

            if( SvtCTLOptions::IsCTLFontEnabled() )

            {

                aSet.MergeRange(RES_CHRATR_CTL_FONT, RES_CHRATR_CTL_WEIGHT);

            }

            if( SvtCJKOptions::IsAnyEnabled() )

            {

                aSet.MergeRange(RES_CHRATR_CJK_FONT, RES_CHRATR_CJK_WEIGHT);

                aSet.MergeRange(RES_CHRATR_EMPHASIS_MARK, RES_CHRATR_TWO_LINES);

                aSet.MergeRange(RES_PARATR_SCRIPTSPACE, RES_PARATR_FORBIDDEN_RULES);

            }

            TypedWhichId<SvxSetItem> nWhich = SID_SEARCH_SEARCHSET;

            if ( FID_SEARCH_REPLACESET == nSlot )

            {

                nWhich = SID_SEARCH_REPLACESET;

                if ( s_xReplaceList )

                {

                    s_xReplaceList->Get( aSet );

                    s_xReplaceList.reset();

                }

            }

            else if ( s_xSearchList )

            {

                s_xSearchList->Get( aSet );

                s_xSearchList.reset();

            }

            rReq.SetReturnValue( SvxSetItem( nWhich, aSet ) );

        }

        break;

        default:

            SAL_WARN_IF( nSlot, "sw", "nSlot: " << nSlot << " wrong Dispatcher (viewsrch.cxx)" );

            return;

    }

}

bool SwView::SearchAndWrap(bool bApi)

{

    // tdf#124442 moved m_pWrtShell->GetCursor()->Normalize to before SwSearchOptions aOpts is

    // constructed to fix search key not found when a forward search (Find Next) results in a

    // unique find selection to the end of the document followed by a backward search (Find

    // Previous) or when a backward search results in a unique find selection to the start of the

    // document followed by a forward search. Unique find selection meaning the document

    // contains only one match of the search key.

    // fdo#65014 : Ensure that the point of the cursor is at the extremity of the

    // selection closest to the end being searched to as to exclude the selected

    // region from the search. (This doesn't work in the case of multiple

    // selected regions as the cursor doesn't mark the selection in that case.)

    m_pWrtShell->GetCursor()->Normalize( s_pSrchItem->GetBackward() );

    SwSearchOptions aOpts( m_pWrtShell.get(), s_pSrchItem->GetBackward() );

        // Remember starting position of the search for wraparound

        // Start- / EndAction perhaps because existing selections of 'search all'

    m_pWrtShell->StartAllAction();

    m_pWrtShell->Push();

    // After a search all action we place the cursor at the beginning of

    // the document so that the single search selects the first matching

    // occurrence in the document instead of the second.

    if( m_eLastSearchCommand == SvxSearchCmd::FIND_ALL )

    {

        if( SwDocPositions::Start == aOpts.eEnd )

            m_pWrtShell->EndOfSection();

        else

            m_pWrtShell->StartOfSection();

    }

    if (!s_pSrchItem->GetSelection())

    {

        // If you want to search in selected areas, they must not be unselected.

        m_pWrtShell->KillSelection(nullptr, false);

        if (s_pSrchItem->HasStartPoint())

        {

            // No selection -> but we have a start point (top left corner of the

            // current view), start searching from there, not from the current

            // cursor position.

            SwEditShell& rShell = GetWrtShell();

            Point aPosition(s_pSrchItem->GetStartPointX(), s_pSrchItem->GetStartPointY());

            rShell.SetCursor(aPosition);

        }

        else if (m_pWrtShell->GetCursor()->GetPointContentNode()

                 && lcl_IsNotTextSearch(s_pSrchItem))

        {

            // if already at the end then start at the next paragraph

            SwCursor* pCursor = m_pWrtShell->GetCursor();

            const sal_Int32 nIndex = pCursor->GetPoint()->GetContentIndex();

            const bool bToNextPara

                = s_pSrchItem->GetBackward()

                    ? !nIndex

                    : nIndex == pCursor->GetPointContentNode()->Len();

            if (bToNextPara)

            {

                SwMoveFnCollection const & fnMove

                    = s_pSrchItem->GetBackward() ? fnMoveBackward : fnMoveForward;

                if (!(*fnMove.fnPos)(pCursor->GetPoint(), false))

                {

                    if (s_pSrchItem->GetBackward())

                        m_pWrtShell->EndOfSection();

                    else

                        m_pWrtShell->StartOfSection();

                }

                else

                    pCursor->GetPoint()->SetContent(

                        s_pSrchItem->GetBackward() ? pCursor->GetPointContentNode()->Len() : 0);

            }

        }

    }

    std::optional<SwWait> oWait( std::in_place, *GetDocShell(), true );

    if( FUNC_Search( aOpts ) )

    {

        s_bFound = true;

        if(m_pWrtShell->IsSelFrameMode())

        {

            m_pWrtShell->Push(); // push the 'found' cursor to the stack

            m_pWrtShell->UnSelectFrame();

            m_pWrtShell->LeaveSelFrameMode();

            m_pWrtShell->Pop(SwCursorShell::PopMode::DeleteCurrent); // restore stack cursor

        }

        m_pWrtShell->Pop();

        m_pWrtShell->EndAllAction();

        return true;

    }

    oWait.reset();

        // Search in the specialized areas when no search is present in selections.

        // When searching selections they will already be searched in these special areas.

    bool bHasSrchInOther = s_bExtra;

    if (!s_pSrchItem->GetSelection() && !s_bExtra )

    {

        s_bExtra = true;

        if( FUNC_Search( aOpts ) )

        {

            s_bFound = true;

            m_pWrtShell->Pop();

            m_pWrtShell->EndAllAction();

            return true;

        }

        s_bExtra = false;

    }

    else

        s_bExtra = !s_bExtra;

        // If starting position is at the end or beginning of the document.

    if (aOpts.bDontWrap)

    {

        m_pWrtShell->EndAllAction();

        if( !bApi )

        {

#if HAVE_FEATURE_DESKTOP

            if (SfxViewShell* pNotifySh = m_pWrtShell->GetSfxViewShell())

                pNotifySh->libreOfficeKitViewCallback(LOK_CALLBACK_SEARCH_NOT_FOUND, s_pSrchItem->GetSearchString().toUtf8());

            SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::NotFound);

#endif

        }

        s_bFound = false;

        m_pWrtShell->Pop();

        return false;

    }

    m_pWrtShell->EndAllAction();

        // Try again with WrapAround?

    m_pWrtShell->StartAllAction();

    m_pWrtShell->Pop(SwCursorShell::PopMode::DeleteCurrent);

    oWait.emplace( *GetDocShell(), true );

    bool bSrchBkwrd = SwDocPositions::Start == aOpts.eEnd;

    aOpts.eEnd =  bSrchBkwrd ? SwDocPositions::Start : SwDocPositions::End;

    aOpts.eStart = bSrchBkwrd ? SwDocPositions::End : SwDocPositions::Start;

    if (bHasSrchInOther)

    {

        m_pWrtShell->ClearMark();

        // Select the start or the end of the entire document

        if (bSrchBkwrd)

            m_pWrtShell->SttEndDoc(false);

        else

            m_pWrtShell->SttEndDoc(true);

    }

    s_bFound = bool(FUNC_Search( aOpts ));

    // If WrapAround found no matches in the body text, search in the special

    // sections, too.

    if (!s_bFound && !s_pSrchItem->GetSelection() && !s_bExtra)

    {

        s_bExtra = true;

        if (FUNC_Search(aOpts))

            s_bFound = true;

        else

            s_bExtra = false;

    }

    m_pWrtShell->EndAllAction();

    oWait.reset();

#if HAVE_FEATURE_DESKTOP

    if (s_bFound)

    {

        if (!bSrchBkwrd)

            SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::End);

        else

            SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::Start);

    }

    else if(!bApi)

    {

        if (SfxViewShell* pNotifySh = m_pWrtShell->GetSfxViewShell())

            pNotifySh->libreOfficeKitViewCallback(LOK_CALLBACK_SEARCH_NOT_FOUND, s_pSrchItem->GetSearchString().toUtf8());

        SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::NotFound);

    }

#endif

    return s_bFound;

}

sal_Int32 SwView::SearchAll()

{

    SwWait aWait( *GetDocShell(), true );

    m_pWrtShell->StartAllAction();

    SwSearchOptions aOpts( m_pWrtShell.get(), s_pSrchItem->GetBackward() );

    aOpts.eStart = s_pSrchItem->GetBackward() ? SwDocPositions::End : SwDocPositions::Start;

    if (!s_pSrchItem->GetSelection())

    {

        // Cancel existing selections, if should not be sought in selected areas.

        m_pWrtShell->KillSelection(nullptr, false);

        if( SwDocPositions::Start == aOpts.eEnd )

            m_pWrtShell->EndOfSection();

        else

            m_pWrtShell->StartOfSection();

    }

    s_bExtra = false;

    auto nFound = FUNC_Search(aOpts);

    s_bFound = 0 != nFound;

    m_pWrtShell->EndAllAction();

    return nFound;

}

void SwView::Replace()

{

    SwWait aWait( *GetDocShell(), true );

    m_pWrtShell->StartAllAction();

    const bool bReplaceParagraphStyle = s_pSrchItem->GetPattern();

    if (!bReplaceParagraphStyle && GetPostItMgr()->HasActiveSidebarWin())

        GetPostItMgr()->Replace(s_pSrchItem);

    bool bReqReplace = true;

    if (m_pWrtShell->HasSelection())

    {

        /* check that the selection match the search string */

        //save state

        SwPosition aStartPos = *m_pWrtShell->GetCursor()->Start();

        SwPosition aEndPos = *m_pWrtShell->GetCursor()->End();

        const bool bHasSelection = s_pSrchItem->GetSelection();

        const SvxSearchCmd nOldCmd = s_pSrchItem->GetCommand();

        //set state for checking if current selection has a match

        s_pSrchItem->SetCommand(SvxSearchCmd::FIND);

        s_pSrchItem->SetSelection(true);

        //check if it matches

        SwSearchOptions aOpts(m_pWrtShell.get(), s_pSrchItem->GetBackward());

        if (!FUNC_Search(aOpts))

        {

            // no matching therefore should not replace selection

            // => remove selection

            if (!s_pSrchItem->GetBackward())

            {

                (*m_pWrtShell->GetCursor()->Start()) = std::move(aStartPos);

                (*m_pWrtShell->GetCursor()->End()) = std::move(aEndPos);

            }

            else

            {

                (*m_pWrtShell->GetCursor()->Start()) = std::move(aEndPos);

                (*m_pWrtShell->GetCursor()->End()) = std::move(aStartPos);

            }

            bReqReplace = false;

        }

        // set back old search state

        s_pSrchItem->SetCommand(nOldCmd);

        s_pSrchItem->SetSelection(bHasSelection);

    }

    /*

        * remove current selection

        * otherwise it is always replaced

        * no matter if the search string exists or not in the selection

        * Now the selection is removed and the next matching string is selected

        */

    if (bReqReplace)

    {

        if (bReplaceParagraphStyle)

        {

            SwRewriter aRewriter;

            aRewriter.AddRule(UndoArg1, s_pSrchItem->GetSearchString());

            aRewriter.AddRule(UndoArg2, SwResId(STR_YIELDS));

            aRewriter.AddRule(UndoArg3, s_pSrchItem->GetReplaceString());

            m_pWrtShell->StartUndo(SwUndoId::UI_REPLACE_STYLE, &aRewriter);

            m_pWrtShell->SetTextFormatColl(m_pWrtShell->GetParaStyle(

                UIName(s_pSrchItem->GetReplaceString()), SwWrtShell::GETSTYLE_CREATESOME));

            m_pWrtShell->EndUndo();

        }

        else

        {

            bool bReplaced = true;

            // Replace selection (Not if only attributes should be replaced)

            if (!s_pSrchItem->GetReplaceString().isEmpty() || !s_xReplaceList)

            {

                bReplaced = m_pWrtShell->SwEditShell::Replace( s_pSrchItem->GetReplaceString(),

                                                               s_pSrchItem->GetRegExp() );

            }

            // Replace attributes

            if( bReplaced && s_xReplaceList && s_xReplaceList->Count() && m_pWrtShell->HasSelection() )

            {

                SfxItemSet aReplSet( m_pWrtShell->GetAttrPool(),

                                     aTextFormatCollSetRange );

                if( s_xReplaceList->Get( aReplSet ).Count() )

                    m_pWrtShell->SwEditShell::SetAttrSet( aReplSet );

            }

        }

    }

    m_pWrtShell->EndAllAction();

}

SwSearchOptions::SwSearchOptions( SwWrtShell const * pSh, bool bBackward )

   : eStart(SwDocPositions::Curr)

{

    if( bBackward )

    {

        eEnd = SwDocPositions::Start;

        bDontWrap = pSh->IsEndOfDoc();

    }

    else

    {

        eEnd = SwDocPositions::End;

        bDontWrap = pSh->IsStartOfDoc();

    }

}

sal_Int32 SwView::FUNC_Search(const SwSearchOptions& rOptions)

{

#if HAVE_FEATURE_DESKTOP

    SvxSearchDialogWrapper::SetSearchLabel(SearchLabel::Empty);

#endif

    bool bDoReplace = s_pSrchItem->GetCommand() == SvxSearchCmd::REPLACE ||

                      s_pSrchItem->GetCommand() == SvxSearchCmd::REPLACE_ALL;

    FindRanges eRanges = s_pSrchItem->GetSelection()

                        ? FindRanges::InSel

                        : s_bExtra

                          ? FindRanges::InOther : FindRanges::InBody;

    if (s_pSrchItem->GetCommand() == SvxSearchCmd::FIND_ALL    ||

        s_pSrchItem->GetCommand() == SvxSearchCmd::REPLACE_ALL)

        eRanges |= FindRanges::InSelAll;

    m_pWrtShell->SttSelect();

    static const WhichRangesContainer aSearchAttrRange(svl::Items<

        RES_CHRATR_BEGIN, RES_CHRATR_END-1,

        RES_PARATR_BEGIN, RES_PARATR_END-1,

        RES_FRMATR_BEGIN, RES_FRMATR_END-1,

        SID_ATTR_PARA_PAGEBREAK, SID_ATTR_PARA_PAGEBREAK,

        SID_ATTR_PARA_MODEL, SID_ATTR_PARA_MODEL, // page style

        SID_ATTR_PARA_KEEP, SID_ATTR_PARA_KEEP

        >);

    SfxItemSet aSrchSet( m_pWrtShell->GetAttrPool(), aSearchAttrRange);

    if( s_xSearchList && s_xSearchList->Count() )

    {

        s_xSearchList->Get( aSrchSet );

        // create Sw Page Style from Sfx Page Style

        ::SfxToSwPageDescAttr(*m_pWrtShell, aSrchSet);

    }

    std::optional<SfxItemSet> xReplSet;

    if (bDoReplace)

    {

        // tdf#99672 - create empty replace set to check for replacements in SwCursor::FindAttrs

        xReplSet.emplace(m_pWrtShell->GetAttrPool(), aSearchAttrRange);

        if (s_xReplaceList && s_xReplaceList->Count())

        {

            s_xReplaceList->Get( *xReplSet );

            if( !xReplSet->Count() )        // too bad, we don't know

                xReplSet.reset();        // the attributes

        }

    }

    // build SearchOptions to be used

    i18nutil::SearchOptions2 aSearchOpt( s_pSrchItem->GetSearchOptions() );

    aSearchOpt.Locale = GetAppLanguageTag().getLocale();

    if( !bDoReplace )

        aSearchOpt.replaceString.clear();

    sal_Int32 nFound;

    if( aSrchSet.Count() || ( xReplSet && xReplSet->Count() ))

    {

        nFound = m_pWrtShell->SearchAttr(

            aSrchSet,

            !s_pSrchItem->GetPattern(),

            rOptions.eStart,

            rOptions.eEnd,

            eRanges,

            !s_pSrchItem->GetSearchString().isEmpty() ? &aSearchOpt : nullptr,

            xReplSet ? &*xReplSet : nullptr );

    }

    else if( s_pSrchItem->GetPattern() )

    {

        // Searching (and replacing) templates

        const UIName sRplStr( s_pSrchItem->GetReplaceString() );