/* -*- 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 <vcl/weld.hxx>
#include <svl/fstathelper.hxx>
#include <unotools/pathoptions.hxx>
#include <unotools/transliterationwrapper.hxx>
#include <osl/diagnose.h>
#include <o3tl/string_view.hxx>
#include <swtypes.hxx>
#include <swmodule.hxx>
#include <shellio.hxx>
#include <initui.hxx>
#include <glosdoc.hxx>
#include <gloslst.hxx>
#include <swunohelper.hxx>
#include <view.hxx>

#include <vector>

#define STRING_DELIM char(0x0A)
#define GLOS_TIMEOUT 30000   // update every 30 seconds
#define FIND_MAX_GLOS 20

namespace {

struct TripleString
{
    OUString sGroup;
    OUString sBlock;
    OUString sShort;
};

class SwGlossDecideDlg : public weld::GenericDialogController
{
    std::unique_ptr<weld::Button> m_xOk;
    std::unique_ptr<weld::TreeView> m_xListLB;

    DECL_LINK(DoubleClickHdl, weld::TreeView&, bool);
    DECL_LINK(SelectHdl, weld::TreeView&, void);

public:
    explicit SwGlossDecideDlg(weld::Window* pParent);

    weld::TreeView& GetTreeView() {return *m_xListLB;}
};

}

SwGlossDecideDlg::SwGlossDecideDlg(weld::Window* pParent)
    : GenericDialogController(pParent, u"modules/swriter/ui/selectautotextdialog.ui"_ustr, u"SelectAutoTextDialog"_ustr)
    , m_xOk(m_xBuilder->weld_button(u"ok"_ustr))
    , m_xListLB(m_xBuilder->weld_tree_view(u"treeview"_ustr))
{
    m_xListLB->set_size_request(m_xListLB->get_approximate_digit_width() * 32,
                                m_xListLB->get_height_rows(8));
    m_xListLB->connect_row_activated(LINK(this, SwGlossDecideDlg, DoubleClickHdl));
    m_xListLB->connect_selection_changed(LINK(this, SwGlossDecideDlg, SelectHdl));
}

IMPL_LINK_NOARG(SwGlossDecideDlg, DoubleClickHdl, weld::TreeView&, bool)
{
    m_xDialog->response(RET_OK);
    return true;
}

IMPL_LINK_NOARG(SwGlossDecideDlg, SelectHdl, weld::TreeView&, void)
{
    m_xOk->set_sensitive(m_xListLB->get_selected_index() != -1);
}

SwGlossaryList::SwGlossaryList() :
    AutoTimer("SwGlossaryList"), m_bFilled(false)
{
    SvtPathOptions aPathOpt;
    m_sPath = aPathOpt.GetAutoTextPath();
    SetTimeout(GLOS_TIMEOUT);
}

SwGlossaryList::~SwGlossaryList()
{
    ClearGroups();
}

// If the GroupName is already known, then only rShortName
// will be filled. Otherwise also rGroupName will be set and
// on demand asked for the right group.

bool SwGlossaryList::GetShortName(std::u16string_view rLongName,
                                  OUString& rShortName, OUString& rGroupName )
{
    if(!m_bFilled)
        Update();

    std::vector<TripleString> aTripleStrings;

    size_t nCount = m_aGroupArr.size();
    for(size_t i = 0; i < nCount; i++ )
    {
        AutoTextGroup* pGroup = m_aGroupArr[i].get();
        if(!rGroupName.isEmpty() && rGroupName != pGroup->sName)
            continue;

        sal_Int32 nPosLong = 0;
        for(sal_uInt16 j = 0; j < pGroup->nCount; j++)
        {
            const OUString sLong = pGroup->sLongNames.getToken(0, STRING_DELIM, nPosLong);
            if(rLongName != sLong)
                continue;

            TripleString aTriple;
            aTriple.sGroup = pGroup->sName;
            aTriple.sBlock = sLong;
            aTriple.sShort = pGroup->sShortNames.getToken(j, STRING_DELIM);
            aTripleStrings.push_back(aTriple);
        }
    }

    bool bRet = false;
    nCount = aTripleStrings.size();
    if(1 == nCount)
    {
        const TripleString& rTriple(aTripleStrings.front());
        rShortName = rTriple.sShort;
        rGroupName = rTriple.sGroup;
        bRet = true;
    }
    else if(1 < nCount)
    {
        SwView *pView  = ::GetActiveView();
        if (!pView)
            return bRet;
        SwGlossDecideDlg aDlg(pView->GetFrameWeld());
        OUString sTitle = aDlg.get_title() + " " + aTripleStrings.front().sBlock;
        aDlg.set_title(sTitle);

        weld::TreeView& rLB = aDlg.GetTreeView();
        for (const auto& rTriple : aTripleStrings)
            rLB.append_text(rTriple.sGroup.getToken(0, GLOS_DELIM));

        rLB.select(0);
        if (aDlg.run() == RET_OK && rLB.get_selected_index() != -1)
        {
            const TripleString& rTriple(aTripleStrings[rLB.get_selected_index()]);
            rShortName = rTriple.sShort;
            rGroupName = rTriple.sGroup;
            bRet = true;
        }
        else
            bRet = false;
    }
    return bRet;
}

size_t SwGlossaryList::GetGroupCount()
{
    if(!m_bFilled)
        Update();
    return m_aGroupArr.size();
}

OUString SwGlossaryList::GetGroupName(size_t nPos)
{
    OSL_ENSURE(m_aGroupArr.size() > nPos, "group not available");
    if(nPos < m_aGroupArr.size())
    {
        AutoTextGroup* pGroup = m_aGroupArr[nPos].get();
        OUString sRet = pGroup->sName;
        return sRet;
    }
    return OUString();
}

OUString SwGlossaryList::GetGroupTitle(size_t nPos)
{
    OSL_ENSURE(m_aGroupArr.size() > nPos, "group not available");
    if(nPos < m_aGroupArr.size())
    {
        AutoTextGroup* pGroup = m_aGroupArr[nPos].get();
        return pGroup->sTitle;
    }
    return OUString();
}

sal_uInt16 SwGlossaryList::GetBlockCount(size_t nGroup)
{
    OSL_ENSURE(m_aGroupArr.size() > nGroup, "group not available");
    if(nGroup < m_aGroupArr.size())
    {
        AutoTextGroup* pGroup = m_aGroupArr[nGroup].get();
        return pGroup->nCount;
    }
    return 0;
}

OUString SwGlossaryList::GetBlockLongName(size_t nGroup, sal_uInt16 nBlock)
{
    OSL_ENSURE(m_aGroupArr.size() > nGroup, "group not available");
    if(nGroup < m_aGroupArr.size())
    {
        AutoTextGroup* pGroup = m_aGroupArr[nGroup].get();
        return pGroup->sLongNames.getToken(nBlock, STRING_DELIM);
    }
    return OUString();
}

OUString SwGlossaryList::GetBlockShortName(size_t nGroup, sal_uInt16 nBlock)
{
    OSL_ENSURE(m_aGroupArr.size() > nGroup, "group not available");
    if(nGroup < m_aGroupArr.size())
    {
        AutoTextGroup* pGroup = m_aGroupArr[nGroup].get();
        return pGroup->sShortNames.getToken(nBlock, STRING_DELIM);
    }
    return OUString();
}

void SwGlossaryList::Update()
{
    if(!IsActive())
        Start();

    SvtPathOptions aPathOpt;
    const OUString& sTemp( aPathOpt.GetAutoTextPath() );
    if(sTemp != m_sPath)
    {
        m_sPath = sTemp;
        m_bFilled = false;
        ClearGroups();
    }
    SwGlossaries* pGlossaries = ::GetGlossaries();
    const std::vector<OUString> & rPathArr = pGlossaries->GetPathArray();
    const OUString sExt( SwGlossaries::GetExtension() );
    if(!m_bFilled)
    {
        const size_t nGroupCount = pGlossaries->GetGroupCnt();
        for(size_t i = 0; i < nGroupCount; ++i)
        {
            OUString sGrpName = pGlossaries->GetGroupName(i);
            const size_t nPath = static_cast<size_t>(
                o3tl::toInt32(o3tl::getToken(sGrpName, 1, GLOS_DELIM)));
            if( nPath < rPathArr.size() )
            {
                std::unique_ptr<AutoTextGroup> pGroup(new AutoTextGroup);
                pGroup->sName = sGrpName;

                FillGroup(pGroup.get(), pGlossaries);
                OUString sName = rPathArr[nPath] + "/" +
                    o3tl::getToken(pGroup->sName, 0, GLOS_DELIM) + sExt;
                FStatHelper::GetModifiedDateTimeOfFile( sName,
                                                &pGroup->aDateModified,
                                                &pGroup->aDateModified );

                m_aGroupArr.insert( m_aGroupArr.begin(), std::move(pGroup) );
            }
        }
        m_bFilled = true;
    }
    else
    {
        for( size_t nPath = 0; nPath < rPathArr.size(); nPath++ )
        {
            std::vector<OUString> aFoundGroupNames;
            std::vector<OUString> aFiles;
            std::vector<DateTime> aDateTimeArr;

            SWUnoHelper::UCB_GetFileListOfFolder( rPathArr[nPath], aFiles,
                                                    &sExt, &aDateTimeArr );
            for( size_t nFiles = 0; nFiles < aFiles.size(); ++nFiles )
            {
                const OUString& aTitle = aFiles[ nFiles ];
                ::DateTime& rDT = aDateTimeArr[ nFiles ];

                OUString sName( aTitle.copy( 0, aTitle.getLength() - sExt.getLength() ));

                aFoundGroupNames.push_back(sName);
                sName += OUStringChar(GLOS_DELIM) + OUString::number( o3tl::narrowing<sal_uInt16>(nPath) );
                AutoTextGroup* pFound = FindGroup( sName );
                if( !pFound )
                {
                    pFound = new AutoTextGroup;
                    pFound->sName = sName;
                    FillGroup( pFound, pGlossaries );
                    pFound->aDateModified = rDT;

                    m_aGroupArr.push_back(std::unique_ptr<AutoTextGroup>(pFound));
                }
                else if( pFound->aDateModified != rDT )
                {
                    FillGroup(pFound, pGlossaries);
                    pFound->aDateModified = rDT;
                }
            }

            for( size_t i = m_aGroupArr.size(); i>0; )
            {
                --i;
                // maybe remove deleted groups
                AutoTextGroup* pGroup = m_aGroupArr[i].get();
                const size_t nGroupPath = static_cast<size_t>(
                    o3tl::toInt32(o3tl::getToken(pGroup->sName, 1, GLOS_DELIM)));
                // Only the groups will be checked which are registered
                // for the current subpath.
                if( nGroupPath == nPath )
                {
                    std::u16string_view sCompareGroup = o3tl::getToken(pGroup->sName, 0, GLOS_DELIM);
                    bool bFound = std::any_of(aFoundGroupNames.begin(), aFoundGroupNames.end(),
                        [&sCompareGroup](const OUString& rGroupName) { return sCompareGroup == rGroupName; });

                    if(!bFound)
                    {
                        m_aGroupArr.erase(m_aGroupArr.begin() + i);
                    }
                }
            }
        }
    }
}

void SwGlossaryList::Invoke()
{
    // Only update automatically if a SwView has the focus.
    if(::GetActiveView())
        Update();
}

AutoTextGroup* SwGlossaryList::FindGroup(std::u16string_view rGroupName)
{
    for(const auto & pRet : m_aGroupArr)
    {
        if(pRet->sName == rGroupName)
            return pRet.get();
    }
    return nullptr;
}

void SwGlossaryList::FillGroup(AutoTextGroup* pGroup, SwGlossaries* pGlossaries)
{
    std::unique_ptr<SwTextBlocks> pBlock = pGlossaries->GetGroupDoc(pGroup->sName);
    pGroup->nCount = pBlock ? pBlock->GetCount() : 0;
    pGroup->sLongNames.clear();
    pGroup->sShortNames.clear();
    if(pBlock)
        pGroup->sTitle = pBlock->GetName();

    for(sal_uInt16 j = 0; j < pGroup->nCount; j++)
    {
        pGroup->sLongNames += pBlock->GetLongName(j)
            + OUStringChar(STRING_DELIM);
        pGroup->sShortNames += pBlock->GetShortName(j)
            + OUStringChar(STRING_DELIM);
    }
}

// Give back all (not exceeding FIND_MAX_GLOS) found modules
// with matching beginning.

void SwGlossaryList::HasLongName(const std::vector<OUString>& rBeginCandidates,
                                 std::vector<std::pair<OUString, sal_uInt16>>& rLongNames)
{
    if(!m_bFilled)
        Update();
    const ::utl::TransliterationWrapper& rSCmp = GetAppCmpStrIgnore();
    // We store results for all candidate words in separate lists, so that later
    // we can sort them according to the candidate position
    std::vector<std::vector<OUString>> aResults(rBeginCandidates.size());

    // We can't break after FIND_MAX_GLOS items found, since first items may have ended up in
    // lower-priority lists, and those from higher-priority lists are yet to come. So process all.
    for (const auto& pGroup : m_aGroupArr)
    {
        sal_Int32 nIdx{ 0 };
        for(sal_uInt16 j = 0; j < pGroup->nCount; j++)
        {
            OUString sBlock = pGroup->sLongNames.getToken(0, STRING_DELIM, nIdx);
            for (size_t i = 0; i < rBeginCandidates.size(); ++i)
            {
                const OUString& s = rBeginCandidates[i];
                if (s.getLength() + 1 < sBlock.getLength()
                    && rSCmp.isEqual(sBlock.copy(0, s.getLength()), s))
                {
                    aResults[i].push_back(sBlock);
                }
            }
        }
    }

    std::vector<std::pair<OUString, sal_uInt16>> aAllResults;
    // Sort and concatenate all result lists. See QuickHelpData::SortAndFilter
    for (size_t i = 0; i < rBeginCandidates.size(); ++i)
    {
        std::sort(aResults[i].begin(), aResults[i].end(),
                  [origWord = rBeginCandidates[i]](const OUString& s1, const OUString& s2) {
                      int nRet = s1.compareToIgnoreAsciiCase(s2);
                      if (nRet == 0)
                      {
                          // fdo#61251 sort stuff that starts with the exact rOrigWord before
                          // another ignore-case candidate
                          int n1StartsWithOrig = s1.startsWith(origWord) ? 0 : 1;
                          int n2StartsWithOrig = s2.startsWith(origWord) ? 0 : 1;
                          return n1StartsWithOrig < n2StartsWithOrig;
                      }
                      return nRet < 0;
                  });
        // All suggestions must be accompanied with length of the text they would replace
        std::transform(aResults[i].begin(), aResults[i].end(), std::back_inserter(aAllResults),
                       [nLen = sal_uInt16(rBeginCandidates[i].getLength())](const OUString& s) {
                           return std::make_pair(s, nLen);
                       });
    }

    const auto it = std::unique(
        aAllResults.begin(), aAllResults.end(),
        [](const std::pair<OUString, sal_uInt16>& s1, const std::pair<OUString, sal_uInt16>& s2) {
            return s1.first.equalsIgnoreAsciiCase(s2.first);
        });
    if (const auto nCount = std::min<size_t>(std::distance(aAllResults.begin(), it), FIND_MAX_GLOS))
    {
        rLongNames.insert(rLongNames.end(), aAllResults.begin(), aAllResults.begin() + nCount);
    }
}

void    SwGlossaryList::ClearGroups()
{
    m_aGroupArr.clear();
    m_bFilled = false;
}

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