# PDFreeTextAppearanceHandler.java

    /*
     * Copyright 2018 The Apache Software Foundation.
     *
     * Licensed 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
     *
     * Unless required by applicable law or agreed to in writing, software
     * distributed under the License is distributed on an "AS IS" BASIS,
     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     * See the License for the specific language governing permissions and
     * limitations under the License.
     */
    package org.apache.pdfbox.pdmodel.interactive.annotation.handlers;

    import java.io.IOException;
    import java.nio.charset.StandardCharsets;
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.apache.pdfbox.contentstream.operator.Operator;
    import org.apache.pdfbox.contentstream.operator.OperatorName;
    import org.apache.pdfbox.cos.COSArray;
    import org.apache.pdfbox.cos.COSBase;
    import org.apache.pdfbox.cos.COSName;
    import org.apache.pdfbox.cos.COSNumber;
    import org.apache.pdfbox.pdfparser.PDFStreamParser;
    import org.apache.pdfbox.pdmodel.PDAppearanceContentStream;
    import org.apache.pdfbox.pdmodel.PDDocument;
    import org.apache.pdfbox.pdmodel.PDResources;
    import org.apache.pdfbox.pdmodel.common.PDRectangle;
    import org.apache.pdfbox.pdmodel.font.PDFont;
    import org.apache.pdfbox.pdmodel.graphics.color.PDColor;
    import org.apache.pdfbox.pdmodel.graphics.color.PDDeviceCMYK;
    import org.apache.pdfbox.pdmodel.graphics.color.PDDeviceGray;
    import org.apache.pdfbox.pdmodel.graphics.color.PDDeviceRGB;
    import org.apache.pdfbox.pdmodel.interactive.annotation.PDAnnotation;
    import org.apache.pdfbox.pdmodel.interactive.annotation.PDAnnotationFreeText;
    import static org.apache.pdfbox.pdmodel.interactive.annotation.PDAnnotationLine.LE_NONE;
    import org.apache.pdfbox.pdmodel.interactive.annotation.PDAppearanceStream;
    import org.apache.pdfbox.pdmodel.interactive.annotation.PDBorderEffectDictionary;
    import org.apache.pdfbox.pdmodel.interactive.annotation.layout.AppearanceStyle;
    import org.apache.pdfbox.pdmodel.interactive.annotation.layout.PlainText;
    import org.apache.pdfbox.pdmodel.interactive.annotation.layout.PlainTextFormatter;
    import org.apache.pdfbox.pdmodel.interactive.form.PDAcroForm;
    import org.apache.pdfbox.util.Matrix;

    public class PDFreeTextAppearanceHandler extends PDAbstractAppearanceHandler
    {
        private static final Log LOG = LogFactory.getLog(PDFreeTextAppearanceHandler.class);

        private static final Pattern COLOR_PATTERN =
                Pattern.compile(".*color\\:\\s*\\#([0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]).*");

        private float fontSize = 10;
        private COSName fontName = COSName.HELV;

        public PDFreeTextAppearanceHandler(PDAnnotation annotation)
        {
            super(annotation);
        }

        public PDFreeTextAppearanceHandler(PDAnnotation annotation, PDDocument document)
        {
            super(annotation, document);
        }

        @Override
        public void generateNormalAppearance()
        {
            PDAnnotationFreeText annotation = (PDAnnotationFreeText) getAnnotation();
            float[] pathsArray;
            if (PDAnnotationFreeText.IT_FREE_TEXT_CALLOUT.equals(annotation.getIntent()))
            {
                pathsArray = annotation.getCallout();
                if (pathsArray == null || pathsArray.length != 4 && pathsArray.length != 6)
                {
                    pathsArray = new float[0];
                }
            }
            else
            {
                pathsArray = new float[0];
            }
            AnnotationBorder ab = AnnotationBorder.getAnnotationBorder(annotation, annotation.getBorderStyle());

            try (PDAppearanceContentStream cs = getNormalAppearanceAsContentStream(true))
            {
                // The fill color is the /C entry, there is no /IC entry defined
                boolean hasBackground = cs.setNonStrokingColorOnDemand(annotation.getColor());
                setOpacity(cs, annotation.getConstantOpacity());

                // Adobe uses the last non stroking color from /DA as stroking color!
                // But if there is a color in /DS, then that one is used for text.
                PDColor strokingColor = extractNonStrokingColor(annotation);
                boolean hasStroke = cs.setStrokingColorOnDemand(strokingColor);
                PDColor textColor = strokingColor;
                String defaultStyleString = annotation.getDefaultStyleString();
                if (defaultStyleString != null)
                {
                    Matcher m = COLOR_PATTERN.matcher(defaultStyleString);
                    if (m.find())
                    {
                        int color = Integer.parseInt(m.group(1), 16);
                        float r = ((color >> 16) & 0xFF) / 255f;
                        float g = ((color >> 8) & 0xFF) / 255f;
                        float b = (color & 0xFF) / 255f;
                        textColor = new PDColor( new float[] { r, g, b }, PDDeviceRGB.INSTANCE);
                    }
                }

                if (ab.dashArray != null)
                {
                    cs.setLineDashPattern(ab.dashArray, 0);
                }
                cs.setLineWidth(ab.width);

                // draw callout line(s)
                // must be done before retangle paint to avoid a line cutting through cloud
                // see CTAN-example-Annotations.pdf
                for (int i = 0; i < pathsArray.length / 2; ++i)
                {
                    float x = pathsArray[i * 2];
                    float y = pathsArray[i * 2 + 1];
                    if (i == 0)
                    {
                        if (SHORT_STYLES.contains(annotation.getLineEndingStyle()))
                        {
                            // modify coordinate to shorten the segment
                            // https://stackoverflow.com/questions/7740507/extend-a-line-segment-a-specific-distance
                            float x1 = pathsArray[2];
                            float y1 = pathsArray[3];
                            float len = (float) (Math.sqrt(Math.pow(x - x1, 2) + Math.pow(y - y1, 2)));
                            if (Float.compare(len, 0) != 0)
                            {
                                x += (x1 - x) / len * ab.width;
                                y += (y1 - y) / len * ab.width;
                            }
                        }
                        cs.moveTo(x, y);
                    }
                    else
                    {
                        cs.lineTo(x, y);
                    }
                }
                if (pathsArray.length > 0)
                {
                    cs.stroke();
                }

                // paint the styles here and after line(s) draw, to avoid line crossing a filled shape
                if (PDAnnotationFreeText.IT_FREE_TEXT_CALLOUT.equals(annotation.getIntent())
                        // check only needed to avoid q cm Q if LE_NONE
                        && !LE_NONE.equals(annotation.getLineEndingStyle())
                        && pathsArray.length >= 4)
                {
                    float x2 = pathsArray[2];
                    float y2 = pathsArray[3];
                    float x1 = pathsArray[0];
                    float y1 = pathsArray[1];
                    cs.saveGraphicsState();
                    if (ANGLED_STYLES.contains(annotation.getLineEndingStyle()))
                    {
                        // do a transform so that first "arm" is imagined flat,
                        // like in line handler.
                        // The alternative would be to apply the transform to the
                        // LE shape coordinates directly, which would be more work
                        // and produce code difficult to understand
                        double angle = Math.atan2(y2 - y1, x2 - x1);
                        cs.transform(Matrix.getRotateInstance(angle, x1, y1));
                    }
                    else
                    {
                        cs.transform(Matrix.getTranslateInstance(x1, y1));
                    }
                    drawStyle(annotation.getLineEndingStyle(), cs, 0, 0, ab.width, hasStroke, hasBackground, false);
                    cs.restoreGraphicsState();
                }

                PDRectangle borderBox;
                PDBorderEffectDictionary borderEffect = annotation.getBorderEffect();
                if (borderEffect != null && borderEffect.getStyle().equals(PDBorderEffectDictionary.STYLE_CLOUDY))
                {
                    // Adobe draws the text with the original rectangle in mind.
                    // but if there is an /RD, then writing area get smaller.
                    // do this here because /RD is overwritten in a few lines
                    borderBox = applyRectDifferences(getRectangle(), annotation.getRectDifferences());

                    //TODO this segment was copied from square handler. Refactor?
                    CloudyBorder cloudyBorder = new CloudyBorder(cs,
                        borderEffect.getIntensity(), ab.width, getRectangle());
                    cloudyBorder.createCloudyRectangle(annotation.getRectDifference());
                    annotation.setRectangle(cloudyBorder.getRectangle());
                    annotation.setRectDifference(cloudyBorder.getRectDifference());
                    PDAppearanceStream appearanceStream = annotation.getNormalAppearanceStream();
                    appearanceStream.setBBox(cloudyBorder.getBBox());
                    appearanceStream.setMatrix(cloudyBorder.getMatrix());
                }
                else
                {
                    // handle the border box
                    //
                    // There are two options. The handling is not part of the PDF specification but
                    // implementation specific to Adobe Reader
                    // - if /RD is set the border box is the /Rect entry inset by the respective
                    //   border difference.
                    // - if /RD is not set then we don't touch /RD etc because Adobe doesn't either.
                    borderBox = applyRectDifferences(getRectangle(), annotation.getRectDifferences());
                    annotation.getNormalAppearanceStream().setBBox(borderBox);

                    // note that borderBox is not modified
                    PDRectangle paddedRectangle = getPaddedRectangle(borderBox, ab.width / 2);
                    cs.addRect(paddedRectangle.getLowerLeftX(), paddedRectangle.getLowerLeftY(),
                               paddedRectangle.getWidth(), paddedRectangle.getHeight());
                }
                cs.drawShape(ab.width, hasStroke, hasBackground);

                // rotation is an undocumented feature, but Adobe uses it. Examples can be found
                // in pdf_commenting_new.pdf file, page 3.
                int rotation = annotation.getCOSObject().getInt(COSName.ROTATE, 0);
                cs.transform(Matrix.getRotateInstance(Math.toRadians(rotation), 0, 0));
                float xOffset;
                float yOffset;
                float width = rotation == 90 || rotation == 270 ? borderBox.getHeight() : borderBox.getWidth();
                // strategy to write formatted text is somewhat inspired by
                // AppearanceGeneratorHelper.insertGeneratedAppearance()
                PDFont font = null;
                float clipY;
                float clipWidth = width - ab.width * 4;
                float clipHeight = rotation == 90 || rotation == 270 ?
                                    borderBox.getWidth() - ab.width * 4 : borderBox.getHeight() - ab.width * 4;
                extractFontDetails(annotation);
                if (document != null)
                {
                    PDAcroForm acroForm = document.getDocumentCatalog().getAcroForm();
                    if (acroForm != null)
                    {
                        // Try to get font from AcroForm default resources
                        // Sample file: https://gitlab.freedesktop.org/poppler/poppler/issues/6
                        PDResources defaultResources = acroForm.getDefaultResources();
                        if (defaultResources != null)
                        {
                            PDFont defaultResourcesFont = defaultResources.getFont(fontName);
                            if (defaultResourcesFont != null)
                            {
                                font = defaultResourcesFont;
                            }
                        }
                    }
                }
                if (font == null)
                {
                    font = getDefaultFont();
                }
                // value used by Adobe, no idea where it comes from, actual font bbox max y is 0.931
                // gathered by creating an annotation with width 0.
                float yDelta = 0.7896f;
                switch (rotation)
                {
                    case 180:
                        xOffset = - borderBox.getUpperRightX() + ab.width * 2;
                        yOffset = - borderBox.getLowerLeftY() - ab.width * 2 - yDelta * fontSize;
                        clipY = - borderBox.getUpperRightY() + ab.width * 2;
                        break;
                    case 90:
                        xOffset = borderBox.getLowerLeftY() + ab.width * 2;
                        yOffset = - borderBox.getLowerLeftX() - ab.width * 2 - yDelta * fontSize;
                        clipY = - borderBox.getUpperRightX() + ab.width * 2;
                        break;
                    case 270:
                        xOffset = - borderBox.getUpperRightY() + ab.width * 2;
                        yOffset = borderBox.getUpperRightX() - ab.width * 2 - yDelta * fontSize;
                        clipY = borderBox.getLowerLeftX() + ab.width * 2;
                        break;
                    case 0:
                    default:
                        xOffset = borderBox.getLowerLeftX() + ab.width * 2;
                        yOffset = borderBox.getUpperRightY() - ab.width * 2 - yDelta * fontSize;
                        clipY = borderBox.getLowerLeftY() + ab.width * 2;
                        break;
                }

                // clip writing area
                cs.addRect(xOffset, clipY, clipWidth, clipHeight);
                cs.clip();

                if (annotation.getContents() != null)
                {
                    cs.beginText();
                    cs.setFont(font, fontSize);
                    cs.setNonStrokingColor(textColor.getComponents());
                    AppearanceStyle appearanceStyle = new AppearanceStyle();
                    appearanceStyle.setFont(font);
                    appearanceStyle.setFontSize(fontSize);
                    PlainTextFormatter formatter = new PlainTextFormatter.Builder(cs)
                            .style(appearanceStyle)
                            .text(new PlainText(annotation.getContents()))
                            .width(width - ab.width * 4)
                            .wrapLines(true)
                            .initialOffset(xOffset, yOffset)
                            // Adobe ignores the /Q
                            //.textAlign(annotation.getQ())
                            .build();
                    try
                    {
                        formatter.format();
                    }
                    catch (IllegalArgumentException ex)
                    {
                        throw new IOException(ex);
                    }
                    finally
                    {
                        cs.endText();
                    }
                }

                if (pathsArray.length > 0)
                {
                    PDRectangle rect = getRectangle();

                    // Adjust rectangle
                    // important to do this after the rectangle has been painted, because the
                    // final rectangle will be bigger due to callout
                    // CTAN-example-Annotations.pdf p1
                    //TODO in a class structure this should be overridable
                    float minX = Float.MAX_VALUE;
                    float minY = Float.MAX_VALUE;
                    float maxX = Float.MIN_VALUE;
                    float maxY = Float.MIN_VALUE;
                    for (int i = 0; i < pathsArray.length / 2; ++i)
                    {
                        float x = pathsArray[i * 2];
                        float y = pathsArray[i * 2 + 1];
                        minX = Math.min(minX, x);
                        minY = Math.min(minY, y);
                        maxX = Math.max(maxX, x);
                        maxY = Math.max(maxY, y);
                    }
                    // arrow length is 9 * width at about 30° => 10 * width seems to be enough
                    rect.setLowerLeftX(Math.min(minX - ab.width * 10, rect.getLowerLeftX()));
                    rect.setLowerLeftY(Math.min(minY - ab.width * 10, rect.getLowerLeftY()));
                    rect.setUpperRightX(Math.max(maxX + ab.width * 10, rect.getUpperRightX()));
                    rect.setUpperRightY(Math.max(maxY + ab.width * 10, rect.getUpperRightY()));
                    annotation.setRectangle(rect);

                    // need to set the BBox too, because rectangle modification came later
                    annotation.getNormalAppearanceStream().setBBox(getRectangle());

                    //TODO when callout is used, /RD should be so that the result is the writable part
                }
            }
            catch (IOException ex)
            {
                LOG.error(ex);
            }
        }

        // get the last non stroking color from the /DA entry
        private PDColor extractNonStrokingColor(PDAnnotationFreeText annotation)
        {
            // It could also work with a regular expression, but that should be written so that
            // "/LucidaConsole 13.94766 Tf .392 .585 .93 rg" does not produce "2 .585 .93 rg" as result
            // Another alternative might be to create a PDDocument and a PDPage with /DA content as /Content,
            // process the whole thing and then get the non stroking color.

            PDColor strokingColor = new PDColor(new float[]{0}, PDDeviceGray.INSTANCE);
            String defaultAppearance = annotation.getDefaultAppearance();
            if (defaultAppearance == null)
            {
                return strokingColor;
            }

            try
            {
                // not sure if charset is correct, but we only need numbers and simple characters
                PDFStreamParser parser = new PDFStreamParser(defaultAppearance.getBytes(StandardCharsets.US_ASCII));
                COSArray arguments = new COSArray();
                COSArray colors = null;
                Operator graphicOp = null;
                for (Object token = parser.parseNextToken(); token != null; token = parser.parseNextToken())
                {
                    if (token instanceof Operator)
                    {
                        Operator op = (Operator) token;
                        String name = op.getName();
                        if (OperatorName.NON_STROKING_GRAY.equals(name) ||
                            OperatorName.NON_STROKING_RGB.equals(name) ||
                            OperatorName.NON_STROKING_CMYK.equals(name))
                        {
                            graphicOp = op;
                            colors = arguments;
                        }
                        arguments = new COSArray();
                    }
                    else
                    {
                        arguments.add((COSBase) token);
                    }
                }
                if (graphicOp != null)
                {
                    switch (graphicOp.getName())
                    {
                        case OperatorName.NON_STROKING_GRAY:
                            strokingColor = new PDColor(colors, PDDeviceGray.INSTANCE);
                            break;
                        case OperatorName.NON_STROKING_RGB:
                            strokingColor = new PDColor(colors, PDDeviceRGB.INSTANCE);
                            break;
                        case OperatorName.NON_STROKING_CMYK:
                            strokingColor = new PDColor(colors, PDDeviceCMYK.INSTANCE);
                            break;
                        default:
                            break;
                    }
                }
            }
            catch (IOException ex)
            {
                LOG.warn("Problem parsing /DA, will use default black", ex);
            }
            return strokingColor;
        }

        //TODO extractNonStrokingColor and extractFontDetails
        // might somehow be replaced with PDDefaultAppearanceString, which is quite similar.
        private void extractFontDetails(PDAnnotationFreeText annotation)
        {
            String defaultAppearance = annotation.getDefaultAppearance();
            if (defaultAppearance == null && document != null)
            {
                PDAcroForm pdAcroForm = document.getDocumentCatalog().getAcroForm();
                if (pdAcroForm != null)
                {
                    defaultAppearance = pdAcroForm.getDefaultAppearance();
                }
            }
            if (defaultAppearance == null)
            {
                return;
            }

            try
            {
                // not sure if charset is correct, but we only need numbers and simple characters
                PDFStreamParser parser = new PDFStreamParser(defaultAppearance.getBytes(StandardCharsets.US_ASCII));
                COSArray arguments = new COSArray();
                COSArray fontArguments = new COSArray();
                for (Object token = parser.parseNextToken(); token != null; token = parser.parseNextToken())
                {
                    if (token instanceof Operator)
                    {
                        Operator op = (Operator) token;
                        String name = op.getName();
                        if (OperatorName.SET_FONT_AND_SIZE.equals(name))
                        {
                            fontArguments = arguments;
                        }
                        arguments = new COSArray();
                    }
                    else
                    {
                        arguments.add((COSBase) token);
                    }
                }
                if (fontArguments.size() >= 2)
                {
                    COSBase base = fontArguments.get(0);
                    if (base instanceof COSName)
                    {
                        fontName = (COSName) base;
                    }
                    base = fontArguments.get(1);
                    if (base instanceof COSNumber)
                    {
                        fontSize = ((COSNumber) base).floatValue();
                    }
                }
            }
            catch (IOException ex)
            {
                LOG.warn("Problem parsing /DA, will use default 'Helv 10'", ex);
            }
        }

        @Override
        public void generateRolloverAppearance()
        {
            // TODO to be implemented
        }

        @Override
        public void generateDownAppearance()
        {
            // TODO to be implemented
        }
    }