package jnpf.fileStorage.dms;

import com.google.zxing.BarcodeFormat;
import com.google.zxing.EncodeHintType;
import com.google.zxing.MultiFormatWriter;
import com.google.zxing.common.BitMatrix;
import jnpf.dmsEntity.preview.model.DmsWatermarkPositionSnapshot;
import jnpf.dmsEntity.preview.model.DmsWatermarkSnapshot;
import jnpf.dms.fonts.DmsWatermarkFonts;
import jnpf.exception.DataException;
import jnpf.onlyoffice.PageWatermarkRequest;
import org.docx4j.XmlUtils;
import org.docx4j.finders.SectPrFinder;
import org.docx4j.model.structure.HeaderFooterPolicy;
import org.docx4j.model.structure.SectionWrapper;
import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
import org.docx4j.openpackaging.parts.PartName;
import org.docx4j.openpackaging.parts.WordprocessingML.BinaryPartAbstractImage;
import org.docx4j.openpackaging.parts.WordprocessingML.HeaderPart;
import org.docx4j.relationships.Relationship;
import org.docx4j.wml.HdrFtrRef;
import org.docx4j.wml.HeaderReference;
import org.docx4j.wml.ObjectFactory;
import org.docx4j.wml.P;
import org.docx4j.wml.SectPr;
import org.springframework.stereotype.Service;
import org.springframework.web.util.UriUtils;
import org.w3c.dom.Element;

import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.font.FontRenderContext;
import java.awt.font.TextLayout;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.awt.image.DataBufferInt;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.StringWriter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Collections;
import java.util.IdentityHashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

@Service
public class DmsDocxWatermarkService {
    private static final String W = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
    private static final String R = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
    private static final String WP = "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing";
    private static final String A = "http://schemas.openxmlformats.org/drawingml/2006/main";
    private static final String PIC = "http://schemas.openxmlformats.org/drawingml/2006/picture";
    private static final String WPS = "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
    private static final String W14 = "http://schemas.microsoft.com/office/word/2010/wordml";
    private static final Pattern PAGE_VARIABLE = Pattern.compile("\\{/((?:Curr|Total)Page)\\}");
    private static final String FILE_URL_PREFIX = "/api/file/Image/";
    private static final Map<String, String> NAMESPACES;
    private static final double DPI = 144D;
    private static final int MAX_TILED_MARKS = 300;
    private static final int MAX_IMAGE_WATERMARKS = 16;
    private static final int MAX_IMAGE_DRAW_WORK_MULTIPLIER = 8;
    private static final long MAX_IMAGE_MARK_SOURCE_BYTES = 10L * 1024L * 1024L;
    private static final int MAX_IMAGE_MARK_DIMENSION = 8_192;
    private static final long MAX_IMAGE_MARK_PIXELS = 4_000_000L;
    private static final int MAX_IMAGE_CODE128_CHARACTERS = 256;
    private static final int MAX_RASTER_MARK_DIMENSION = 16_384;
    private static final long MAX_RASTER_MARK_PIXELS = 16_000_000L;
    private static final int BARCODE_TEXT_FONT_SIZE = 10;
    private static final int BARCODE_TEXT_PADDING_PX = 2;
    private static final ObjectFactory WML = new ObjectFactory();

    static {
        Map<String, String> namespaces = new LinkedHashMap<>();
        namespaces.put("w", W);
        namespaces.put("r", R);
        namespaces.put("wp", WP);
        namespaces.put("a", A);
        namespaces.put("pic", PIC);
        namespaces.put("wps", WPS);
        namespaces.put("w14", W14);
        NAMESPACES = Collections.unmodifiableMap(namespaces);
    }

    private final DmsCommonFileStorage commonFileStorage;

    public DmsDocxWatermarkService(DmsCommonFileStorage commonFileStorage) {
        this.commonFileStorage = commonFileStorage;
    }

    public byte[] apply(byte[] source, List<DmsWatermarkSnapshot> watermarks) {
        if (watermarks == null || watermarks.isEmpty()) {
            return source;
        }
        if (watermarks.stream().anyMatch(mark -> mark.getRenderPages() != null)) {
            throw new DataException("指定页水印必须通过按页渲染服务处理");
        }
        try {
            WordprocessingMLPackage word = WordprocessingMLPackage.load(new ByteArrayInputStream(source));
            Map<HeaderPart, PageSize> targets = effectiveHeaders(word);
            List<DmsWatermarkSnapshot> staticMarks = new ArrayList<>();
            List<DmsWatermarkSnapshot> pageMarks = new ArrayList<>();
            for (DmsWatermarkSnapshot watermark : watermarks) {
                if ("TEXT".equalsIgnoreCase(value(watermark.getWatermarkType(), "TEXT"))
                        && PAGE_VARIABLE.matcher(value(watermark.getContent(), "")).find()) {
                    pageMarks.add(watermark);
                } else {
                    staticMarks.add(watermark);
                }
            }
            int drawingId = 1000;
            for (Map.Entry<HeaderPart, PageSize> target : targets.entrySet()) {
                if (!staticMarks.isEmpty()) {
                    byte[] overlay = renderOverlay(target.getValue(), staticMarks);
                    BinaryPartAbstractImage image = BinaryPartAbstractImage.createImagePart(
                            word, target.getKey(), overlay);
                    target.getKey().getContent().add(anchor(image.getRelLast().getId(),
                            target.getValue(), drawingId++));
                }
                for (DmsWatermarkSnapshot watermark : pageMarks) {
                    for (Point point : points(target.getValue(), watermark)) {
                        target.getKey().getContent().add(pageFieldAnchor(watermark, point, drawingId++));
                    }
                }
            }
            if (!pageMarks.isEmpty()) {
                org.docx4j.wml.BooleanDefaultTrue update = new org.docx4j.wml.BooleanDefaultTrue();
                update.setVal(true);
                org.docx4j.openpackaging.parts.WordprocessingML.DocumentSettingsPart settings =
                        word.getMainDocumentPart().getDocumentSettingsPart();
                if (settings == null) {
                    settings = new org.docx4j.openpackaging.parts.WordprocessingML.DocumentSettingsPart();
                    settings.setJaxbElement(WML.createCTSettings());
                    word.getMainDocumentPart().addTargetPart(settings);
                }
                settings.getJaxbElement().setUpdateFields(update);
            }
            ByteArrayOutputStream output = new ByteArrayOutputStream();
            word.save(output);
            return output.toByteArray();
        } catch (DataException exception) {
            throw exception;
        } catch (Exception exception) {
            throw new DataException("生成 DOCX 水印失败：" + message(exception));
        }
    }

    /** Reuse the existing bitmap/layout renderer for every distinct paper size in the source. */
    List<PageWatermarkRequest.Overlay> pageOverlays(byte[] source, List<DmsWatermarkSnapshot> marks) throws Exception {
        WordprocessingMLPackage word = WordprocessingMLPackage.load(new ByteArrayInputStream(source));
        Map<String, PageSize> sizes = new LinkedHashMap<>();
        for (SectionWrapper section : word.getDocumentModel().getSections()) {
            PageSize size = pageSize(section);
            sizes.put(size.width + ":" + size.height, size);
        }
        if (sizes.isEmpty()) sizes.put("A4", new PageSize(210D, 297D));
        if (sizes.size() > 64) throw new DataException("文档纸张规格过多，无法生成指定页水印");
        List<PageWatermarkRequest.Overlay> overlays = new ArrayList<>();
        long totalImageBytes = 0;
        for (DmsWatermarkSnapshot mark : marks) {
            if (mark.getRenderPages() == null || mark.getRenderPages().isEmpty()) {
                throw new DataException("指定页水印缺少页码数组");
            }
            // Each entry gets an independent drawing, including entries targeting the same page.
            List<PageWatermarkRequest.Variant> variants = new ArrayList<>();
            for (PageSize size : sizes.values()) {
                PositionedImage positioned = positionedImage(size, mark);
                byte[] image = positioned.png;
                totalImageBytes += image.length;
                if (totalImageBytes > 32_000_000) throw new DataException("指定页水印图片超过处理上限");
                variants.add(new PageWatermarkRequest.Variant(size.width, size.height,
                        positioned.width, positioned.height, positioned.x, positioned.y,
                        java.util.Base64.getEncoder().encodeToString(image)));
            }
            overlays.add(new PageWatermarkRequest.Overlay(List.copyOf(mark.getRenderPages()), variants));
        }
        return overlays;
    }

    private PositionedImage positionedImage(PageSize page, DmsWatermarkSnapshot watermark) throws Exception {
        if ("TILED".equalsIgnoreCase(watermark.getLayoutMode())) {
            return new PositionedImage(renderOverlay(page, Collections.singletonList(watermark)),
                    page.width, page.height, 0D, 0D);
        }
        double width = positive(watermark.getMarkWidthMm(), 80D);
        double height = positive(watermark.getMarkHeightMm(), 20D);
        Point point = points(page, watermark).get(0);
        double radians = Math.toRadians(Math.floorMod(value(watermark.getRotationAngle(), 0), 360));
        double drawingWidth = Math.abs(width * Math.cos(radians)) + Math.abs(height * Math.sin(radians));
        double drawingHeight = Math.abs(width * Math.sin(radians)) + Math.abs(height * Math.cos(radians));
        int canvasWidth = Math.max(1, px(drawingWidth));
        int canvasHeight = Math.max(1, px(drawingHeight));
        BufferedImage image = new BufferedImage(canvasWidth, canvasHeight, BufferedImage.TYPE_INT_ARGB);
        Graphics2D graphics = image.createGraphics();
        try {
            graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
            float opacity = Math.max(0, Math.min(100, value(watermark.getOpacity(), 100))) / 100F;
            graphics.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, opacity));
            graphics.translate(canvasWidth / 2D, canvasHeight / 2D);
            graphics.rotate(radians);
            graphics.drawImage(renderMark(watermark, width, height),
                    -px(width) / 2, -px(height) / 2, px(width), px(height), null);
        } finally {
            graphics.dispose();
        }
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        if (!ImageIO.write(image, "png", output)) {
            throw new DataException("当前运行环境不能生成 PNG 水印图层");
        }
        double x = clamp(point.x - (drawingWidth - width) / 2D, 0D, Math.max(0D, page.width - drawingWidth));
        double y = clamp(point.y - (drawingHeight - height) / 2D, 0D, Math.max(0D, page.height - drawingHeight));
        return new PositionedImage(output.toByteArray(), drawingWidth, drawingHeight, x, y);
    }

    private Map<HeaderPart, PageSize> effectiveHeaders(WordprocessingMLPackage word) throws Exception {
        Map<HeaderPart, PageSize> result = new IdentityHashMap<>();
        List<SectionWrapper> sections = word.getDocumentModel().getSections();
        if (sections.isEmpty()) {
            SectPr sectPr = defaultSectPr();
            word.getMainDocumentPart().getJaxbElement().getBody().setSectPr(sectPr);
            result.put(createDefaultHeader(word, sectPr), new PageSize(210D, 297D));
            return result;
        }
        SectPrFinder finder = new SectPrFinder(word.getMainDocumentPart());
        new org.docx4j.TraversalUtil(word.getMainDocumentPart().getJaxbElement(), finder);
        List<SectPr> actualSections = finder.getOrderedSectPrList();
        for (int index = 0; index < sections.size(); index++) {
            SectionWrapper section = sections.get(index);
            PageSize size = pageSize(section);
            HeaderFooterPolicy policy = section.getHeaderFooterPolicy();
            Set<HeaderPart> headers = Collections.newSetFromMap(new IdentityHashMap<>());
            if (policy != null) {
                add(headers, policy.getDefaultHeader());
                add(headers, policy.getFirstHeader());
                add(headers, policy.getEvenHeader());
            }
            if (headers.isEmpty()) {
                SectPr actual = index == sections.size() - 1
                        ? word.getMainDocumentPart().getJaxbElement().getBody().getSectPr()
                        : (index < actualSections.size() ? actualSections.get(index) : section.getSectPr());
                if (actual == null && index == sections.size() - 1) {
                    actual = section.getSectPr() == null ? defaultSectPr() : section.getSectPr();
                    word.getMainDocumentPart().getJaxbElement().getBody().setSectPr(actual);
                }
                headers.add(createDefaultHeader(word, actual));
            }
            for (HeaderPart header : headers) {
                result.putIfAbsent(header, size);
            }
        }
        return result;
    }

    private SectPr defaultSectPr() {
        SectPr sectPr = WML.createSectPr();
        SectPr.PgSz size = WML.createSectPrPgSz();
        size.setW(BigInteger.valueOf(11906));
        size.setH(BigInteger.valueOf(16838));
        sectPr.setPgSz(size);
        return sectPr;
    }

    private void add(Set<HeaderPart> headers, HeaderPart header) {
        if (header != null) {
            headers.add(header);
        }
    }

    private HeaderPart createDefaultHeader(WordprocessingMLPackage word, SectPr sectPr) throws Exception {
        HeaderPart header = new HeaderPart(new PartName("/word/header-dms-" +
                Math.abs(java.util.UUID.randomUUID().getMostSignificantBits()) + ".xml"));
        header.init();
        Relationship relationship = word.getMainDocumentPart().addTargetPart(header);
        HeaderReference reference = WML.createHeaderReference();
        reference.setId(relationship.getId());
        reference.setType(HdrFtrRef.DEFAULT);
        if (sectPr == null) {
            throw new DataException("DOCX 分节缺少页面设置");
        }
        sectPr.getEGHdrFtrReferences().add(reference);
        return header;
    }

    private PageSize pageSize(SectionWrapper section) {
        SectPr.PgSz pgSz = section.getPageDimensions().getPgSz();
        double width = pgSz == null || pgSz.getW() == null ? 210D : pgSz.getW().doubleValue() * 25.4D / 1440D;
        double height = pgSz == null || pgSz.getH() == null ? 297D : pgSz.getH().doubleValue() * 25.4D / 1440D;
        return new PageSize(width, height);
    }

    byte[] renderPdfOverlay(double widthMm, double heightMm,
                            List<DmsWatermarkSnapshot> watermarks) throws Exception {
        return renderOverlay(new PageSize(widthMm, heightMm), watermarks);
    }

    /** Use the export renderer for the configuration dialog, including custom TTC fonts. */
    public byte[] preview(double widthMm, double heightMm, DmsWatermarkSnapshot watermark) throws Exception {
        if (!Double.isFinite(widthMm) || !Double.isFinite(heightMm)
                || widthMm <= 0 || heightMm <= 0 || widthMm > 500 || heightMm > 500
                || watermark == null || watermark.getPositions() == null
                || watermark.getPositions().isEmpty() || watermark.getPositions().size() > 16) {
            throw new DataException("水印预览页面配置无效");
        }
        if (watermark.getContent() != null && watermark.getContent().length() > 2000
                || watermark.getFontSize() != null && (watermark.getFontSize() < 6 || watermark.getFontSize() > 144)
                || watermark.getRotationAngle() != null && Math.abs((long) watermark.getRotationAngle()) > 180
                || watermark.getOpacity() != null && (watermark.getOpacity() < 0 || watermark.getOpacity() > 100)) {
            throw new DataException("水印预览内容或效果配置无效");
        }
        for (BigDecimal dimension : new BigDecimal[]{watermark.getMarkWidthMm(), watermark.getMarkHeightMm()}) {
            if (dimension != null && (dimension.signum() <= 0 || dimension.compareTo(BigDecimal.valueOf(500)) > 0)) {
                throw new DataException("水印预览宽高超出范围");
            }
        }
        for (DmsWatermarkPositionSnapshot position : watermark.getPositions()) {
            if (position == null) throw new DataException("水印预览位置配置无效");
            for (BigDecimal coordinate : new BigDecimal[]{position.getPaperWidthMm(), position.getPaperHeightMm(),
                    position.getPortraitXMm(), position.getPortraitYMm(), position.getLandscapeXMm(), position.getLandscapeYMm()}) {
                if (coordinate != null && (coordinate.signum() < 0 || coordinate.compareTo(BigDecimal.valueOf(500)) > 0)) {
                    throw new DataException("水印预览位置超出范围");
                }
            }
        }
        if ("BARCODE".equalsIgnoreCase(watermark.getWatermarkType())
                && !"QR_CODE".equalsIgnoreCase(watermark.getBarcodeFormat())
                && value(watermark.getContent(), "").length() > MAX_IMAGE_CODE128_CHARACTERS) {
            throw new DataException("条码预览内容过长");
        }
        return renderPdfOverlay(widthMm, heightMm, Collections.singletonList(watermark));
    }

    private byte[] renderOverlay(PageSize page, List<DmsWatermarkSnapshot> watermarks) throws Exception {
        BufferedImage canvas = new BufferedImage(px(page.width), px(page.height), BufferedImage.TYPE_INT_ARGB);
        Graphics2D graphics = canvas.createGraphics();
        try {
            graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            graphics.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
            graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
            for (DmsWatermarkSnapshot watermark : watermarks) {
                renderWatermark(graphics, page, watermark);
            }
        } finally {
            graphics.dispose();
        }
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        if (!ImageIO.write(canvas, "png", output)) {
            throw new DataException("当前运行环境不能生成 PNG 水印图层");
        }
        return output.toByteArray();
    }

    /**
     * Renders the existing millimetre-based watermark configuration on a raster image.
     * The closest configured paper ratio supplies the reference coordinate system, while
     * the watermark itself keeps its aspect ratio on non-paper-sized images.
     */
    void applyImageWatermarks(BufferedImage canvas,
                              List<DmsWatermarkSnapshot> watermarks) throws Exception {
        if (canvas == null || canvas.getWidth() <= 0 || canvas.getHeight() <= 0) {
            throw new DataException("图片尺寸无效，无法生成水印");
        }
        if (watermarks == null || watermarks.isEmpty()) {
            return;
        }
        if (watermarks.size() > MAX_IMAGE_WATERMARKS) {
            throw new DataException("单张图片最多支持 " + MAX_IMAGE_WATERMARKS + " 个水印");
        }
        long remainingWork = (long) canvas.getWidth() * canvas.getHeight()
                * MAX_IMAGE_DRAW_WORK_MULTIPLIER;
        Graphics2D graphics = canvas.createGraphics();
        try {
            graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            graphics.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
            graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
            for (DmsWatermarkSnapshot watermark : watermarks) {
                remainingWork = renderImageWatermark(graphics, canvas.getWidth(), canvas.getHeight(),
                        watermark, remainingWork);
            }
        } finally {
            graphics.dispose();
        }
    }

    private long renderImageWatermark(Graphics2D graphics, int canvasWidth, int canvasHeight,
                                      DmsWatermarkSnapshot watermark, long remainingWork) throws Exception {
        if (watermark == null) {
            throw new DataException("图片水印配置无效");
        }
        ImageReference reference = closestImageReference(canvasWidth, canvasHeight, watermark.getPositions());
        double scaleX = canvasWidth / reference.width;
        double scaleY = canvasHeight / reference.height;
        double markScale = Math.min(scaleX, scaleY);
        double widthMm = positive(watermark.getMarkWidthMm(), 80D);
        double heightMm = positive(watermark.getMarkHeightMm(), 20D);
        double markWidth = Math.max(1D, widthMm * markScale);
        double markHeight = Math.max(1D, heightMm * markScale);
        double originX = reference.x * scaleX;
        double originY = reference.y * scaleY;
        validateImageWatermarkGeometry(markWidth, markHeight, originX, originY);
        List<Point> points;
        if ("TILED".equalsIgnoreCase(watermark.getLayoutMode())) {
            points = tiledPoints(new PageSize(canvasWidth, canvasHeight),
                    originX, originY,
                    markWidth, markHeight,
                    nonNegative(watermark.getRepeatSpacingXMm(), 20D) * scaleX,
                    nonNegative(watermark.getRepeatSpacingYMm(), 20D) * scaleY);
        } else {
            points = Collections.singletonList(new Point(originX, originY));
        }

        int targetWidth = imageTargetDimension(markWidth);
        int targetHeight = imageTargetDimension(markHeight);
        int rotationAngle = value(watermark.getRotationAngle(), 0);
        List<Point> visiblePoints = new ArrayList<>();
        long drawWork = 0L;
        for (Point point : points) {
            long visiblePixels = visiblePixels(point, targetWidth, targetHeight,
                    canvasWidth, canvasHeight, rotationAngle);
            if (visiblePixels > 0L) {
                visiblePoints.add(point);
                drawWork += visiblePixels;
            }
        }
        if (drawWork > remainingWork) {
            throw new DataException("图片水印绘制量超过处理上限");
        }
        if (visiblePoints.isEmpty()) {
            return remainingWork;
        }
        RasterSize raster = boundedRasterSize(targetWidth, targetHeight, canvasWidth, canvasHeight);
        double renderScale = Math.min(raster.width / (double) Math.max(1, px(widthMm)),
                raster.height / (double) Math.max(1, px(heightMm)));
        BufferedImage mark = renderMarkPixels(watermark, raster.width, raster.height, renderScale, true);
        float opacity = Math.max(0, Math.min(100, value(watermark.getOpacity(), 100))) / 100F;
        boolean barcode = "BARCODE".equalsIgnoreCase(value(watermark.getWatermarkType(), "TEXT"));
        for (Point point : visiblePoints) {
            Graphics2D layer = (Graphics2D) graphics.create();
            try {
                layer.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, opacity));
                layer.setRenderingHint(RenderingHints.KEY_INTERPOLATION, barcode
                        ? RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR
                        : RenderingHints.VALUE_INTERPOLATION_BICUBIC);
                int x = (int) Math.round(point.x);
                int y = (int) Math.round(point.y);
                layer.rotate(Math.toRadians(rotationAngle),
                        x + targetWidth / 2D, y + targetHeight / 2D);
                layer.drawImage(mark, x, y, targetWidth, targetHeight, null);
            } finally {
                layer.dispose();
            }
        }
        return remainingWork - drawWork;
    }

    private void validateImageWatermarkGeometry(double width, double height, double x, double y) {
        if (!Double.isFinite(width) || !Double.isFinite(height)
                || !Double.isFinite(x) || !Double.isFinite(y)) {
            throw new DataException("图片水印尺寸或位置无效");
        }
    }

    private int imageTargetDimension(double value) {
        long rounded = Math.round(value);
        if (rounded <= 0L || rounded > Integer.MAX_VALUE) {
            throw new DataException("图片水印绘制量超过处理上限");
        }
        return (int) rounded;
    }

    private RasterSize boundedRasterSize(int targetWidth, int targetHeight,
                                         int canvasWidth, int canvasHeight) {
        double scale = Math.min(1D, Math.min(canvasWidth / (double) targetWidth,
                canvasHeight / (double) targetHeight));
        scale = Math.min(scale, Math.min(MAX_RASTER_MARK_DIMENSION / (double) targetWidth,
                MAX_RASTER_MARK_DIMENSION / (double) targetHeight));
        double pixels = (double) targetWidth * targetHeight;
        if (pixels * scale * scale > MAX_RASTER_MARK_PIXELS) {
            scale = Math.min(scale, Math.sqrt(MAX_RASTER_MARK_PIXELS / pixels));
        }
        return new RasterSize(Math.max(1, (int) Math.round(targetWidth * scale)),
                Math.max(1, (int) Math.round(targetHeight * scale)));
    }

    private long visiblePixels(Point point, int width, int height,
                               int canvasWidth, int canvasHeight, int rotationAngle) {
        double radians = Math.toRadians(Math.floorMod(rotationAngle, 360));
        double rotatedWidth = Math.abs(width * Math.cos(radians)) + Math.abs(height * Math.sin(radians));
        double rotatedHeight = Math.abs(width * Math.sin(radians)) + Math.abs(height * Math.cos(radians));
        double left = point.x - (rotatedWidth - width) / 2D;
        double top = point.y - (rotatedHeight - height) / 2D;
        double visibleWidth = Math.max(0D,
                Math.min(canvasWidth, left + rotatedWidth) - Math.max(0D, left));
        double visibleHeight = Math.max(0D,
                Math.min(canvasHeight, top + rotatedHeight) - Math.max(0D, top));
        return (long) Math.ceil(visibleWidth) * (long) Math.ceil(visibleHeight);
    }

    private ImageReference closestImageReference(int canvasWidth, int canvasHeight,
                                                 List<DmsWatermarkPositionSnapshot> positions) {
        if (positions == null || positions.isEmpty()) {
            throw new DataException("水印配置缺少页面位置");
        }
        boolean landscape = canvasWidth > canvasHeight;
        double imageRatio = (double) canvasWidth / canvasHeight;
        ImageReference best = null;
        double bestDistance = Double.MAX_VALUE;
        for (DmsWatermarkPositionSnapshot position : positions) {
            double width = positive(position.getPaperWidthMm(), 210D);
            double height = positive(position.getPaperHeightMm(), 297D);
            if (landscape != (width > height)) {
                double swapped = width;
                width = height;
                height = swapped;
            }
            double distance = Math.abs(Math.log(imageRatio / (width / height)));
            if (distance < bestDistance) {
                BigDecimal x = landscape ? position.getLandscapeXMm() : position.getPortraitXMm();
                BigDecimal y = landscape ? position.getLandscapeYMm() : position.getPortraitYMm();
                best = new ImageReference(width, height,
                        x == null ? 0D : x.doubleValue(), y == null ? 0D : y.doubleValue());
                bestDistance = distance;
            }
        }
        return best;
    }

    private void renderWatermark(Graphics2D graphics, PageSize page,
                                 DmsWatermarkSnapshot watermark) throws Exception {
        double width = positive(watermark.getMarkWidthMm(), 80D);
        double height = positive(watermark.getMarkHeightMm(), 20D);
        List<Point> points = points(page, watermark);
        BufferedImage mark = renderMark(watermark, width, height);
        float opacity = Math.max(0, Math.min(100, value(watermark.getOpacity(), 100))) / 100F;
        for (Point point : points) {
            Graphics2D layer = (Graphics2D) graphics.create();
            try {
                layer.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, opacity));
                int x = pixelOffset(point.x);
                int y = pixelOffset(point.y);
                int markWidth = px(width);
                int markHeight = px(height);
                layer.rotate(Math.toRadians(value(watermark.getRotationAngle(), 0)),
                        x + markWidth / 2D, y + markHeight / 2D);
                layer.drawImage(mark, x, y, markWidth, markHeight, null);
            } finally {
                layer.dispose();
            }
        }
    }

    private BufferedImage renderMark(DmsWatermarkSnapshot watermark, double width, double height) throws Exception {
        int imageWidth = Math.max(1, px(width));
        int imageHeight = Math.max(1, px(height));
        return renderMarkPixels(watermark, imageWidth, imageHeight, 1D, false);
    }

    private BufferedImage renderMarkPixels(DmsWatermarkSnapshot watermark, int imageWidth,
                                           int imageHeight, double renderScale,
                                           boolean imageTarget) throws Exception {
        String type = value(watermark.getWatermarkType(), "TEXT").toUpperCase(Locale.ROOT);
        if ("IMAGE".equals(type)) {
            return fitImage(loadImage(watermark.getImageUrl()), imageWidth, imageHeight);
        }
        if ("BARCODE".equals(type)) {
            return barcode(watermark, imageWidth, imageHeight, renderScale, imageTarget);
        }
        return text(watermark, imageWidth, imageHeight, renderScale);
    }

    private BufferedImage text(DmsWatermarkSnapshot watermark, int width, int height) {
        return text(watermark, width, height, 1D);
    }

    private BufferedImage text(DmsWatermarkSnapshot watermark, int width, int height,
                               double renderScale) {
        String content = value(watermark.getContent(), "");
        String[] lines = content.split("\\R", -1);
        int requestedSize = Math.max(1, value(watermark.getFontSize(), 24));
        Font font = chooseFont(watermark.getFontFamily(), content, requestedSize, renderScale);
        TextLayout[] layouts = new TextLayout[lines.length];
        Rectangle[] lineBounds = new Rectangle[lines.length];
        String horizontal = horizontalAlignment(watermark);
        Rectangle ink = null;
        int lineHeight;
        BufferedImage sample = new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB);
        Graphics2D measure = sample.createGraphics();
        try {
            measure.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            measure.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
            measure.setFont(font);
            FontMetrics metrics = measure.getFontMetrics();
            lineHeight = metrics.getHeight();
            FontRenderContext context = measure.getFontRenderContext();
            for (int i = 0; i < lines.length; i++) {
                if (lines[i].isEmpty()) {
                    continue;
                }
                layouts[i] = new TextLayout(lines[i], font, context);
                Rectangle lineInk = layouts[i].getPixelBounds(context, 0, i * lineHeight);
                lineBounds[i] = lineInk;
                if (!lineInk.isEmpty()) {
                    ink = ink == null ? lineInk : ink.union(lineInk);
                }
            }
        } finally {
            measure.dispose();
        }
        if (ink == null) {
            return new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
        }
        int padding = Math.min(128, Math.max(4, font.getSize()));
        BufferedImage temporary = new BufferedImage(Math.addExact(width, padding * 2),
                Math.addExact(height, padding * 2), BufferedImage.TYPE_INT_ARGB);
        Graphics2D graphics = temporary.createGraphics();
        try {
            graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            graphics.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
            graphics.setColor(parseColor(watermark.getFontColor()));
            for (int i = 0; i < layouts.length; i++) {
                if (layouts[i] != null) {
                    Rectangle bounds = lineBounds[i];
                    int x = "LEFT".equals(horizontal) ? padding - ink.x
                            : padding - bounds.x + alignmentOffset(width, bounds.width, horizontal);
                    layouts[i].draw(graphics, x,
                            padding + i * lineHeight - ink.y);
                }
            }
        } finally {
            graphics.dispose();
        }
        return alignTextInk(temporary, width, height,
                "LEFT".equals(horizontal) ? null : padding, verticalAlignment(watermark));
    }

    private BufferedImage alignTextInk(BufferedImage source, int width, int height,
                                       Integer horizontalOrigin, String vertical) {
        int sourceWidth = source.getWidth();
        int left = sourceWidth;
        int top = source.getHeight();
        int bottom = -1;
        int[] pixels = ((DataBufferInt) source.getRaster().getDataBuffer()).getData();
        for (int y = 0; y < source.getHeight(); y++) {
            for (int x = 0; x < sourceWidth; x++) {
                if ((pixels[y * sourceWidth + x] >>> 24) != 0) {
                    left = Math.min(left, x);
                    top = Math.min(top, y);
                    bottom = Math.max(bottom, y);
                }
            }
        }
        BufferedImage aligned = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
        if (left == sourceWidth) {
            return aligned;
        }
        Graphics2D graphics = aligned.createGraphics();
        try {
            int y = alignmentOffset(height, bottom - top + 1, vertical) - top;
            // Keep the per-line X offsets; trimming the whole image would undo centering.
            graphics.drawImage(source, -(horizontalOrigin == null ? left : horizontalOrigin), y, null);
        } finally {
            graphics.dispose();
        }
        return aligned;
    }

    private int alignmentOffset(int available, int content, String alignment) {
        int remaining = Math.max(0, available - content);
        return switch (alignment) {
            case "CENTER", "MIDDLE" -> remaining / 2;
            case "RIGHT", "BOTTOM" -> remaining;
            default -> 0;
        };
    }

    private String horizontalAlignment(DmsWatermarkSnapshot watermark) {
        return "POSITION".equalsIgnoreCase(value(watermark.getLayoutMode(), "POSITION"))
                ? value(watermark.getHorizontalAlign(), "LEFT").toUpperCase(Locale.ROOT) : "LEFT";
    }

    private String verticalAlignment(DmsWatermarkSnapshot watermark) {
        return "POSITION".equalsIgnoreCase(value(watermark.getLayoutMode(), "POSITION"))
                ? value(watermark.getVerticalAlign(), "TOP").toUpperCase(Locale.ROOT) : "TOP";
    }

    private Font chooseFont(String requested, String content, int points) {
        return chooseFont(requested, content, points, 1D);
    }

    private Font chooseFont(String requested, String content, int points, double renderScale) {
        return DmsWatermarkFonts.configured().choose(requested, content,
                Math.max(1, (int) Math.round(points * DPI / 72D * Math.max(0.01D, renderScale))));
    }

    private Color parseColor(String value) {
        String color = value(value, "#666666").trim();
        try {
            if (color.matches("#[0-9a-fA-F]{6}")) {
                return Color.decode(color);
            }
            if (color.matches("#[0-9a-fA-F]{8}")) {
                return new Color((int) Long.parseLong(color.substring(1), 16), true);
            }
        } catch (NumberFormatException ignored) {
            // Configuration validation normally prevents this fallback.
        }
        return Color.DARK_GRAY;
    }

    BufferedImage barcode(DmsWatermarkSnapshot watermark, int width, int height) throws Exception {
        return barcode(watermark, width, height, 1D, false);
    }

    private BufferedImage barcode(DmsWatermarkSnapshot watermark, int width, int height,
                                  double renderScale, boolean imageTarget) throws Exception {
        String configuredFormat = watermark.getBarcodeFormat();
        if (!"QR_CODE".equalsIgnoreCase(configuredFormat)
                && !"CODE_128".equalsIgnoreCase(configuredFormat)) {
            throw new DataException("不支持的水印条码格式，请选择 Code 128 或二维码");
        }
        BarcodeFormat format = BarcodeFormat.valueOf(configuredFormat.toUpperCase(Locale.ROOT));
        String content = value(watermark.getContent(), " ");
        if (imageTarget && format == BarcodeFormat.CODE_128
                && content.length() > MAX_IMAGE_CODE128_CHARACTERS) {
            throw new DataException("图片 Code 128 水印内容过长");
        }
        if (!Boolean.TRUE.equals(watermark.getShowBarcodeText())) {
            return barcodeSymbol(content, format, width, height);
        }

        String label = watermark.getBarcodeText() == null ? content : watermark.getBarcodeText();
        Font font = chooseFont(watermark.getFontFamily(), label, BARCODE_TEXT_FONT_SIZE, renderScale);
        int textPadding = Math.max(1,
                (int) Math.round(BARCODE_TEXT_PADDING_PX * Math.max(0.01D, renderScale)));
        BufferedImage metricsImage = new BufferedImage(1, 1, BufferedImage.TYPE_INT_ARGB);
        Graphics2D metricsGraphics = metricsImage.createGraphics();
        int textHeight;
        try {
            metricsGraphics.setFont(font);
            textHeight = metricsGraphics.getFontMetrics().getHeight() + textPadding * 2;
        } finally {
            metricsGraphics.dispose();
        }
        int symbolHeight = Math.max(1, height - textHeight);
        BufferedImage symbol = barcodeSymbol(content, format, width, symbolHeight);
        int imageWidth = Math.max(width, symbol.getWidth());
        int imageHeight = Math.max(height, symbol.getHeight() + textHeight);
        BufferedImage image = new BufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_INT_ARGB);
        Graphics2D graphics = image.createGraphics();
        try {
            graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            graphics.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
            graphics.drawImage(symbol, (imageWidth - symbol.getWidth()) / 2, 0, null);
            graphics.setFont(font);
            graphics.setColor(Color.BLACK);
            FontMetrics metrics = graphics.getFontMetrics();
            int textX = Math.max(textPadding,
                    (imageWidth - metrics.stringWidth(label)) / 2);
            int baseline = imageHeight - textPadding - metrics.getDescent();
            graphics.drawString(label, textX, baseline);
        } finally {
            graphics.dispose();
        }
        return image;
    }

    private BufferedImage barcodeSymbol(String content, BarcodeFormat format,
                                        int width, int height) throws Exception {
        Map<EncodeHintType, Object> hints = new LinkedHashMap<>();
        hints.put(EncodeHintType.CHARACTER_SET, StandardCharsets.UTF_8.name());
        BitMatrix matrix = new MultiFormatWriter().encode(content, format, width, height, hints);
        long pixels = (long) matrix.getWidth() * matrix.getHeight();
        if (matrix.getWidth() > MAX_RASTER_MARK_DIMENSION
                || matrix.getHeight() > MAX_RASTER_MARK_DIMENSION
                || pixels > MAX_RASTER_MARK_PIXELS) {
            throw new DataException("条码处理量超过系统安全上限");
        }
        BufferedImage image = new BufferedImage(matrix.getWidth(), matrix.getHeight(), BufferedImage.TYPE_INT_ARGB);
        for (int y = 0; y < matrix.getHeight(); y++) {
            for (int x = 0; x < matrix.getWidth(); x++) {
                if (matrix.get(x, y)) {
                    image.setRGB(x, y, Color.BLACK.getRGB());
                }
            }
        }
        return image;
    }

    private BufferedImage loadImage(String imageUrl) throws Exception {
        if (imageUrl == null || imageUrl.trim().isEmpty()) {
            throw new DataException("图片水印缺少图片文件");
        }
        String value = imageUrl.trim();
        if (value.startsWith("data:image/")) {
            int comma = value.indexOf(',');
            if (comma < 0 || !value.substring(0, comma).endsWith(";base64")) {
                throw new DataException("图片水印的 data URI 格式不正确");
            }
            String encoded = value.substring(comma + 1);
            long maxEncodedLength = ((MAX_IMAGE_MARK_SOURCE_BYTES + 2L) / 3L) * 4L + 4L;
            if (encoded.length() > maxEncodedLength) {
                throw new DataException("图片水印素材超过处理上限（10 MB）");
            }
            try {
                byte[] bytes = java.util.Base64.getDecoder().decode(encoded);
                if (bytes.length > MAX_IMAGE_MARK_SOURCE_BYTES) {
                    throw new DataException("图片水印素材超过处理上限（10 MB）");
                }
                return readImage(bytes);
            } catch (IllegalArgumentException exception) {
                throw new DataException("图片水印的 data URI 格式不正确");
            }
        }
        FileSource source = parseFileSource(value);
        final BufferedImage[] image = new BufferedImage[1];
        commonFileStorage.download(source.type, source.fileName, input -> {
            try {
                image[0] = readImage(input);
            } catch (Exception exception) {
                throw new ImageReadException(exception);
            }
        });
        if (image[0] == null) {
            throw new DataException("图片水印文件内容为空");
        }
        return image[0];
    }

    private BufferedImage readImage(InputStream input) throws Exception {
        DmsBoundedByteArrayOutputStream bytes = new DmsBoundedByteArrayOutputStream(
                MAX_IMAGE_MARK_SOURCE_BYTES, "图片水印素材超过处理上限（10 MB）");
        input.transferTo(bytes);
        return readImage(bytes.toByteArrayAndRelease());
    }

    private BufferedImage readImage(byte[] source) throws Exception {
        try (DmsByteArrayImageInputStream input = new DmsByteArrayImageInputStream(source)) {
            java.util.Iterator<ImageReader> readers = ImageIO.getImageReaders(input);
            if (!readers.hasNext()) {
                throw new DataException("图片水印仅支持可识别的图片格式");
            }
            ImageReader reader = readers.next();
            try {
                reader.setInput(input, false, false);
                int width = reader.getWidth(0);
                int height = reader.getHeight(0);
                long pixels = (long) width * height;
                if (width <= 0 || height <= 0
                        || width > MAX_IMAGE_MARK_DIMENSION || height > MAX_IMAGE_MARK_DIMENSION
                        || pixels > MAX_IMAGE_MARK_PIXELS) {
                    throw new DataException("图片水印素材尺寸超过处理上限");
                }
                BufferedImage image = reader.read(0);
                if (image == null) {
                    throw new DataException("图片水印仅支持可识别的图片格式");
                }
                return image;
            } finally {
                reader.dispose();
            }
        }
    }

    private FileSource parseFileSource(String value) {
        try {
            URI uri = URI.create(value);
            String path = uri.getRawPath();
            int index = path == null ? -1 : path.indexOf(FILE_URL_PREFIX);
            if (index < 0) {
                throw new DataException("图片水印必须来自 file-common");
            }
            String[] parts = path.substring(index + FILE_URL_PREFIX.length()).split("/", -1);
            if (parts.length != 2) {
                throw new DataException("图片水印文件地址格式不正确");
            }
            String type = decode(parts[0]);
            String fileName = decode(parts[1]);
            validateSegment(type);
            validateSegment(fileName);
            return new FileSource(type, fileName);
        } catch (DataException exception) {
            throw exception;
        } catch (IllegalArgumentException exception) {
            throw new DataException("图片水印文件地址格式不正确");
        }
    }

    private String decode(String value) {
        return UriUtils.decode(value, StandardCharsets.UTF_8);
    }

    private void validateSegment(String value) {
        if (value == null || value.trim().isEmpty() || value.contains("/") || value.contains("\\")
                || ".".equals(value) || "..".equals(value)) {
            throw new DataException("图片水印文件地址不合法");
        }
    }

    private BufferedImage fitImage(BufferedImage source, int width, int height) {
        BufferedImage result = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
        double scale = Math.min((double) width / source.getWidth(), (double) height / source.getHeight());
        int targetWidth = Math.max(1, (int) Math.round(source.getWidth() * scale));
        int targetHeight = Math.max(1, (int) Math.round(source.getHeight() * scale));
        int x = (width - targetWidth) / 2;
        int y = (height - targetHeight) / 2;
        Graphics2D graphics = result.createGraphics();
        try {
            graphics.setRenderingHint(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
            graphics.drawImage(source, x, y, targetWidth, targetHeight, null);
        } finally {
            graphics.dispose();
        }
        return result;
    }

    private DmsWatermarkPositionSnapshot closestPosition(PageSize page,
                                                           List<DmsWatermarkPositionSnapshot> positions) {
        if (positions == null || positions.isEmpty()) {
            throw new DataException("水印配置缺少页面位置");
        }
        DmsWatermarkPositionSnapshot best = null;
        double bestDistance = Double.MAX_VALUE;
        for (DmsWatermarkPositionSnapshot candidate : positions) {
            double width = positive(candidate.getPaperWidthMm(), 210D);
            double height = positive(candidate.getPaperHeightMm(), 297D);
            double direct = Math.abs(width - page.width) + Math.abs(height - page.height);
            double rotated = Math.abs(height - page.width) + Math.abs(width - page.height);
            double distance = Math.min(direct, rotated);
            if (distance < bestDistance) {
                best = candidate;
                bestDistance = distance;
            }
        }
        return best;
    }

    private double coordinate(PageSize page, DmsWatermarkPositionSnapshot position, boolean x) {
        boolean landscape = page.width > page.height;
        BigDecimal value;
        if (landscape) {
            value = x ? position.getLandscapeXMm() : position.getLandscapeYMm();
        } else {
            value = x ? position.getPortraitXMm() : position.getPortraitYMm();
        }
        return value == null ? 0D : value.doubleValue();
    }

    private List<Point> tiledPoints(PageSize page, double originX, double originY,
                                    double width, double height, double spacingX, double spacingY) {
        double stepX = Math.max(1D, width + spacingX);
        double stepY = Math.max(1D, height + spacingY);
        double startX = originX;
        double startY = originY;
        while (startX - stepX > -width) {
            startX -= stepX;
        }
        while (startY - stepY > -height) {
            startY -= stepY;
        }
        List<Point> points = new ArrayList<>();
        for (double y = startY; y < page.height && points.size() < MAX_TILED_MARKS; y += stepY) {
            for (double x = startX; x < page.width && points.size() < MAX_TILED_MARKS; x += stepX) {
                points.add(new Point(x, y));
            }
        }
        return points;
    }

    private List<Point> points(PageSize page, DmsWatermarkSnapshot watermark) {
        DmsWatermarkPositionSnapshot position = closestPosition(page, watermark.getPositions());
        double x = coordinate(page, position, true);
        double y = coordinate(page, position, false);
        double width = positive(watermark.getMarkWidthMm(), 80D);
        double height = positive(watermark.getMarkHeightMm(), 20D);
        if ("TILED".equalsIgnoreCase(watermark.getLayoutMode())) {
            return tiledPoints(page, x, y, width, height,
                    nonNegative(watermark.getRepeatSpacingXMm(), 20D),
                    nonNegative(watermark.getRepeatSpacingYMm(), 20D));
        }
        return Collections.singletonList(new Point(
                clamp(x, 0D, Math.max(0D, page.width - width)),
                clamp(y, 0D, Math.max(0D, page.height - height))));
    }

    private double clamp(double value, double minimum, double maximum) {
        return Math.max(minimum, Math.min(maximum, value));
    }

    // Page numbers must remain Word fields: a repeated header image cannot vary per page.
    private P pageFieldAnchor(DmsWatermarkSnapshot watermark, Point point, int id) throws Exception {
        double width = positive(watermark.getMarkWidthMm(), 80D);
        double height = positive(watermark.getMarkHeightMm(), 20D);
        org.w3c.dom.Document xml = newXml("w:p");
        Element paragraph = xml.getDocumentElement();
        add(add(paragraph, "w:pPr"), "w:spacing", "w:before", "0", "w:after", "0",
                "w:line", "1", "w:lineRule", "exact");
        Element drawing = add(add(paragraph, "w:r"), "w:drawing");
        Element anchor = add(drawing, "wp:anchor", "distT", "0", "distB", "0", "distL", "0", "distR", "0",
                "simplePos", "0", "relativeHeight", "1", "behindDoc", "1", "locked", "1",
                "layoutInCell", "1", "allowOverlap", "1");
        add(anchor, "wp:simplePos", "x", "0", "y", "0");
        add(add(anchor, "wp:positionH", "relativeFrom", "page"), "wp:posOffset").setTextContent(emu(point.x));
        add(add(anchor, "wp:positionV", "relativeFrom", "page"), "wp:posOffset").setTextContent(emu(point.y));
        add(anchor, "wp:extent", "cx", emu(width), "cy", emu(height));
        add(anchor, "wp:effectExtent", "l", "0", "t", "0", "r", "0", "b", "0");
        add(anchor, "wp:wrapNone");
        add(anchor, "wp:docPr", "id", Integer.toString(id), "name", "DMS_PAGE_WATERMARK_" + id);
        add(add(anchor, "wp:cNvGraphicFramePr"), "a:graphicFrameLocks",
                "noSelect", "1", "noMove", "1", "noResize", "1");
        Element shape = add(add(add(anchor, "a:graphic"), "a:graphicData", "uri", WPS), "wps:wsp");
        add(shape, "wps:cNvSpPr", "txBox", "1");
        Element properties = add(shape, "wps:spPr");
        Element transform = add(properties, "a:xfrm", "rot",
                Long.toString(Math.floorMod(value(watermark.getRotationAngle(), 0), 360) * 60000L));
        add(transform, "a:off", "x", "0", "y", "0");
        add(transform, "a:ext", "cx", emu(width), "cy", emu(height));
        add(add(properties, "a:prstGeom", "prst", "rect"), "a:avLst");
        add(properties, "a:noFill");
        add(add(properties, "a:ln"), "a:noFill");
        Element content = add(add(shape, "wps:txbx"), "w:txbxContent");
        for (String line : value(watermark.getContent(), "").split("\\R", -1)) {
            Element p = add(content, "w:p");
            Element pPr = add(p, "w:pPr");
            add(pPr, "w:spacing", "w:before", "0", "w:after", "0");
            add(pPr, "w:jc", "w:val", horizontalAlignment(watermark).toLowerCase(Locale.ROOT));
            Matcher matcher = PAGE_VARIABLE.matcher(line);
            int start = 0;
            while (matcher.find()) {
                fieldText(p, line.substring(start, matcher.start()), watermark);
                add(fieldRun(p, watermark), "w:fldChar", "w:fldCharType", "begin", "w:dirty", "true");
                Element instruction = add(fieldRun(p, watermark), "w:instrText");
                instruction.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:space", "preserve");
                instruction.setTextContent("CurrPage".equals(matcher.group(1)) ? " PAGE " : " NUMPAGES ");
                add(fieldRun(p, watermark), "w:fldChar", "w:fldCharType", "separate");
                fieldText(p, "1", watermark);
                add(fieldRun(p, watermark), "w:fldChar", "w:fldCharType", "end");
                start = matcher.end();
            }
            fieldText(p, line.substring(start), watermark);
        }
        // OnlyOffice sizes a no-wrap header textbox from its first-page field values.
        // When PAGE gains a digit (9 -> 10), that cached width clips the end of NUMPAGES.
        // Lay out text within the configured box on every page instead.
        String verticalAnchor = switch (verticalAlignment(watermark)) {
            case "MIDDLE" -> "ctr";
            case "BOTTOM" -> "b";
            default -> "t";
        };
        Element body = add(shape, "wps:bodyPr", "rot", "0", "vert", "horz", "wrap", "square",
                "lIns", "0", "tIns", "0", "rIns", "0", "bIns", "0", "anchor", verticalAnchor);
        add(body, "a:noAutofit");
        return (P) unmarshal(xml);
    }

    private void fieldText(Element paragraph, String value, DmsWatermarkSnapshot watermark) {
        if (!value.isEmpty()) {
            Element text = add(fieldRun(paragraph, watermark), "w:t");
            text.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:space", "preserve");
            text.setTextContent(value);
        }
    }

    private Element fieldRun(Element paragraph, DmsWatermarkSnapshot watermark) {
        Element run = add(paragraph, "w:r");
        Element properties = add(run, "w:rPr");
        String font = chooseFont(watermark.getFontFamily(), value(watermark.getContent(), ""),
                value(watermark.getFontSize(), 24)).getFamily(Locale.ENGLISH);
        add(properties, "w:rFonts", "w:ascii", font, "w:hAnsi", font, "w:eastAsia", font, "w:cs", font);
        Color color = parseColor(watermark.getFontColor());
        String rgb = String.format(Locale.ROOT, "%06X", color.getRGB() & 0xFFFFFF);
        add(properties, "w:color", "w:val", rgb);
        String size = Integer.toString(Math.max(1, value(watermark.getFontSize(), 24)) * 2);
        add(properties, "w:sz", "w:val", size);
        add(properties, "w:szCs", "w:val", size);
        Element fill = add(add(add(properties, "w14:textFill"), "w14:solidFill"), "w14:srgbClr", "w14:val", rgb);
        double opacity = Math.max(0, Math.min(100, value(watermark.getOpacity(), 100)))
                * color.getAlpha() / 255D;
        int transparency = (int) Math.round((100D - opacity) * 1000D);
        add(fill, "w14:alpha", "w14:val", Integer.toString(transparency));
        return run;
    }

    private P anchor(String relationshipId, PageSize page, int id) throws Exception {
        org.w3c.dom.Document xml = newXml("w:p");
        Element paragraph = xml.getDocumentElement();
        add(add(paragraph, "w:pPr"), "w:spacing", "w:before", "0", "w:after", "0",
                "w:line", "1", "w:lineRule", "exact");
        Element drawing = add(add(paragraph, "w:r"), "w:drawing");
        Element anchor = add(drawing, "wp:anchor", "distT", "0", "distB", "0", "distL", "0", "distR", "0",
                "simplePos", "0", "relativeHeight", "0", "behindDoc", "1", "locked", "1",
                "layoutInCell", "1", "allowOverlap", "1");
        add(anchor, "wp:simplePos", "x", "0", "y", "0");
        add(add(anchor, "wp:positionH", "relativeFrom", "page"), "wp:posOffset").setTextContent("0");
        add(add(anchor, "wp:positionV", "relativeFrom", "page"), "wp:posOffset").setTextContent("0");
        add(anchor, "wp:extent", "cx", emu(page.width), "cy", emu(page.height));
        add(anchor, "wp:effectExtent", "l", "0", "t", "0", "r", "0", "b", "0");
        add(anchor, "wp:wrapNone");
        add(anchor, "wp:docPr", "id", Integer.toString(id), "name", "DMS_WATERMARK_" + id,
                "descr", "Dynamic DMS preview watermark");
        add(add(anchor, "wp:cNvGraphicFramePr"), "a:graphicFrameLocks", "noChangeAspect", "1",
                "noSelect", "1", "noMove", "1", "noResize", "1");
        Element data = add(add(anchor, "a:graphic"), "a:graphicData", "uri", PIC);
        Element picture = add(data, "pic:pic");
        Element nonVisual = add(picture, "pic:nvPicPr");
        add(nonVisual, "pic:cNvPr", "id", Integer.toString(id), "name", "dms-watermark.png");
        add(nonVisual, "pic:cNvPicPr");
        Element fill = add(picture, "pic:blipFill");
        add(fill, "a:blip", "r:embed", relationshipId);
        add(add(fill, "a:stretch"), "a:fillRect");
        Element properties = add(picture, "pic:spPr");
        Element transform = add(properties, "a:xfrm");
        add(transform, "a:off", "x", "0", "y", "0");
        add(transform, "a:ext", "cx", emu(page.width), "cy", emu(page.height));
        add(add(properties, "a:prstGeom", "prst", "rect"), "a:avLst");
        return (P) unmarshal(xml);
    }

    private org.w3c.dom.Document newXml(String root) throws Exception {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);
        org.w3c.dom.Document xml = factory.newDocumentBuilder().newDocument();
        Element element = xml.createElementNS(namespace(root), root);
        xml.appendChild(element);
        for (Map.Entry<String, String> namespace : NAMESPACES.entrySet()) {
            element.setAttributeNS("http://www.w3.org/2000/xmlns/",
                    "xmlns:" + namespace.getKey(), namespace.getValue());
        }
        return xml;
    }

    private Element add(Element parent, String name, String... attributes) {
        Element result = parent.getOwnerDocument().createElementNS(namespace(name), name);
        for (int i = 0; i < attributes.length; i += 2) {
            String key = attributes[i];
            if (key.contains(":")) {
                result.setAttributeNS(namespace(key), key, attributes[i + 1]);
            } else {
                result.setAttribute(key, attributes[i + 1]);
            }
        }
        parent.appendChild(result);
        return result;
    }

    private Object unmarshal(org.w3c.dom.Document xml) throws Exception {
        StringWriter writer = new StringWriter();
        TransformerFactory.newInstance().newTransformer().transform(new DOMSource(xml), new StreamResult(writer));
        return XmlUtils.unwrap(XmlUtils.unmarshalString(writer.toString()));
    }

    private String namespace(String qualifiedName) {
        return NAMESPACES.get(qualifiedName.substring(0, qualifiedName.indexOf(':')));
    }

    private int px(double millimeters) {
        return Math.max(1, (int) Math.round(millimeters * DPI / 25.4D));
    }

    private int pixelOffset(double millimeters) {
        return (int) Math.round(millimeters * DPI / 25.4D);
    }

    private String emu(double millimeters) {
        return Long.toString(Math.round(millimeters * 36000D));
    }

    private double positive(BigDecimal value, double fallback) {
        return value == null || value.signum() <= 0 ? fallback : value.doubleValue();
    }

    private double nonNegative(BigDecimal value, double fallback) {
        return value == null || value.signum() < 0 ? fallback : value.doubleValue();
    }

    private int value(Integer value, int fallback) {
        return value == null ? fallback : value;
    }

    private String value(String value, String fallback) {
        return value == null ? fallback : value;
    }

    private String message(Exception exception) {
        Throwable cause = exception;
        while (cause.getCause() != null) {
            cause = cause.getCause();
        }
        return cause.getMessage() == null ? cause.getClass().getSimpleName() : cause.getMessage();
    }

    private static final class PageSize {
        private final double width;
        private final double height;

        private PageSize(double width, double height) {
            this.width = width;
            this.height = height;
        }
    }

    private static final class Point {
        private final double x;
        private final double y;

        private Point(double x, double y) {
            this.x = x;
            this.y = y;
        }
    }

    private static final class RasterSize {
        private final int width;
        private final int height;

        private RasterSize(int width, int height) {
            this.width = width;
            this.height = height;
        }
    }

    private static final class ImageReference {
        private final double width;
        private final double height;
        private final double x;
        private final double y;

        private ImageReference(double width, double height, double x, double y) {
            this.width = width;
            this.height = height;
            this.x = x;
            this.y = y;
        }
    }

    private static final class PositionedImage {
        private final byte[] png;
        private final double width;
        private final double height;
        private final double x;
        private final double y;

        private PositionedImage(byte[] png, double width, double height, double x, double y) {
            this.png = png;
            this.width = width;
            this.height = height;
            this.x = x;
            this.y = y;
        }
    }

    private static final class FileSource {
        private final String type;
        private final String fileName;

        private FileSource(String type, String fileName) {
            this.type = type;
            this.fileName = fileName;
        }
    }

    private static final class ImageReadException extends RuntimeException {
        private ImageReadException(Throwable cause) {
            super(cause);
        }
    }
}