/* -*- 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 <sal/macros.h>

#include <com/sun/star/beans/XPropertySet.hpp>

#include <com/sun/star/container/ElementExistException.hpp>

#include <com/sun/star/container/XNameAccess.hpp>

#include <com/sun/star/configuration/theDefaultProvider.hpp>

#include <com/sun/star/i18n/BreakIterator.hpp>

#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>

#include <com/sun/star/lang/XComponent.hpp>

#include <com/sun/star/lang/XServiceInfo.hpp>

#include <com/sun/star/lang/XMultiServiceFactory.hpp>

#include <com/sun/star/linguistic2/XDictionary.hpp>

#include <com/sun/star/linguistic2/XSupportedLocales.hpp>

#include <com/sun/star/linguistic2/XProofreader.hpp>

#include <com/sun/star/linguistic2/XProofreadingIterator.hpp>

#include <com/sun/star/linguistic2/SingleProofreadingError.hpp>

#include <com/sun/star/linguistic2/ProofreadingResult.hpp>

#include <com/sun/star/linguistic2/LinguServiceEvent.hpp>

#include <com/sun/star/linguistic2/LinguServiceEventFlags.hpp>

#include <com/sun/star/text/TextMarkupType.hpp>

#include <com/sun/star/text/TextMarkupDescriptor.hpp>

#include <com/sun/star/text/XMultiTextMarkup.hpp>

#include <com/sun/star/text/XFlatParagraph.hpp>

#include <com/sun/star/text/XFlatParagraphIterator.hpp>

#include <com/sun/star/uno/XComponentContext.hpp>

#include <sal/config.h>

#include <sal/log.hxx>

#include <o3tl/safeint.hxx>

#include <osl/conditn.hxx>

#include <cppuhelper/supportsservice.hxx>

#include <cppuhelper/weak.hxx>

#include <i18nlangtag/languagetag.hxx>

#include <comphelper/processfactory.hxx>

#include <comphelper/propertysequence.hxx>

#include <tools/debug.hxx>

#include <comphelper/diagnose_ex.hxx>

#include <map>

#include <algorithm>

#include <linguistic/misc.hxx>

#include "gciterator.hxx"

using namespace linguistic;

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

// white space list: obtained from the fonts.config.txt of a Linux system.

const sal_Unicode aWhiteSpaces[] =

{

    0x0020,   /* SPACE */

    0x00a0,   /* NO-BREAK SPACE */

    0x00ad,   /* SOFT HYPHEN */

    0x115f,   /* HANGUL CHOSEONG FILLER */

    0x1160,   /* HANGUL JUNGSEONG FILLER */

    0x1680,   /* OGHAM SPACE MARK */

    0x2000,   /* EN QUAD */

    0x2001,   /* EM QUAD */

    0x2002,   /* EN SPACE */

    0x2003,   /* EM SPACE */

    0x2004,   /* THREE-PER-EM SPACE */

    0x2005,   /* FOUR-PER-EM SPACE */

    0x2006,   /* SIX-PER-EM SPACE */

    0x2007,   /* FIGURE SPACE */

    0x2008,   /* PUNCTUATION SPACE */

    0x2009,   /* THIN SPACE */

    0x200a,   /* HAIR SPACE */

    0x200b,   /* ZERO WIDTH SPACE */

    0x200c,   /* ZERO WIDTH NON-JOINER */

    0x200d,   /* ZERO WIDTH JOINER */

    0x200e,   /* LEFT-TO-RIGHT MARK */

    0x200f,   /* RIGHT-TO-LEFT MARK */

    0x2028,   /* LINE SEPARATOR */

    0x2029,   /* PARAGRAPH SEPARATOR */

    0x202a,   /* LEFT-TO-RIGHT EMBEDDING */

    0x202b,   /* RIGHT-TO-LEFT EMBEDDING */

    0x202c,   /* POP DIRECTIONAL FORMATTING */

    0x202d,   /* LEFT-TO-RIGHT OVERRIDE */

    0x202e,   /* RIGHT-TO-LEFT OVERRIDE */

    0x202f,   /* NARROW NO-BREAK SPACE */

    0x205f,   /* MEDIUM MATHEMATICAL SPACE */

    0x2060,   /* WORD JOINER */

    0x2061,   /* FUNCTION APPLICATION */

    0x2062,   /* INVISIBLE TIMES */

    0x2063,   /* INVISIBLE SEPARATOR */

    0x206A,   /* INHIBIT SYMMETRIC SWAPPING */

    0x206B,   /* ACTIVATE SYMMETRIC SWAPPING */

    0x206C,   /* INHIBIT ARABIC FORM SHAPING */

    0x206D,   /* ACTIVATE ARABIC FORM SHAPING */

    0x206E,   /* NATIONAL DIGIT SHAPES */

    0x206F,   /* NOMINAL DIGIT SHAPES */

    0x3000,   /* IDEOGRAPHIC SPACE */

    0x3164,   /* HANGUL FILLER */

    0xfeff,   /* ZERO WIDTH NO-BREAK SPACE */

    0xffa0,   /* HALFWIDTH HANGUL FILLER */

    0xfff9,   /* INTERLINEAR ANNOTATION ANCHOR */

    0xfffa,   /* INTERLINEAR ANNOTATION SEPARATOR */

    0xfffb    /* INTERLINEAR ANNOTATION TERMINATOR */

};

//  Information about reason for proofreading (ProofInfo)

   const sal_Int32 PROOFINFO_GET_PROOFRESULT = 1;

   const sal_Int32 PROOFINFO_MARK_PARAGRAPH = 2;

static bool lcl_IsWhiteSpace( sal_Unicode cChar )

{

    return std::any_of(std::begin(aWhiteSpaces), std::end(aWhiteSpaces),

        [&cChar](const sal_Unicode c) { return c == cChar; });

}

static sal_Int32 lcl_SkipWhiteSpaces( const OUString &rText, sal_Int32 nStartPos )

{

    // note having nStartPos point right behind the string is OK since that one

    // is a correct end-of-sentence position to be returned from a grammar checker...

    const sal_Int32 nLen = rText.getLength();

    bool bIllegalArgument = false;

    if (nStartPos < 0)

    {

        bIllegalArgument = true;

        nStartPos = 0;

    }

    if (nStartPos > nLen)

    {

        bIllegalArgument = true;

        nStartPos = nLen;

    }

    if (bIllegalArgument)

    {

        SAL_WARN( "linguistic", "lcl_SkipWhiteSpaces: illegal arguments" );

    }

    sal_Int32 nRes = nStartPos;

    if (0 <= nStartPos && nStartPos < nLen)

    {

        const sal_Unicode* const pEnd = rText.getStr() + nLen;

        const sal_Unicode *pText = rText.getStr() + nStartPos;

        while (pText != pEnd && lcl_IsWhiteSpace(*pText))

            ++pText;

        nRes = pText - rText.getStr();

    }

    DBG_ASSERT( 0 <= nRes && nRes <= nLen, "lcl_SkipWhiteSpaces return value out of range" );

    return nRes;

}

static sal_Int32 lcl_BacktraceWhiteSpaces( const OUString &rText, sal_Int32 nStartPos )

{

    // note: having nStartPos point right behind the string is OK since that one

    // is a correct end-of-sentence position to be returned from a grammar checker...

    const sal_Int32 nLen = rText.getLength();

    bool bIllegalArgument = false;

    if (nStartPos < 0)

    {

        bIllegalArgument = true;

        nStartPos = 0;

    }

    if (nStartPos > nLen)

    {

        bIllegalArgument = true;

        nStartPos = nLen;

    }

    if (bIllegalArgument)

    {

        SAL_WARN( "linguistic", "lcl_BacktraceWhiteSpaces: illegal arguments" );

    }

    sal_Int32 nRes = nStartPos;

    sal_Int32 nPosBefore = nStartPos - 1;

    const sal_Unicode *pStart = rText.getStr();

    if (0 <= nPosBefore && nPosBefore < nLen && lcl_IsWhiteSpace( pStart[ nPosBefore ] ))

    {

        nStartPos = nPosBefore;

        const sal_Unicode *pText = rText.getStr() + nStartPos;

        while (pText > pStart && lcl_IsWhiteSpace( *pText ))

            --pText;

        // now add 1 since we want to point to the first char after the last char in the sentence...

        nRes = pText - pStart + 1;

    }

    DBG_ASSERT( 0 <= nRes && nRes <= nLen, "lcl_BacktraceWhiteSpaces return value out of range" );

    return nRes;

}

extern "C" {

static void lcl_workerfunc (void * gci)

{

    osl_setThreadName("GrammarCheckingIterator");

    static_cast<GrammarCheckingIterator*>(gci)->DequeueAndCheck();

}

}

static lang::Locale lcl_GetPrimaryLanguageOfSentence(

    const uno::Reference< text::XFlatParagraph >& xFlatPara,

    sal_Int32 nStartIndex )

{

    //get the language of the first word

    return xFlatPara->getLanguageOfText( nStartIndex, 1 );

}

LngXStringKeyMap::LngXStringKeyMap() {}

void SAL_CALL LngXStringKeyMap::insertValue(const OUString& aKey, const css::uno::Any& aValue)

{

    std::map<OUString, css::uno::Any>::const_iterator aIter = maMap.find(aKey);

    if (aIter != maMap.end())

        throw css::container::ElementExistException();

    maMap[aKey] = aValue;

}

css::uno::Any SAL_CALL LngXStringKeyMap::getValue(const OUString& aKey)

{

    std::map<OUString, css::uno::Any>::const_iterator aIter = maMap.find(aKey);

    if (aIter == maMap.end())

        throw css::container::NoSuchElementException();

    return (*aIter).second;

}

sal_Bool SAL_CALL LngXStringKeyMap::hasValue(const OUString& aKey)

{

    return maMap.contains(aKey);

}

::sal_Int32 SAL_CALL LngXStringKeyMap::getCount() { return maMap.size(); }

OUString SAL_CALL LngXStringKeyMap::getKeyByIndex(::sal_Int32 nIndex)

{

    if (nIndex < 0 || o3tl::make_unsigned(nIndex) >= maMap.size())

        throw css::lang::IndexOutOfBoundsException();

    return OUString();

}

css::uno::Any SAL_CALL LngXStringKeyMap::getValueByIndex(::sal_Int32 nIndex)

{

    if (nIndex < 0 || o3tl::make_unsigned(nIndex) >= maMap.size())

        throw css::lang::IndexOutOfBoundsException();

    return css::uno::Any();

}

osl::Mutex& GrammarCheckingIterator::MyMutex()

{

    static osl::Mutex SINGLETON;

    return SINGLETON;

}

GrammarCheckingIterator::GrammarCheckingIterator() :

    m_bEnd( false ),

    m_bGCServicesChecked( false ),

    m_nDocIdCounter( 0 ),

    m_thread(nullptr),

    m_aEventListeners( MyMutex() ),

    m_aNotifyListeners( MyMutex() )

{

}

GrammarCheckingIterator::~GrammarCheckingIterator()

{

    TerminateThread();

}

void GrammarCheckingIterator::TerminateThread()

{

    oslThread t;

    {

        ::osl::Guard< ::osl::Mutex > aGuard( MyMutex() );

        t = m_thread;

        m_thread = nullptr;

        m_bEnd = true;

        m_aWakeUpThread.set();

    }

    if (t != nullptr)

    {

        osl_joinWithThread(t);

        osl_destroyThread(t);

    }

    // After m_bEnd was used to flag lcl_workerfunc to quit, now

    // reset it so lcl_workerfunc could be relaunched later.

    {

        ::osl::Guard< ::osl::Mutex > aGuard( MyMutex() );

        m_bEnd = false;

    }

}

bool GrammarCheckingIterator::joinThreads()

{

    TerminateThread();

    return true;

}

sal_Int32 GrammarCheckingIterator::NextDocId()

{

    ::osl::Guard< ::osl::Mutex > aGuard( MyMutex() );

    m_nDocIdCounter += 1;

    return m_nDocIdCounter;

}

OUString GrammarCheckingIterator::GetOrCreateDocId(

    const uno::Reference< lang::XComponent > &xComponent )

{

    // internal method; will always be called with locked mutex

    OUString aRes;

    if (xComponent.is())

    {

        if (m_aDocIdMap.contains( xComponent.get() ))

        {

            // return already existing entry

            aRes = m_aDocIdMap[ xComponent.get() ];

        }

        else // add new entry

        {

            sal_Int32 nRes = NextDocId();

            aRes = OUString::number( nRes );

            m_aDocIdMap[ xComponent.get() ] = aRes;

            xComponent->addEventListener( this );

        }

    }

    return aRes;

}

void GrammarCheckingIterator::AddEntry(

    const uno::Reference< text::XFlatParagraphIterator >& xFlatParaIterator,

    const uno::Reference< text::XFlatParagraph >& xFlatPara,

    const OUString & rDocId,

    sal_Int32 nStartIndex,

    bool bAutomatic )

{

    // we may not need/have a xFlatParaIterator (e.g. if checkGrammarAtPos was called)

    // but we always need a xFlatPara...

    if (!xFlatPara.is())

        return;

    FPEntry aNewFPEntry;

    aNewFPEntry.m_xParaIterator = xFlatParaIterator;

    aNewFPEntry.m_xPara         = xFlatPara;

    aNewFPEntry.m_aDocId        = rDocId;

    aNewFPEntry.m_nStartIndex   = nStartIndex;

    aNewFPEntry.m_bAutomatic    = bAutomatic;

    // add new entry to the end of this queue

    ::osl::Guard< ::osl::Mutex > aGuard( MyMutex() );

    if (!m_thread)

        m_thread = osl_createThread( lcl_workerfunc, this );

    m_aFPEntriesQueue.push_back( aNewFPEntry );

    // wake up the thread in order to do grammar checking

    m_aWakeUpThread.set();

}

void GrammarCheckingIterator::ProcessResult(

    const linguistic2::ProofreadingResult &rRes,

    const uno::Reference< text::XFlatParagraphIterator > &rxFlatParagraphIterator,

    bool bIsAutomaticChecking )

{

    DBG_ASSERT( rRes.xFlatParagraph.is(), "xFlatParagraph is missing" );

     //no guard necessary as no members are used

    bool bContinueWithNextPara = false;

    if (!rRes.xFlatParagraph.is() || rRes.xFlatParagraph->isModified())

    {

        // if paragraph was modified/deleted meanwhile continue with the next one...

        bContinueWithNextPara = true;

    }

    else    // paragraph is still unchanged...

    {

        // mark found errors...

        sal_Int32 nTextLen = rRes.aText.getLength();

        bool bBoundariesOk = 0 <= rRes.nStartOfSentencePosition     && rRes.nStartOfSentencePosition <= nTextLen &&

                             0 <= rRes.nBehindEndOfSentencePosition && rRes.nBehindEndOfSentencePosition <= nTextLen &&

                             0 <= rRes.nStartOfNextSentencePosition && rRes.nStartOfNextSentencePosition <= nTextLen &&

                             rRes.nStartOfSentencePosition      <= rRes.nBehindEndOfSentencePosition &&

                             rRes.nBehindEndOfSentencePosition  <= rRes.nStartOfNextSentencePosition;

        DBG_ASSERT( bBoundariesOk, "inconsistent sentence boundaries" );

        uno::Reference< text::XMultiTextMarkup > xMulti( rRes.xFlatParagraph, uno::UNO_QUERY );

        if (xMulti.is())    // use new API for markups

        {

            try

            {

                // length = number of found errors + 1 sentence markup

                sal_Int32 nErrors = rRes.aErrors.getLength();

                uno::Sequence< text::TextMarkupDescriptor > aDescriptors( nErrors + 1 );

                text::TextMarkupDescriptor * pDescriptors = aDescriptors.getArray();

                uno::Reference< linguistic2::XDictionary > xIgnoreAll = ::GetIgnoreAllList();

                sal_Int32 ignoredCount = 0;

                // at pos 0 .. nErrors-1 -> all grammar errors

                for (const linguistic2::SingleProofreadingError &rError : rRes.aErrors)

                {

                    OUString word(rRes.aText.subView(rError.nErrorStart, rError.nErrorLength));

                    bool ignored = xIgnoreAll.is() && xIgnoreAll->getEntry(word).is();

                    if (!ignored)

                    {

                        text::TextMarkupDescriptor &rDesc = *pDescriptors++;

                        rDesc.nType   = rError.nErrorType;

                        rDesc.nOffset = rError.nErrorStart;

                        rDesc.nLength = rError.nErrorLength;

                        // the proofreader may return SPELLING but right now our core

                        // does only handle PROOFREADING if the result is from the proofreader...

                        // (later on we may wish to color spelling errors found by the proofreader

                        // differently for example. But no special handling right now.

                        if (rDesc.nType == text::TextMarkupType::SPELLCHECK)

                            rDesc.nType = text::TextMarkupType::PROOFREADING;

                        uno::Reference< container::XStringKeyMap > xKeyMap(new LngXStringKeyMap());

                        for( const beans::PropertyValue& rProperty : rError.aProperties )

                        {

                            if ( rProperty.Name == "LineColor" )

                            {

                                xKeyMap->insertValue(rProperty.Name, rProperty.Value);

                                rDesc.xMarkupInfoContainer = xKeyMap;

                            }

                            else if ( rProperty.Name == "LineType" )

                            {

                                xKeyMap->insertValue(rProperty.Name, rProperty.Value);

                                rDesc.xMarkupInfoContainer = xKeyMap;

                            }

                        }

                    }

                    else

                        ignoredCount++;

                }

                if (ignoredCount != 0)

                {

                    aDescriptors.realloc(aDescriptors.getLength() - ignoredCount);

                    pDescriptors = aDescriptors.getArray();

                    pDescriptors += aDescriptors.getLength() - 1;

                }

                // at pos nErrors -> sentence markup

                // nSentenceLength: includes the white-spaces following the sentence end...

                const sal_Int32 nSentenceLength = rRes.nStartOfNextSentencePosition - rRes.nStartOfSentencePosition;

                pDescriptors->nType   = text::TextMarkupType::SENTENCE;

                pDescriptors->nOffset = rRes.nStartOfSentencePosition;

                pDescriptors->nLength = nSentenceLength;

                xMulti->commitMultiTextMarkup( aDescriptors ) ;

            }

            catch (lang::IllegalArgumentException &)

            {

                TOOLS_WARN_EXCEPTION( "linguistic", "commitMultiTextMarkup" );

            }

        }

        // other sentences left to be checked in this paragraph?

        if (rRes.nStartOfNextSentencePosition < rRes.aText.getLength())

        {

            AddEntry( rxFlatParagraphIterator, rRes.xFlatParagraph, rRes.aDocumentIdentifier, rRes.nStartOfNextSentencePosition, bIsAutomaticChecking );

        }

        else    // current paragraph finished

        {

            // set "already checked" flag for the current flat paragraph

            if (rRes.xFlatParagraph.is())

                rRes.xFlatParagraph->setChecked( text::TextMarkupType::PROOFREADING, true );

            bContinueWithNextPara = true;

        }

    }

    if (bContinueWithNextPara)

    {

        // we need to continue with the next paragraph

        if (rxFlatParagraphIterator.is())

            AddEntry(rxFlatParagraphIterator, rxFlatParagraphIterator->getNextPara(),

                     rRes.aDocumentIdentifier, 0, bIsAutomaticChecking);

    }

}

std::pair<OUString, std::optional<OUString>>

GrammarCheckingIterator::getServiceForLocale(const lang::Locale& rLocale) const

{

    if (!rLocale.Language.isEmpty())

    {

        const OUString sBcp47 = LanguageTag::convertToBcp47(rLocale, false);

        GCImplNames_t::const_iterator aLangIt(m_aGCImplNamesByLang.find(sBcp47));

        if (aLangIt != m_aGCImplNamesByLang.end())

            return { aLangIt->second, {} };

        for (const auto& sFallbackBcp47 : LanguageTag(rLocale).getFallbackStrings(false))

        {

            aLangIt = m_aGCImplNamesByLang.find(sFallbackBcp47);

            if (aLangIt != m_aGCImplNamesByLang.end())

                return { aLangIt->second, sFallbackBcp47 };

        }

    }

    return {};

}

uno::Reference< linguistic2::XProofreader > GrammarCheckingIterator::GetGrammarChecker(

    lang::Locale &rLocale )

{

    uno::Reference< linguistic2::XProofreader > xRes;

    // ---- THREAD SAFE START ----

    ::osl::Guard< ::osl::Mutex > aGuard( MyMutex() );

    // check supported locales for each grammarchecker if not already done

    if (!m_bGCServicesChecked)

    {

        GetConfiguredGCSvcs_Impl();

        m_bGCServicesChecked = true;

    }

    if (const auto [aSvcImplName, oFallbackBcp47] = getServiceForLocale(rLocale);

        !aSvcImplName.isEmpty()) // matching configured language found?

    {

        if (oFallbackBcp47)

            rLocale = LanguageTag::convertToLocale(*oFallbackBcp47, false);

        GCReferences_t::const_iterator aImplNameIt( m_aGCReferencesByService.find( aSvcImplName ) );

        if (aImplNameIt != m_aGCReferencesByService.end())  // matching impl name found?

        {

            xRes = aImplNameIt->second;

        }

        else    // the service is to be instantiated here for the first time...

        {

            try

            {

                const uno::Reference< uno::XComponentContext >& xContext( comphelper::getProcessComponentContext() );

                uno::Reference< linguistic2::XProofreader > xGC(

                        xContext->getServiceManager()->createInstanceWithContext(aSvcImplName, xContext),

                        uno::UNO_QUERY_THROW );

                uno::Reference< linguistic2::XSupportedLocales > xSuppLoc( xGC, uno::UNO_QUERY_THROW );

                if (xSuppLoc->hasLocale( rLocale ))

                {

                    m_aGCReferencesByService[ aSvcImplName ] = xGC;

                    xRes = xGC;

                    uno::Reference< linguistic2::XLinguServiceEventBroadcaster > xBC( xGC, uno::UNO_QUERY );

                    if (xBC.is())

                        xBC->addLinguServiceEventListener( this );

                }

                else

                {

                    SAL_WARN( "linguistic", "grammar checker does not support required locale" );

                }

            }

            catch (uno::Exception &)

            {

                SAL_WARN( "linguistic", "instantiating grammar checker failed" );

            }

        }

    }

    else // not found - quite normal

    {

        SAL_INFO("linguistic", "No grammar checker found for \""

                                   << LanguageTag::convertToBcp47(rLocale, false) << "\"");

    }

    // ---- THREAD SAFE END ----

    return xRes;

}

static uno::Sequence<beans::PropertyValue>

lcl_makeProperties(uno::Reference<text::XFlatParagraph> const& xFlatPara, sal_Int32 nProofInfo)

{

    uno::Reference<beans::XPropertySet> const xProps(

            xFlatPara, uno::UNO_QUERY_THROW);

    css::uno::Any a (nProofInfo);

    return comphelper::InitPropertySequence({

        { "FieldPositions", xProps->getPropertyValue(u"FieldPositions"_ustr) },

        { "FootnotePositions", xProps->getPropertyValue(u"FootnotePositions"_ustr) },

        { "SortedTextId", xProps->getPropertyValue(u"SortedTextId"_ustr) },

        { "DocumentElementsCount", xProps->getPropertyValue(u"DocumentElementsCount"_ustr) },

        { "ProofInfo", a }

    });

}

void GrammarCheckingIterator::DequeueAndCheck()

{

    for (;;)

    {

        // ---- THREAD SAFE START ----

        bool bQueueEmpty = false;

        {

            ::osl::Guard< ::osl::Mutex > aGuard( MyMutex() );

            if (m_bEnd)

            {

                break;

            }

            bQueueEmpty = m_aFPEntriesQueue.empty();

        }

        // ---- THREAD SAFE END ----

        if (!bQueueEmpty)

        {

            uno::Reference< text::XFlatParagraphIterator > xFPIterator;

            uno::Reference< text::XFlatParagraph > xFlatPara;

            FPEntry aFPEntryItem;

            OUString aCurDocId;

            // ---- THREAD SAFE START ----

            {

                ::osl::Guard< ::osl::Mutex > aGuard( MyMutex() );

                aFPEntryItem        = m_aFPEntriesQueue.front();

                xFPIterator         = aFPEntryItem.m_xParaIterator;

                xFlatPara           = aFPEntryItem.m_xPara;

                m_aCurCheckedDocId  = aFPEntryItem.m_aDocId;

                aCurDocId = m_aCurCheckedDocId;

                m_aFPEntriesQueue.pop_front();

            }

            // ---- THREAD SAFE END ----

            if (xFlatPara.is() && xFPIterator.is())

            {

                try

                {

                    OUString aCurTxt( xFlatPara->getText() );

                    lang::Locale aCurLocale = lcl_GetPrimaryLanguageOfSentence( xFlatPara, aFPEntryItem.m_nStartIndex );

                    const bool bModified = xFlatPara->isModified();

                    if (!bModified)

                    {

                        linguistic2::ProofreadingResult aRes;

                        // ---- THREAD SAFE START ----

                        {

                            osl::ClearableMutexGuard aGuard(MyMutex());

                            sal_Int32 nStartPos = aFPEntryItem.m_nStartIndex;

                            sal_Int32 nSuggestedEnd

                                = GetSuggestedEndOfSentence(aCurTxt, nStartPos, aCurLocale);

                            DBG_ASSERT((nSuggestedEnd == 0 && aCurTxt.isEmpty())

                                           || nSuggestedEnd > nStartPos,

                                       "nSuggestedEndOfSentencePos calculation failed?");

                            uno::Reference<linguistic2::XProofreader> xGC =

                                GetGrammarChecker(aCurLocale);

                            if (xGC.is())

                            {

                                aGuard.clear();

                                uno::Sequence<beans::PropertyValue> const aProps(

                                    lcl_makeProperties(xFlatPara, PROOFINFO_MARK_PARAGRAPH));

                                aRes = xGC->doProofreading(aCurDocId, aCurTxt, aCurLocale,

                                                           nStartPos, nSuggestedEnd, aProps);

                                //!! work-around to prevent looping if the grammar checker

                                //!! failed to properly identify the sentence end

                                if (aRes.nBehindEndOfSentencePosition <= nStartPos

                                    && aRes.nBehindEndOfSentencePosition != nSuggestedEnd)

                                {

                                    SAL_WARN(

                                        "linguistic",

                                        "!! Grammarchecker failed to provide end of sentence !!");

                                    aRes.nBehindEndOfSentencePosition = nSuggestedEnd;

                                }

                                aRes.xFlatParagraph = std::move(xFlatPara);

                                aRes.nStartOfSentencePosition = nStartPos;

                            }

                            else

                            {

                                // no grammar checker -> no error

                                // but we need to provide the data below in order to continue with the next sentence

                                aRes.aDocumentIdentifier = aCurDocId;

                                aRes.xFlatParagraph = std::move(xFlatPara);

                                aRes.aText = aCurTxt;

                                aRes.aLocale = std::move(aCurLocale);

                                aRes.nStartOfSentencePosition = nStartPos;

                                aRes.nBehindEndOfSentencePosition = nSuggestedEnd;

                            }

                            aRes.nStartOfNextSentencePosition

                                = lcl_SkipWhiteSpaces(aCurTxt, aRes.nBehindEndOfSentencePosition);

                            aRes.nBehindEndOfSentencePosition = lcl_BacktraceWhiteSpaces(

                                aCurTxt, aRes.nStartOfNextSentencePosition);

                            //guard has to be cleared as ProcessResult calls out of this class

                        }

                        // ---- THREAD SAFE END ----

                        ProcessResult( aRes, xFPIterator, aFPEntryItem.m_bAutomatic );

                    }

                    else

                    {

                        // the paragraph changed meanwhile... (and maybe is still edited)

                        // thus we simply continue to ask for the next to be checked.

                        uno::Reference< text::XFlatParagraph > xFlatParaNext( xFPIterator->getNextPara() );

                        AddEntry( xFPIterator, xFlatParaNext, aCurDocId, 0, aFPEntryItem.m_bAutomatic );

                    }

                }

                catch (css::uno::Exception &)

                {

                    TOOLS_WARN_EXCEPTION("linguistic", "GrammarCheckingIterator::DequeueAndCheck ignoring");

                }

            }

            // ---- THREAD SAFE START ----

            {

                ::osl::Guard< ::osl::Mutex > aGuard( MyMutex() );

                m_aCurCheckedDocId.clear();

            }

            // ---- THREAD SAFE END ----

        }

        else

        {

            // ---- THREAD SAFE START ----

            {

                ::osl::Guard< ::osl::Mutex > aGuard( MyMutex() );

                if (m_bEnd)

                {

                    break;

                }

                // Check queue state again

                if (m_aFPEntriesQueue.empty())

                    m_aWakeUpThread.reset();

            }

            // ---- THREAD SAFE END ----

            //if the queue is empty

            // IMPORTANT: Don't call condition.wait() with locked

            // mutex. Otherwise you would keep out other threads

            // to add entries to the queue! A condition is thread-

            // safe implemented.

            m_aWakeUpThread.wait();

        }

    }

}

void SAL_CALL GrammarCheckingIterator::startProofreading(

    const uno::Reference< ::uno::XInterface > & xDoc,

    const uno::Reference< text::XFlatParagraphIteratorProvider > & xIteratorProvider )

{

    // get paragraph to start checking with

    const bool bAutomatic = true;

    uno::Reference<text::XFlatParagraphIterator> xFPIterator = xIteratorProvider->getFlatParagraphIterator(

            text::TextMarkupType::PROOFREADING, bAutomatic );

    uno::Reference< text::XFlatParagraph > xPara( xFPIterator.is()? xFPIterator->getFirstPara() : nullptr );

    uno::Reference< lang::XComponent > xComponent( xDoc, uno::UNO_QUERY );

    // ---- THREAD SAFE START ----

    ::osl::Guard< ::osl::Mutex > aGuard( MyMutex() );

    if (xPara.is() && xComponent.is())

    {

        OUString aDocId = GetOrCreateDocId( xComponent );

        // create new entry and add it to queue

        AddEntry( xFPIterator, xPara, aDocId, 0, bAutomatic );

    }

    // ---- THREAD SAFE END ----

}

linguistic2::ProofreadingResult SAL_CALL GrammarCheckingIterator::checkSentenceAtPosition(

    const uno::Reference< uno::XInterface >& xDoc,

    const uno::Reference< text::XFlatParagraph >& xFlatPara,

    const OUString& rText,

    const lang::Locale&,

    sal_Int32 nStartOfSentencePos,

    sal_Int32 nSuggestedEndOfSentencePos,

    sal_Int32 nErrorPosInPara )

{

    // for the context menu...

    uno::Reference< lang::XComponent > xComponent( xDoc, uno::UNO_QUERY );

    const bool bDoCheck = (xFlatPara.is() && xComponent.is() &&

        ( nErrorPosInPara < 0 || nErrorPosInPara < rText.getLength()));

    if (!bDoCheck)

        return linguistic2::ProofreadingResult();

    // iterate through paragraph until we find the sentence we are interested in

    linguistic2::ProofreadingResult aTmpRes;

    sal_Int32 nStartPos = nStartOfSentencePos >= 0 ? nStartOfSentencePos : 0;

    bool bFound = false;

    try

    {

        do

        {

            lang::Locale aCurLocale = lcl_GetPrimaryLanguageOfSentence(xFlatPara, nStartPos);

            sal_Int32 nOldStartOfSentencePos = nStartPos;

            uno::Reference<linguistic2::XProofreader> xGC;

            OUString aDocId;

            // ---- THREAD SAFE START ----

            {

                ::osl::Guard<::osl::Mutex> aGuard(MyMutex());

                aDocId = GetOrCreateDocId(xComponent);

                nSuggestedEndOfSentencePos

                    = GetSuggestedEndOfSentence(rText, nStartPos, aCurLocale);

                DBG_ASSERT(nSuggestedEndOfSentencePos > nStartPos,

                           "nSuggestedEndOfSentencePos calculation failed?");

                xGC = GetGrammarChecker(aCurLocale);

            }

            // ---- THREAD SAFE START ----

            sal_Int32 nEndPos = -1;

            if (xGC.is())

            {

                uno::Sequence<beans::PropertyValue> const aProps(

                    lcl_makeProperties(xFlatPara, PROOFINFO_GET_PROOFRESULT));

                aTmpRes = xGC->doProofreading(aDocId, rText, aCurLocale, nStartPos,

                                              nSuggestedEndOfSentencePos, aProps);

                //!! work-around to prevent looping if the grammar checker

                //!! failed to properly identify the sentence end

                if (aTmpRes.nBehindEndOfSentencePosition <= nStartPos)

                {

                    SAL_WARN("linguistic",

                             "!! Grammarchecker failed to provide end of sentence !!");

                    aTmpRes.nBehindEndOfSentencePosition = nSuggestedEndOfSentencePos;

                }

                aTmpRes.xFlatParagraph = xFlatPara;

                aTmpRes.nStartOfSentencePosition = nStartPos;

                nEndPos = aTmpRes.nBehindEndOfSentencePosition;

                if ((nErrorPosInPara < 0 || nStartPos <= nErrorPosInPara)

                    && nErrorPosInPara < nEndPos)

                    bFound = true;

            }

            if (nEndPos == -1) // no result from grammar checker

                nEndPos = nSuggestedEndOfSentencePos;

            nStartPos = lcl_SkipWhiteSpaces(rText, nEndPos);

            aTmpRes.nBehindEndOfSentencePosition = nEndPos;

            aTmpRes.nStartOfNextSentencePosition = nStartPos;

            aTmpRes.nBehindEndOfSentencePosition

                = lcl_BacktraceWhiteSpaces(rText, aTmpRes.nStartOfNextSentencePosition);

            // prevent endless loop by forcefully advancing if needs be...

            if (nStartPos <= nOldStartOfSentencePos)

            {

                SAL_WARN("linguistic", "end-of-sentence detection failed?");

                nStartPos = nOldStartOfSentencePos + 1;

            }

        } while (!bFound && nStartPos < rText.getLength());

    }

    catch (css::uno::Exception&)

    {

        TOOLS_WARN_EXCEPTION("linguistic",

                             "GrammarCheckingIterator::checkSentenceAtPosition ignoring");

    }

    if (bFound && !xFlatPara->isModified())

        return aTmpRes;

    return linguistic2::ProofreadingResult();

}

sal_Int32 GrammarCheckingIterator::GetSuggestedEndOfSentence(

    const OUString &rText,

    sal_Int32 nSentenceStartPos,

    const lang::Locale &rLocale )

{

    // internal method; will always be called with locked mutex

    if (!m_xBreakIterator.is())

    {

        const uno::Reference< uno::XComponentContext >& xContext = ::comphelper::getProcessComponentContext();

        m_xBreakIterator = i18n::BreakIterator::create(xContext);

    }

    sal_Int32 nTextLen = rText.getLength();

    sal_Int32 nEndPosition(0);

    sal_Int32 nTmpStartPos = nSentenceStartPos;

    do

    {

        sal_Int32 const nPrevEndPosition(nEndPosition);

        nEndPosition = nTextLen;

        if (nTmpStartPos < nTextLen)

        {

            nEndPosition = m_xBreakIterator->endOfSentence( rText, nTmpStartPos, rLocale );

            if (nEndPosition <= nPrevEndPosition)

            {

                // fdo#68750 if there's no progress at all then presumably

                // there's no end of sentence in this paragraph so just

                // set the end position to end of paragraph

                nEndPosition = nTextLen;

            }

        }

        if (nEndPosition < 0)

            nEndPosition = nTextLen;

        ++nTmpStartPos;

    }

    while (nEndPosition <= nSentenceStartPos && nEndPosition < nTextLen);

    if (nEndPosition > nTextLen)