/*****************************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * 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.preflight.content;

import static org.apache.pdfbox.preflight.PreflightConstants.ERROR_GRAPHIC_INVALID_COLOR_SPACE_CMYK;
import static org.apache.pdfbox.preflight.PreflightConstants.ERROR_GRAPHIC_INVALID_COLOR_SPACE_MISSING;
import static org.apache.pdfbox.preflight.PreflightConstants.ERROR_GRAPHIC_INVALID_COLOR_SPACE_RGB;
import static org.apache.pdfbox.preflight.PreflightConstants.ERROR_GRAPHIC_INVALID_UNKNOWN_COLOR_SPACE;
import static org.apache.pdfbox.preflight.PreflightConstants.ERROR_GRAPHIC_TOO_MANY_GRAPHIC_STATES;
import static org.apache.pdfbox.preflight.PreflightConstants.ERROR_GRAPHIC_UNEXPECTED_VALUE_FOR_KEY;
import static org.apache.pdfbox.preflight.PreflightConstants.MAX_GRAPHIC_STATES;

import java.awt.color.ColorSpace;
import java.awt.color.ICC_ColorSpace;
import java.io.IOException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.pdfbox.cos.COSBase;
import org.apache.pdfbox.cos.COSDictionary;
import org.apache.pdfbox.cos.COSDocument;
import org.apache.pdfbox.cos.COSName;
import org.apache.pdfbox.cos.COSString;
import org.apache.pdfbox.pdmodel.PDPage;
import org.apache.pdfbox.pdmodel.graphics.color.PDCalGray;
import org.apache.pdfbox.pdmodel.graphics.color.PDCalRGB;
import org.apache.pdfbox.pdmodel.graphics.color.PDColorSpace;
import org.apache.pdfbox.pdmodel.graphics.color.PDColorSpaceFactory;
import org.apache.pdfbox.pdmodel.graphics.color.PDColorState;
import org.apache.pdfbox.pdmodel.graphics.color.PDICCBased;
import org.apache.pdfbox.pdmodel.graphics.color.PDLab;
import org.apache.pdfbox.preflight.PreflightConfiguration;
import org.apache.pdfbox.preflight.PreflightContext;
import org.apache.pdfbox.preflight.ValidationResult.ValidationError;
import org.apache.pdfbox.preflight.exception.ValidationException;
import org.apache.pdfbox.preflight.graphic.ColorSpaceHelper;
import org.apache.pdfbox.preflight.graphic.ColorSpaceHelperFactory;
import org.apache.pdfbox.preflight.graphic.ColorSpaceHelperFactory.ColorSpaceRestriction;
import org.apache.pdfbox.preflight.graphic.ColorSpaces;
import org.apache.pdfbox.preflight.graphic.ICCProfileWrapper;
import org.apache.pdfbox.preflight.utils.COSUtils;
import org.apache.pdfbox.preflight.utils.FilterHelper;
import org.apache.pdfbox.preflight.utils.RenderingIntents;
import org.apache.pdfbox.util.PDFOperator;
import org.apache.pdfbox.util.PDFStreamEngine;
import org.apache.pdfbox.util.operator.BeginText;
import org.apache.pdfbox.util.operator.Concatenate;
import org.apache.pdfbox.util.operator.EndText;
import org.apache.pdfbox.util.operator.GRestore;
import org.apache.pdfbox.util.operator.GSave;
import org.apache.pdfbox.util.operator.Invoke;
import org.apache.pdfbox.util.operator.MoveText;
import org.apache.pdfbox.util.operator.MoveTextSetLeading;
import org.apache.pdfbox.util.operator.NextLine;
import org.apache.pdfbox.util.operator.OperatorProcessor;
import org.apache.pdfbox.util.operator.SetCharSpacing;
import org.apache.pdfbox.util.operator.SetHorizontalTextScaling;
import org.apache.pdfbox.util.operator.SetLineCapStyle;
import org.apache.pdfbox.util.operator.SetLineDashPattern;
import org.apache.pdfbox.util.operator.SetLineJoinStyle;
import org.apache.pdfbox.util.operator.SetLineWidth;
import org.apache.pdfbox.util.operator.SetMatrix;
import org.apache.pdfbox.util.operator.SetNonStrokingCMYKColor;
import org.apache.pdfbox.util.operator.SetNonStrokingColor;
import org.apache.pdfbox.util.operator.SetNonStrokingColorSpace;
import org.apache.pdfbox.util.operator.SetNonStrokingRGBColor;
import org.apache.pdfbox.util.operator.SetStrokingCMYKColor;
import org.apache.pdfbox.util.operator.SetStrokingColor;
import org.apache.pdfbox.util.operator.SetStrokingColorSpace;
import org.apache.pdfbox.util.operator.SetStrokingRGBColor;
import org.apache.pdfbox.util.operator.SetTextFont;
import org.apache.pdfbox.util.operator.SetTextLeading;
import org.apache.pdfbox.util.operator.SetTextRenderingMode;
import org.apache.pdfbox.util.operator.SetTextRise;
import org.apache.pdfbox.util.operator.SetWordSpacing;

/**
 * This class inherits from org.apache.pdfbox.util.PDFStreamEngine to allow the validation of specific rules in
 * ContentStream.
 */
public abstract class ContentStreamEngine extends PDFStreamEngine
{

    private enum ColorSpaceType
    {
        RGB, CMYK, ALL;
    }

    protected PreflightContext context = null;

    protected COSDocument cosDocument = null;

    protected PDPage processeedPage = null;

    protected Map<String, OperatorProcessor> contentStreamEngineOperators = new HashMap<String, OperatorProcessor>();

    public ContentStreamEngine(PreflightContext _context, PDPage _page)
    {
        super();
        this.context = _context;
        this.cosDocument = _context.getDocument().getDocument();
        this.processeedPage = _page;

        // Graphics operators
        registerOperatorProcessor("w", new SetLineWidth());
        registerOperatorProcessor("cm", new Concatenate());

        registerOperatorProcessor("CS", new SetStrokingColorSpace());
        registerOperatorProcessor("cs", new SetNonStrokingColorSpace());
        registerOperatorProcessor("d", new SetLineDashPattern());
        registerOperatorProcessor("Do", new Invoke());

        registerOperatorProcessor("j", new SetLineJoinStyle());
        registerOperatorProcessor("J", new SetLineCapStyle());
        registerOperatorProcessor("K", new SetStrokingCMYKColor());
        registerOperatorProcessor("k", new SetNonStrokingCMYKColor());

        registerOperatorProcessor("rg", new SetNonStrokingRGBColor());
        registerOperatorProcessor("RG", new SetStrokingRGBColor());

        registerOperatorProcessor("SC", new SetStrokingColor());
        registerOperatorProcessor("SCN", new SetStrokingColor());
        registerOperatorProcessor("sc", new SetNonStrokingColor());
        registerOperatorProcessor("scn", new SetNonStrokingColor());

        // Graphics state
        registerOperatorProcessor("Q", new GRestore());
        registerOperatorProcessor("q", new GSave());

        // Text operators
        registerOperatorProcessor("BT", new BeginText());
        registerOperatorProcessor("ET", new EndText());
        registerOperatorProcessor("Tf", new SetTextFont());
        registerOperatorProcessor("Tr", new SetTextRenderingMode());
        registerOperatorProcessor("Tm", new SetMatrix());
        registerOperatorProcessor("Td", new MoveText());
        registerOperatorProcessor("T*", new NextLine());
        registerOperatorProcessor("TD", new MoveTextSetLeading());
        registerOperatorProcessor("Tc", new SetCharSpacing());
        registerOperatorProcessor("TL", new SetTextLeading());
        registerOperatorProcessor("Ts", new SetTextRise());
        registerOperatorProcessor("Tw", new SetWordSpacing());
        registerOperatorProcessor("Tz", new SetHorizontalTextScaling());

        /*
         * Do not use the PDFBox Operator, because of the PageDrawer class cast Or because the Operator doesn't exist
         */
        StubOperator stubOp = new StubOperator();
        registerOperatorProcessor("l", stubOp);
        registerOperatorProcessor("re", stubOp);
        registerOperatorProcessor("c", stubOp);
        registerOperatorProcessor("y", stubOp);
        registerOperatorProcessor("v", stubOp);
        registerOperatorProcessor("n", stubOp);
        registerOperatorProcessor("BI", stubOp);
        registerOperatorProcessor("EI", stubOp);
        registerOperatorProcessor("m", stubOp);
        registerOperatorProcessor("W*", stubOp);
        registerOperatorProcessor("W", stubOp);
        registerOperatorProcessor("h", stubOp);

        registerOperatorProcessor("Tj", stubOp);
        registerOperatorProcessor("TJ", stubOp);
        registerOperatorProcessor("'", stubOp);
        registerOperatorProcessor("\"", stubOp);

        registerOperatorProcessor("b", stubOp);
        registerOperatorProcessor("B", stubOp);
        registerOperatorProcessor("b*", stubOp);
        registerOperatorProcessor("B*", stubOp);

        registerOperatorProcessor("BDC", stubOp);
        registerOperatorProcessor("BMC", stubOp);
        registerOperatorProcessor("DP", stubOp);
        registerOperatorProcessor("EMC", stubOp);

        registerOperatorProcessor("d0", stubOp);
        registerOperatorProcessor("d1", stubOp);

        registerOperatorProcessor("f", stubOp);
        registerOperatorProcessor("F", stubOp);
        registerOperatorProcessor("f*", stubOp);

        registerOperatorProcessor("g", stubOp);
        registerOperatorProcessor("G", stubOp);

        registerOperatorProcessor("M", stubOp);
        registerOperatorProcessor("MP", stubOp);

        registerOperatorProcessor("gs", stubOp);
        registerOperatorProcessor("h", stubOp);
        registerOperatorProcessor("i", stubOp);

        registerOperatorProcessor("ri", stubOp);
        registerOperatorProcessor("s", stubOp);
        registerOperatorProcessor("S", stubOp);
        registerOperatorProcessor("sh", stubOp);
    }

    public final void registerOperatorProcessor(String operator, OperatorProcessor op)
    {
        super.registerOperatorProcessor(operator, op);
        contentStreamEngineOperators.put(operator, op);
    }

    /**
     * Check operands of the "ri" operator. Operands must exist in the RenderingIntent list.
     * (net.awl.edoc.pdfa.validation.utils.RenderingIntents)
     * 
     * @param operator
     *            the "ri" operator
     * @param arguments
     *            the "ri" operands
     * @throws ContentStreamException
     *             ERROR_GRAPHIC_UNEXPECTED_VALUE_FOR_KEY if the operand is invalid
     */
    protected void validRenderingIntent(PDFOperator operator, List arguments) throws ContentStreamException
    {
        if ("ri".equals(operator.getOperation()))
        {
            String riArgument0 = "";
            if (arguments.get(0) instanceof COSName)
            {
                riArgument0 = ((COSName) arguments.get(0)).getName();
            }
            else if (arguments.get(0) instanceof String)
            {
                riArgument0 = (String) arguments.get(0);
            }

            if (!RenderingIntents.contains(riArgument0))
            {
                registerError("Unexpected value '" + arguments.get(0) + "' for ri operand. ",
                        ERROR_GRAPHIC_UNEXPECTED_VALUE_FOR_KEY);
                return;
            }
        }
    }

    /**
     * Valid the number of graphic states if the operator is the Save Graphic state operator ("q")
     * 
     * @param operator
     * @throws ContentStreamException
     */
    protected void validNumberOfGraphicStates(PDFOperator operator) throws ContentStreamException
    {
        if ("q".equals(operator.getOperation()))
        {
            int numberOfGraphicStates = this.getGraphicsStack().size();
            if (numberOfGraphicStates > MAX_GRAPHIC_STATES)
            {
                registerError("Too many graphic states", ERROR_GRAPHIC_TOO_MANY_GRAPHIC_STATES);
                return;
            }
        }
    }

    /**
     * Throw a ContentStreamException if the LZW filter is used in a InlinedImage.
     * 
     * @param operator
     *            the InlinedImage object (BI to EI)
     * @throws ContentStreamException
     */
    protected void validImageFilter(PDFOperator operator) throws ContentStreamException
    {
        COSDictionary dict = operator.getImageParameters().getDictionary();
        /*
         * Search a Filter declaration in the InlinedImage dictionary. The LZWDecode Filter is forbidden.
         */
        COSBase filter = dict.getDictionaryObject(COSName.F, COSName.FILTER);
        FilterHelper
                .isAuthorizedFilter(context, COSUtils.getAsString(filter, this.context.getDocument().getDocument()));
    }

    /**
     * This method validates if the ColorSpace used by the InlinedImage is consistent with the color space defined in
     * OutputIntent dictionaries.
     * 
     * @param operator
     *            the InlinedImage object (BI to EI)
     * @throws ValidationException
     */
    protected void validImageColorSpace(PDFOperator operator) throws ValidationException
    {
        COSDictionary dict = operator.getImageParameters().getDictionary();

        COSBase csInlinedBase = dict.getDictionaryObject(COSName.CS, COSName.COLORSPACE);
        ColorSpaceHelper csHelper;
        if (csInlinedBase != null)
        {
            try
            {
                /*
                 * In InlinedImage only DeviceGray/RGB/CMYK and restricted Indexed color spaces are allowed.
                 */
                PDColorSpace pdCS = operator.getImageParameters().getColorSpace(this.getResources().getColorSpaces());
                PreflightConfiguration cfg = context.getConfig();
                ColorSpaceHelperFactory csFact = cfg.getColorSpaceHelperFact();
                csHelper = csFact.getColorSpaceHelper(context, pdCS, ColorSpaceRestriction.ONLY_DEVICE);
            }
            catch (IOException e)
            {
                registerError(e.getMessage(), ERROR_GRAPHIC_INVALID_UNKNOWN_COLOR_SPACE);
                return;
            }

            csHelper.validate();
        }
    }

    /**
     * This method validates if the ColorOperator can be used with the color space defined in OutputIntent dictionaries.
     * 
     * @param operation
     *            the color operator
     * @throws ContentStreamException
     */
    protected void checkColorOperators(String operation) throws ContentStreamException
    {
        PDColorState cs = getColorState(operation);

        if ("rg".equals(operation) || "RG".equals(operation))
        {
            if (!validColorSpace(cs, ColorSpaceType.RGB))
            {
                registerError("The operator \"" + operation + "\" can't be used with CMYK Profile",
                        ERROR_GRAPHIC_INVALID_COLOR_SPACE_RGB);
                return;
            }
        }

        if ("k".equals(operation) || "K".equals(operation))
        {
            if (!validColorSpace(cs, ColorSpaceType.CMYK))
            {
                registerError("The operator \"" + operation + "\" can't be used with RGB Profile",
                        ERROR_GRAPHIC_INVALID_COLOR_SPACE_CMYK);
                return;
            }
        }

        if ("g".equals(operation) || "G".equals(operation))
        {
            if (!validColorSpace(cs, ColorSpaceType.ALL))
            {
                registerError("The operator \"" + operation + "\" can't be used without Color Profile",
                        ERROR_GRAPHIC_INVALID_COLOR_SPACE_MISSING);
                return;
            }
        }

        if ("f".equals(operation) || "F".equals(operation) || "f*".equals(operation) || "B".equals(operation)
                || "B*".equals(operation) || "b".equals(operation) || "b*".equals(operation))
        {
            if (!validColorSpace(cs, ColorSpaceType.ALL))
            {
                // The default fill color needs an OutputIntent
                registerError("The operator \"" + operation + "\" can't be used without Color Profile",
                        ERROR_GRAPHIC_INVALID_COLOR_SPACE_MISSING);
                return;
            }
        }
    }

    private boolean validColorSpace(PDColorState colorState, ColorSpaceType expectedType) throws ContentStreamException
    {
        boolean result = true;
        if (colorState == null)
        {
            result = validColorSpaceDestOutputProfile(expectedType);
        }
        else
        {
            PDColorSpace cs = colorState.getColorSpace();
            if (isDeviceIndependent(cs, expectedType))
            {
                result = true;
            }
            else
            {
                result = validColorSpaceDestOutputProfile(expectedType);
            }
        }
        return result;
    }

    /**
     * Check if the ColorProfile provided by the DestOutputProfile entry isn't null and if the ColorSpace represented by
     * the Profile has the right type (RGB or CMYK)
     * 
     * @param expectedType
     * @return
     */
    private boolean validColorSpaceDestOutputProfile(ColorSpaceType expectedType) throws ContentStreamException
    {
        boolean result = false;
        ICCProfileWrapper profileWrapper;
        try
        {
            profileWrapper = ICCProfileWrapper.getOrSearchICCProfile(context);
            if (profileWrapper != null)
            {
                switch (expectedType)
                {
                case RGB:
                    result = profileWrapper.isRGBColorSpace();
                    break;
                case CMYK:
                    result = profileWrapper.isCMYKColorSpace();
                    break;
                default:
                    result = true;
                    break;
                }
            }
        }
        catch (ValidationException e)
        {
            throw new ContentStreamException(e);
        }
        return result;
    }

    /**
     * Return true if the given ColorSpace is an independent device ColorSpace. If the color space is an ICCBased, check
     * the embedded profile color (RGB or CMYK)
     * 
     * @param cs
     * @return
     */
    private boolean isDeviceIndependent(PDColorSpace cs, ColorSpaceType expectedType)
    {
        boolean result = (cs instanceof PDCalGray || cs instanceof PDCalRGB || cs instanceof PDLab);
        if (cs instanceof PDICCBased)
        {
            PDICCBased iccBased = (PDICCBased) cs;
            try
            {
                ColorSpace iccColorSpace = iccBased.getJavaColorSpace();
                switch (expectedType)
                {
                case RGB:
                    result = (iccColorSpace.getType() == ICC_ColorSpace.TYPE_RGB);
                    break;
                case CMYK:
                    result = (iccColorSpace.getType() == ICC_ColorSpace.TYPE_CMYK);
                    break;
                default:
                    result = true;
                    break;
                }
            }
            catch (IOException e)
            {
                result = false;
            }
        }
        return result;
    }

    /**
     * Return the current color state used by the operation
     * 
     * @param operation
     * @return
     */
    private PDColorState getColorState(String operation)
    {
        if (getGraphicsState() == null)
        {
            return null;
        }

        PDColorState colorState;
        if (operation.equals("rg") || operation.equals("g") || operation.equals("k") || operation.equals("f")
                || operation.equals("F") || operation.equals("f*"))
        {
            // non stroking operator
            colorState = getGraphicsState().getNonStrokingColor();
        }
        else
        {
            // stroking operator
            colorState = getGraphicsState().getStrokingColor();
        }
        return colorState;
    }

    /**
     * This method validates if the ColorSpace used as operand is consistent with the color space defined in
     * OutputIntent dictionaries.
     * 
     * @param operator
     * @param arguments
     * @throws IOException
     */
    protected void checkSetColorSpaceOperators(PDFOperator operator, List<?> arguments) throws IOException
    {
        if (!("CS".equals(operator.getOperation()) || "cs".equals(operator.getOperation())))
        {
            return;
        }

        String colorSpaceName = null;
        if (arguments.get(0) instanceof String)
        {
            colorSpaceName = (String) arguments.get(0);
        }
        else if (arguments.get(0) instanceof COSString)
        {
            colorSpaceName = ((COSString) arguments.get(0)).toString();
        }
        else if (arguments.get(0) instanceof COSName)
        {
            colorSpaceName = ((COSName) arguments.get(0)).getName();
        }
        else
        {
            registerError("The operand doesn't have the expected type", ERROR_GRAPHIC_UNEXPECTED_VALUE_FOR_KEY);
            return;
        }

        ColorSpaceHelper csHelper = null;
        ColorSpaces cs = null;
        try
        {
            cs = ColorSpaces.valueOf(colorSpaceName);
        }
        catch (IllegalArgumentException e)
        {
            /*
             * The color space is unknown. Try to access the resources dictionary, the color space can be a reference.
             */
            Map<String, PDColorSpace> colorSpaces = this.getResources().getColorSpaces();
            if (colorSpaces != null)
            {
                PDColorSpace pdCS = colorSpaces.get(colorSpaceName);
                if (pdCS != null)
                {
                    cs = ColorSpaces.valueOf(pdCS.getName());
                    PreflightConfiguration cfg = context.getConfig();
                    ColorSpaceHelperFactory csFact = cfg.getColorSpaceHelperFact();
                    csHelper = csFact.getColorSpaceHelper(context, pdCS, ColorSpaceRestriction.NO_RESTRICTION);
                }
            }
        }

        if (cs == null)
        {
            registerError("The ColorSpace " + colorSpaceName + " is unknown", ERROR_GRAPHIC_UNEXPECTED_VALUE_FOR_KEY);
            return;
        }

        if (csHelper == null)
        {
            PDColorSpace pdCS = PDColorSpaceFactory.createColorSpace(COSName.getPDFName(colorSpaceName));
            PreflightConfiguration cfg = context.getConfig();
            ColorSpaceHelperFactory csFact = cfg.getColorSpaceHelperFact();
            csHelper = csFact.getColorSpaceHelper(context, pdCS, ColorSpaceRestriction.NO_RESTRICTION);
        }

        csHelper.validate();
    }

    /**
     * Add a validation error into the PreflightContext
     * 
     * @param msg
     *            exception details
     * @param errorCode
     *            the error code.
     */
    protected void registerError(String msg, String errorCode)
    {
        ValidationError error = new ValidationError(errorCode, msg);
        this.context.addValidationError(error);
    }
}
