/* poppler-private.h: qt interface to poppler
 * Copyright (C) 2005, Net Integration Technologies, Inc.
 * Copyright (C) 2005, 2008, Brad Hards <bradh@frogmouth.net>
 * Copyright (C) 2006-2009, 2011, 2012, 2017-2022, 2024-2026 by Albert Astals Cid <aacid@kde.org>
 * Copyright (C) 2007-2009, 2011, 2014 by Pino Toscano <pino@kde.org>
 * Copyright (C) 2011 Andreas Hartmetz <ahartmetz@gmail.com>
 * Copyright (C) 2011 Hib Eris <hib@hiberis.nl>
 * Copyright (C) 2012, 2013 Thomas Freitag <Thomas.Freitag@alfa.de>
 * Copyright (C) 2013 Anthony Granger <grangeranthony@gmail.com>
 * Copyright (C) 2014 Bogdan Cristea <cristeab@gmail.com>
 * Copyright (C) 2014 Aki Koskinen <freedesktop@akikoskinen.info>
 * Copyright (C) 2016 Jakub Alba <jakubalba@gmail.com>
 * Copyright (C) 2017 Christoph Cullmann <cullmann@kde.org>
 * Copyright (C) 2018 Klarälvdalens Datakonsult AB, a KDAB Group company, <info@kdab.com>. Work sponsored by the LiMux project of the city of Munich
 * Copyright (C) 2018, 2020 Adam Reichold <adam.reichold@t-online.de>
 * Copyright (C) 2019-2021 Oliver Sander <oliver.sander@tu-dresden.de>
 * Copyright (C) 2019 João Netto <joaonetto901@gmail.com>
 * Copyright (C) 2019 Jan Grulich <jgrulich@redhat.com>
 * Copyright (C) 2019 Alexander Volkov <a.volkov@rusbitech.ru>
 * Copyright (C) 2020 Philipp Knechtges <philipp-dev@knechtges.com>
 * Copyright (C) 2021 Mahmoud Khalil <mahmoudkhalil11@gmail.com>
 * Copyright (C) 2021 Hubert Figuiere <hub@figuiere.net>
 * Copyright (C) 2021 Georgiy Sgibnev <georgiy@sgibnev.com>. Work sponsored by lab50.net.
 * Copyright (C) 2024-2026 g10 Code GmbH, Author: Sune Stolborg Vuorela <sune@vuorela.dk>
 * Inspired on code by
 * Copyright (C) 2004 by Albert Astals Cid <tsdgeos@terra.es>
 * Copyright (C) 2004 by Enrico Ros <eros.kde@email.it>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
 */

#ifndef _POPPLER_PRIVATE_H_
#define _POPPLER_PRIVATE_H_

#include <QtCore/QFile>
#include <QtCore/QMutex>
#include <QtCore/QPointer>
#include <QtCore/QVector>

#include <functional>
#include <config.h>
#include <poppler-config.h>
#include <Annot.h>
#include <GfxState.h>
#include <GlobalParams.h>
#include <FileSpec.h>
#include <PDFDoc.h>
#include <FontInfo.h>
#include <OutputDev.h>
#include <Error.h>
#include <SplashOutputDev.h>

#include "poppler-qt6.h"
#include "poppler-embeddedfile-private.h"
#include "poppler-qiodeviceinstream-private.h"

class LinkDest;
class FormWidget;

namespace Poppler {

/* borrowed from kpdf */
POPPLER_QT6_EXPORT QString unicodeToQString(const Unicode *u, int len);
POPPLER_QT6_EXPORT QString unicodeToQString(const std::vector<Unicode> &u);

POPPLER_QT6_EXPORT QString UnicodeParsedString(const GooString *s1);

POPPLER_QT6_EXPORT QString UnicodeParsedString(const std::string &s1);

POPPLER_QT6_EXPORT std::unique_ptr<GooString> QStringToUnicodeGooString(const QString &s);

// Returns a big endian UTF-16 string with BOM or an empty string without BOM.
// The caller owns the returned pointer.
POPPLER_QT6_EXPORT std::unique_ptr<GooString> QStringToGooString(const QString &s);

std::unique_ptr<GooString> QDateTimeToUnicodeGooString(const QDateTime &dt);

void qt6ErrorFunction(ErrorCategory /*category*/, Goffset pos, const char *msg);

Annot::AdditionalActionsType toPopplerAdditionalActionType(Annotation::AdditionalActionType type);

class LinkDestinationData
{
public:
    LinkDestinationData(const LinkDest *l, const GooString *nd, Poppler::DocumentData *pdfdoc, bool external) : ld(l), namedDest(nd), doc(pdfdoc), externalDest(external) { }

    const LinkDest *ld;
    const GooString *namedDest;
    Poppler::DocumentData *doc;
    bool externalDest;
};

class DocumentData : private GlobalParamsIniter
{
public:
    DocumentData(const QString &filePath, const std::optional<GooString> &ownerPassword, const std::optional<GooString> &userPassword) : GlobalParamsIniter(qt6ErrorFunction)
    {
        init();
        m_device = nullptr;
        m_filePath = filePath;

#ifdef _WIN32
        doc = std::make_unique<PDFDoc>((wchar_t *)filePath.utf16(), filePath.length(), ownerPassword, userPassword, [this] { notifyXRefReconstructed(); });
#else
        doc = std::make_unique<PDFDoc>(std::make_unique<GooString>(QFile::encodeName(filePath).constData()), ownerPassword, userPassword, [this] { notifyXRefReconstructed(); });
#endif
    }

    DocumentData(QIODevice *device, const std::optional<GooString> &ownerPassword, const std::optional<GooString> &userPassword) : GlobalParamsIniter(qt6ErrorFunction)
    {
        m_device = device;
        auto str = std::make_unique<QIODeviceInStream>(device, 0, false, device->size(), Object::null());
        init();
        doc = std::make_unique<PDFDoc>(std::move(str), ownerPassword, userPassword, [this] { notifyXRefReconstructed(); });
    }

    DocumentData(const QByteArray &data, const std::optional<GooString> &ownerPassword, const std::optional<GooString> &userPassword) : GlobalParamsIniter(qt6ErrorFunction)
    {
        m_device = nullptr;
        fileContents = data;
        auto str = std::make_unique<MemStream>(fileContents.data(), 0, fileContents.length(), Object::null());
        init();
        doc = std::make_unique<PDFDoc>(std::move(str), ownerPassword, userPassword, [this] { notifyXRefReconstructed(); });
    }

    void init();

    ~DocumentData();

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

    void setPaperColor(const QColor &color) { paperColor = color; }

    void fillMembers()
    {
        int numEmb = doc->getCatalog()->numEmbeddedFiles();
        if (!(0 == numEmb)) {
            // we have some embedded documents, build the list
            for (int yalv = 0; yalv < numEmb; ++yalv) {
                std::unique_ptr<FileSpec> fs = doc->getCatalog()->embeddedFile(yalv);
                m_embeddedFiles.append(new EmbeddedFile(*new EmbeddedFileData(std::move(fs))));
            }
        }
    }

    /**
     * a method that is being called whenever PDFDoc's XRef is reconstructed
     * where we'll set xrefReconstructed flag and notify users of the
     * reconstruction event
     */
    void notifyXRefReconstructed();

    static std::unique_ptr<Document> checkDocument(DocumentData *doc);

    std::unique_ptr<PDFDoc> doc;
    QString m_filePath;
    QIODevice *m_device;
    QByteArray fileContents;
    bool locked;
    Document::RenderBackend m_backend;
    QList<EmbeddedFile *> m_embeddedFiles;
    QPointer<OptContentModel> m_optContentModel;
    QColor paperColor;
    int m_hints;
#if USE_CMS
    GfxLCMSProfilePtr m_sRGBProfile;
    GfxLCMSProfilePtr m_displayProfile;
#endif
    bool xrefReconstructed;
    // notifies the user whenever the backend's PDFDoc XRef is reconstructed
    std::function<void()> xrefReconstructedCallback;
};

class FontInfoData
{
public:
    FontInfoData()
    {
        isEmbedded = false;
        isSubset = false;
        type = FontInfo::unknown;
    }

    explicit FontInfoData(::FontInfo *fi)
    {
        const std::optional<std::string> &fiName = fi->getName();
        if (fiName) {
            fontName = QString::fromStdString(fiName.value());
        }
        const std::optional<std::string> &fiFile = fi->getFile();
        if (fiFile) {
            fontFile = QString::fromStdString(fiFile.value());
        }
        const std::optional<std::string> &fiSubstituteName = fi->getSubstituteName();
        if (fiSubstituteName) {
            fontSubstituteName = QString::fromStdString(fiSubstituteName.value());
        }
        isEmbedded = fi->getEmbedded();
        isSubset = fi->getSubset();
        type = static_cast<Poppler::FontInfo::Type>(fi->getType());
        embRef = fi->getEmbRef();
    }

    FontInfoData(const FontInfoData &fid) = default;
    FontInfoData &operator=(const FontInfoData &) = default;

    QString fontName;
    QString fontSubstituteName;
    QString fontFile;
    bool isEmbedded : 1;
    bool isSubset : 1;
    FontInfo::Type type;
    Ref embRef;
};

class FontIteratorData
{
public:
    FontIteratorData(int startPage, DocumentData *dd) : fontInfoScanner(dd->doc.get(), startPage), totalPages(dd->doc->getNumPages()), currentPage(qMax(startPage, 0) - 1) { }

    ~FontIteratorData() = default;

    FontInfoScanner fontInfoScanner;
    int totalPages;
    int currentPage;
};

class TextBoxData
{
public:
    TextBoxData() = default;

    QString text;
    QRectF bBox;
    TextBox *nextWord = nullptr;
    QVector<QRectF> charBBoxes; // the boundingRect of each character
    bool hasSpaceAfter = false;
};

inline Poppler::ErrorStringType fromPopplerCore(::ErrorStringType type)
{
    switch (type) {
    case ::ErrorStringType::ErrorCodeString:
        return Poppler::ErrorStringType::ErrorCodeString;
    case ::ErrorStringType::UserString:
        return Poppler::ErrorStringType::UserString;
    }
    return Poppler::ErrorStringType::ErrorCodeString;
}

inline Poppler::ErrorString fromPopplerCore(const ::ErrorString &str)
{
    Poppler::ErrorString res;
    res.type = fromPopplerCore(str.type);
    res.data = QString::fromStdString(str.text);
    return res;
}

class FormFieldData
{
public:
    FormFieldData(DocumentData *_doc, ::Page *p, ::FormWidget *w) : doc(_doc), page(p), fm(w) { }

    DocumentData *doc;
    ::Page *page; // Note for some signatures it can be null since there's signatures that don't belong to a given page
    ::FormWidget *fm;
    QRectF box;
    static POPPLER_QT6_EXPORT ::FormWidget *getFormWidget(const FormField *f);
    Poppler::ErrorString lastSigningErrorDetails;
};

class FormFieldIcon;
class FormFieldIconData
{
public:
    static POPPLER_QT6_EXPORT FormFieldIconData *getData(const FormFieldIcon &f);
    Dict *icon;
};

}

#endif
