package pro.verron.officestamper.core;

import jakarta.xml.bind.JAXBElement;

import org.docx4j.TraversalUtil;

import org.docx4j.XmlUtils;

import org.docx4j.finders.ClassFinder;

import org.docx4j.model.structure.HeaderFooterPolicy;

import org.docx4j.model.structure.SectionWrapper;

import org.docx4j.openpackaging.packages.WordprocessingMLPackage;

import org.docx4j.openpackaging.parts.JaxbXmlPart;

import org.docx4j.openpackaging.parts.WordprocessingML.BinaryPartAbstractImage;

import org.docx4j.utils.TraversalUtilVisitor;

import org.docx4j.wml.*;

import org.jvnet.jaxb2_commons.ppp.Child;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.lang.Nullable;

import org.springframework.util.function.ThrowingFunction;

import pro.verron.officestamper.api.DocxPart;

import pro.verron.officestamper.api.OfficeStamperException;

import java.util.*;

import java.util.stream.Stream;

import static java.util.Collections.emptyList;

import static java.util.Optional.ofNullable;

import static java.util.stream.Stream.Builder;

import static pro.verron.officestamper.utils.WmlFactory.newRun;

/// Utility class to retrieve elements from a document.

///

/// @author Joseph Verron

/// @author DallanMC

/// @version ${version}

/// @since 1.4.7

public class DocumentUtil {

    private static final Logger log = LoggerFactory.getLogger(DocumentUtil.class);

    private DocumentUtil() {

        throw new OfficeStamperException("Utility classes shouldn't be instantiated");

    /// Streams the elements of a given class type from the specified DocxPart.

///

    /// @param <T>          the type of elements to be streamed

    /// @param source       the source DocxPart containing the elements to be streamed

    /// @param elementClass the class type of the elements to be filtered and streamed.

///

    /// @return a Stream of elements of the specified type found within the source DocxPart.

    public static <T> Stream<T> streamObjectElements(DocxPart source, Class<T> elementClass) {

        ClassFinder finder = new ClassFinder(elementClass);

1 1. streamObjectElements : removed call to org/docx4j/TraversalUtil::visit → KILLED

        TraversalUtil.visit(source.part(), finder);

1 1. streamObjectElements : replaced return value with Stream.empty for pro/verron/officestamper/core/DocumentUtil::streamObjectElements → KILLED

        return finder.results.stream()

                             .map(elementClass::cast);

    /// Retrieves all elements from the main document part of the specified WordprocessingMLPackage.

///

    /// @param subDocument the WordprocessingMLPackage from which to retrieve the elements

    /// @return a list of objects representing the content of the main document part.

    public static List<Object> allElements(WordprocessingMLPackage subDocument) {

1 1. allElements : replaced return value with Collections.emptyList for pro/verron/officestamper/core/DocumentUtil::allElements → KILLED

        return subDocument.getMainDocumentPart()

                          .getContent();

    /// Recursively walk through a source to find embedded images and import them in the target document.

///

    /// @param source source document containing image files.

    /// @param target target document to add image files to.

///

    /// @return a [Map] object

    public static Map<R, R> walkObjectsAndImportImages(WordprocessingMLPackage source, WordprocessingMLPackage target) {

1 1. walkObjectsAndImportImages : replaced return value with Collections.emptyMap for pro/verron/officestamper/core/DocumentUtil::walkObjectsAndImportImages → KILLED

        return walkObjectsAndImportImages(source.getMainDocumentPart(), source, target);

    /// Recursively walk through source accessor to find embedded images and import the target document.

///

    /// @param container source container to walk.

    /// @param source    source document containing image files.

    /// @param target    target document to add image files to.

///

    /// @return a [Map] object

    public static Map<R, R> walkObjectsAndImportImages(

            ContentAccessor container,

            WordprocessingMLPackage source,

            WordprocessingMLPackage target

) {

        Map<R, R> replacements = new HashMap<>();

        for (Object obj : container.getContent()) {

            Queue<Object> queue = new ArrayDeque<>();

            queue.add(obj);

1 1. walkObjectsAndImportImages : negated conditional → KILLED

            while (!queue.isEmpty()) {

                Object currentObj = queue.remove();

2 1. walkObjectsAndImportImages : negated conditional → KILLED
2. walkObjectsAndImportImages : negated conditional → KILLED

                if (currentObj instanceof R currentR && containsImage(currentR)) {

                    var docxImageExtractor = new DocxImageExtractor(source);

                    var imageData = docxImageExtractor.getRunDrawingData(currentR);

100

                    var maxWidth = docxImageExtractor.getRunDrawingMaxWidth(currentR);

101

                    var imagePart = tryCreateImagePart(target, imageData);

102

                    var runWithImage = newRun(maxWidth, imagePart, "dummyFileName", "dummyAltText");

103

                    replacements.put(currentR, runWithImage);

104

105

1 1. walkObjectsAndImportImages : negated conditional → KILLED

                else if (currentObj instanceof ContentAccessor contentAccessor)

106

                    queue.addAll(contentAccessor.getContent());

107

108

109

1 1. walkObjectsAndImportImages : replaced return value with Collections.emptyMap for pro/verron/officestamper/core/DocumentUtil::walkObjectsAndImportImages → KILLED

        return replacements;

110

111

112

    private static boolean containsImage(R run) {

113

2 1. containsImage : replaced boolean return with true for pro/verron/officestamper/core/DocumentUtil::containsImage → KILLED
2. containsImage : replaced boolean return with false for pro/verron/officestamper/core/DocumentUtil::containsImage → KILLED

        return run.getContent()

114

                  .stream()

115

                  .filter(JAXBElement.class::isInstance)

116

                  .map(JAXBElement.class::cast)

117

                  .map(JAXBElement::getValue)

118

                  .anyMatch(Drawing.class::isInstance);

119

120

121

    private static BinaryPartAbstractImage tryCreateImagePart(WordprocessingMLPackage destDocument, byte[] imageData) {

122

        try {

123

1 1. tryCreateImagePart : replaced return value with null for pro/verron/officestamper/core/DocumentUtil::tryCreateImagePart → KILLED

            return BinaryPartAbstractImage.createImagePart(destDocument, imageData);

124

        } catch (Exception e) {

125

            throw new OfficeStamperException(e);

    /// Finds the smallest common parent between two objects.

130

///

131

    /// @param o1 the first object

132

    /// @param o2 the second object

133

///

134

    /// @return the smallest common parent of the two objects

135

///

136

    /// @throws OfficeStamperException if there is an error finding the common parent

137

    public static ContentAccessor findSmallestCommonParent(Object o1, Object o2) {

138

2 1. findSmallestCommonParent : negated conditional → KILLED
2. findSmallestCommonParent : negated conditional → KILLED

        if (depthElementSearch(o1, o2) && o2 instanceof ContentAccessor contentAccessor)

139

1 1. findSmallestCommonParent : replaced return value with null for pro/verron/officestamper/core/DocumentUtil::findSmallestCommonParent → KILLED

            return findInsertableParent(contentAccessor);

140

2 1. findSmallestCommonParent : negated conditional → KILLED
2. findSmallestCommonParent : replaced return value with null for pro/verron/officestamper/core/DocumentUtil::findSmallestCommonParent → KILLED

        else if (o2 instanceof Child child) return findSmallestCommonParent(o1, child.getParent());

141

        else throw new OfficeStamperException();

142

143

144

    /// Recursively searches for an element in a content tree.

145

///

146

    /// @param searchTarget the element to search for

147

    /// @param searchTree   the content tree to search in

148

///

149

    /// @return true if the element is found, false otherwise

150

    public static boolean depthElementSearch(Object searchTarget, Object searchTree) {

151

        var element = XmlUtils.unwrap(searchTree);

152

2 1. depthElementSearch : replaced boolean return with false for pro/verron/officestamper/core/DocumentUtil::depthElementSearch → KILLED
2. depthElementSearch : negated conditional → KILLED

        if (searchTarget.equals(element)) return true;

153

154

        var contentContent = switch (element) {

155

            case ContentAccessor accessor -> accessor.getContent();

156

            case SdtRun sdtRun -> sdtRun.getSdtContent()

157

                                        .getContent();

158

            default -> {

159

                log.warn("Element {} not recognized", element);

160

                yield emptyList();

161

162

};

163

164

2 1. depthElementSearch : replaced boolean return with false for pro/verron/officestamper/core/DocumentUtil::depthElementSearch → KILLED
2. depthElementSearch : replaced boolean return with true for pro/verron/officestamper/core/DocumentUtil::depthElementSearch → KILLED

        return contentContent.stream()

165

2 1. lambda$depthElementSearch$0 : replaced boolean return with true for pro/verron/officestamper/core/DocumentUtil::lambda$depthElementSearch$0 → KILLED
2. lambda$depthElementSearch$0 : replaced boolean return with false for pro/verron/officestamper/core/DocumentUtil::lambda$depthElementSearch$0 → KILLED

                             .anyMatch(obj -> depthElementSearch(searchTarget, obj));

166

167

168

    private static ContentAccessor findInsertableParent(Object searchFrom) {

169

1 1. findInsertableParent : replaced return value with null for pro/verron/officestamper/core/DocumentUtil::findInsertableParent → KILLED

        return switch (searchFrom) {

170

            case Tc tc -> tc;

171

            case Body body -> body;

172

            case Child child -> findInsertableParent(child.getParent());

173

            default -> throw new OfficeStamperException("Unexpected parent " + searchFrom.getClass());

174

};

175

176

177

    /// Visits the document's main content, header, footer, footnotes, and endnotes using

178

    /// the specified visitor.

179

///

180

    /// @param document the WordprocessingMLPackage representing the document to be visited

181

    /// @param visitor  the TraversalUtilVisitor to be applied to each relevant part of the document

182

    public static void visitDocument(WordprocessingMLPackage document, TraversalUtilVisitor<?> visitor) {

183

        var mainDocumentPart = document.getMainDocumentPart();

184

1 1. visitDocument : removed call to org/docx4j/TraversalUtil::visit → KILLED

        TraversalUtil.visit(mainDocumentPart, visitor);

185

2 1. visitDocument : removed call to java/util/stream/Stream::forEach → SURVIVED
2. lambda$visitDocument$0 : removed call to org/docx4j/TraversalUtil::visit → NO_COVERAGE

        streamHeaderFooterPart(document).forEach(f -> TraversalUtil.visit(f, visitor));

186

1 1. visitDocument : removed call to pro/verron/officestamper/core/DocumentUtil::visitPartIfExists → KILLED

        visitPartIfExists(visitor, mainDocumentPart.getFootnotesPart());

187

1 1. visitDocument : removed call to pro/verron/officestamper/core/DocumentUtil::visitPartIfExists → KILLED

        visitPartIfExists(visitor, mainDocumentPart.getEndNotesPart());

188

189

190

    private static Stream<Object> streamHeaderFooterPart(WordprocessingMLPackage document) {

191

1 1. streamHeaderFooterPart : replaced return value with Stream.empty for pro/verron/officestamper/core/DocumentUtil::streamHeaderFooterPart → SURVIVED

        return document.getDocumentModel()

192

                       .getSections()

193

                       .stream()

194

                       .map(SectionWrapper::getHeaderFooterPolicy)

195

                       .flatMap(DocumentUtil::extractHeaderFooterParts);

196

197

198

    private static void visitPartIfExists(TraversalUtilVisitor<?> visitor, @Nullable JaxbXmlPart<?> part) {

199

        ThrowingFunction<JaxbXmlPart<?>, Object> throwingFunction = JaxbXmlPart::getContents;

200

        Optional.ofNullable(part)

201

1 1. lambda$visitPartIfExists$0 : replaced return value with null for pro/verron/officestamper/core/DocumentUtil::lambda$visitPartIfExists$0 → KILLED

                .map(c -> throwingFunction.apply(c, OfficeStamperException::new))

202

2 1. lambda$visitPartIfExists$1 : removed call to org/docx4j/TraversalUtil::visit → KILLED
2. visitPartIfExists : removed call to java/util/Optional::ifPresent → KILLED

                .ifPresent(c -> TraversalUtil.visit(c, visitor));

203

204

205

    private static Stream<JaxbXmlPart<?>> extractHeaderFooterParts(HeaderFooterPolicy hfp) {

206

        Builder<JaxbXmlPart<?>> builder = Stream.builder();

207