// 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.

#include "DFPlatform.h"
#include "WordPPr.h"
#include "WordStyles.h"
#include "WordSection.h"
#include "CSS.h"
#include "DFHTML.h"
#include "DFString.h"
#include "DFCommon.h"
#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>

static Tag WordNumPr_Children[] = {
    WORD_ILVL,
    WORD_NUMID,
    WORD_NUMBERINGCHANGE,
    WORD_INS,
    0,
};

static Tag WordPPR_Children[] = {
    WORD_PSTYLE,
    WORD_KEEPNEXT,
    WORD_KEEPLINES,
    WORD_PAGEBREAKBEFORE,
    WORD_FRAMEPR,
    WORD_WIDOWCONTROL,
    WORD_NUMPR,
    WORD_SUPPRESSLINENUMBERS,
    WORD_PBDR,
    WORD_SHD,
    WORD_TABS,
    WORD_SUPPRESSAUTOHYPHENS,
    WORD_KINSOKU,
    WORD_WORDWRAP,
    WORD_OVERFLOWPUNCT,
    WORD_TOPLINEPUNCT,
    WORD_AUTOSPACEDE,
    WORD_AUTOSPACEDN,
    WORD_BIDI,
    WORD_ADJUSTRIGHTIND,
    WORD_SNAPTOGRID,
    WORD_SPACING,
    WORD_IND,
    WORD_CONTEXTUALSPACING,
    WORD_MIRRORINDENTS,
    WORD_SUPPRESSOVERLAP,
    WORD_JC,
    WORD_TEXTDIRECTION,
    WORD_TEXTALIGNMENT,
    WORD_TEXTBOXTIGHTWRAP,
    WORD_OUTLINELVL,
    WORD_DIVID,
    WORD_CNFSTYLE,
    WORD_RPR,
    WORD_SECTPR,
    WORD_PPRCHANGE,
    0,
};

////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                //
//                               Paragraph properties (pPr element)                               //
//                                                                                                //
////////////////////////////////////////////////////////////////////////////////////////////////////

static void WordGetPBdr(DFNode *concrete, CSSProperties *properties)
{
    for (DFNode *child = concrete->first; child != NULL; child = child->next) {
        switch (child->tag) {
            case WORD_TOP:
                WordGetBorder(child,"top",properties);
                break;
            case WORD_BOTTOM:
                WordGetBorder(child,"bottom",properties);
                break;
            case WORD_LEFT:
                WordGetBorder(child,"left",properties);
                break;
            case WORD_RIGHT:
                WordGetBorder(child,"right",properties);
                break;
            default:
                break;
        }
    }
}

static void WordPutPBdr(DFNode *concrete, CSSProperties *oldp, CSSProperties *newp)
{
    DFNode *children[PREDEFINED_TAG_COUNT];
    bzero(children,PREDEFINED_TAG_COUNT*sizeof(DFNode *));
    childrenToArray(concrete,children);

    DFDocument *doc = concrete->doc;

    WordPutBorder(doc,oldp,newp,&children[WORD_TOP],WORD_TOP,"top");
    WordPutBorder(doc,oldp,newp,&children[WORD_BOTTOM],WORD_BOTTOM,"bottom");
    WordPutBorder(doc,oldp,newp,&children[WORD_LEFT],WORD_LEFT,"left");
    WordPutBorder(doc,oldp,newp,&children[WORD_RIGHT],WORD_RIGHT,"right");

    Tag WordPBdr_children[] = {
        WORD_TOP,
        WORD_LEFT,
        WORD_BOTTOM,
        WORD_RIGHT,
        WORD_BETWEEN,
        WORD_BAR,
        0,
    };

    replaceChildrenFromArray(concrete,children,WordPBdr_children);
}

static void WordGetNumPr(DFNode *concrete, CSSProperties *properties)
{
    for (DFNode *child = concrete->first; child != NULL; child = child->next) {
        switch (child->tag) {
            case WORD_NUMID:
                CSSPut(properties,"-word-numId",DFGetAttribute(child,WORD_VAL));
                break;
            case WORD_ILVL:
                CSSPut(properties,"-word-ilvl",DFGetAttribute(child,WORD_VAL));
                break;
        }
    }
}

static void WordPutNumPr(DFNode *concrete, CSSProperties *newp)
{
    DFNode *children[PREDEFINED_TAG_COUNT];
    childrenToArray(concrete,children);

    CSSProperties *oldp = CSSPropertiesNew();
    WordGetNumPr(concrete,oldp);

    if (!DFStringEquals(CSSGet(oldp,"-word-numId"),CSSGet(newp,"-word-numId")) ||
        !DFStringEquals(CSSGet(oldp,"-word-ilvl"),CSSGet(newp,"-word-ilvl"))) {
        if (CSSGet(newp,"-word-numId") != NULL) {
            children[WORD_NUMID] = DFCreateElement(concrete->doc,WORD_NUMID);
            DFSetAttribute(children[WORD_NUMID],WORD_VAL,CSSGet(newp,"-word-numId"));

            if (CSSGet(newp,"-word-ilvl") != NULL) {
                children[WORD_ILVL] = DFCreateElement(concrete->doc,WORD_ILVL);
                DFSetAttribute(children[WORD_ILVL],WORD_VAL,CSSGet(newp,"-word-ilvl"));
            }
            else {
                children[WORD_ILVL] = NULL;
            }
        }
        else {
            children[WORD_NUMID] = NULL;
            children[WORD_ILVL] = NULL;
        }
    }

    replaceChildrenFromArray(concrete,children,WordNumPr_Children);
    CSSPropertiesRelease(oldp);
}

void WordGetPPr(DFNode *pPr, CSSProperties *properties, const char **styleId, WordSection *section)
{
    assert(pPr->tag == WORD_PPR);
    if (styleId != NULL)
        *styleId = NULL;
    for (DFNode *child = pPr->first; child != NULL; child = child->next) {
        switch (child->tag) {
            case WORD_PSTYLE:
                if (styleId != NULL)
                    *styleId = DFGetAttribute(child,WORD_VAL);
                break;
            case WORD_PBDR:
                WordGetPBdr(child,properties);
                break;
            case WORD_SHD:
                WordGetShd(child,properties);
                break;
            case WORD_JC: {
                const char *val = DFGetAttribute(child,WORD_VAL);
                if (val != NULL) {
                    if (!strcmp(val,"left") || !strcmp(val,"start"))
                        CSSPut(properties,"text-align","left");
                    else if (!strcmp(val,"right") || !strcmp(val,"end"))
                        CSSPut(properties,"text-align","right");
                    else if (!strcmp(val,"center"))
                        CSSPut(properties,"text-align","center");
                    else if (!strcmp(val,"both"))
                        CSSPut(properties,"text-align","justify");
                }
                break;
            }
            case WORD_IND: {
                if ((section == NULL) || (WordSectionContentWidth(section) <= 0))
                    break;

                // Units: 1/20th of a point

                const char *firstLine = DFGetAttribute(child,WORD_FIRSTLINE);
                const char *hanging = DFGetAttribute(child,WORD_HANGING);
                const char *left = DFGetAttribute(child,WORD_START);
                if (left == NULL)
                    left = DFGetAttribute(child,WORD_LEFT);;
                const char *right = DFGetAttribute(child,WORD_END);
                if (right == NULL)
                    right = DFGetAttribute(child,WORD_RIGHT);

                if (left != NULL) {
                    double leftPct = 100.0*atoi(left)/(double)WordSectionContentWidth(section);
                    char buf[100];
                    CSSPut(properties,"margin-left",DFFormatDoublePct(buf,100,leftPct));
                }

                if (right != NULL) {
                    double rightPct = 100.0*atoi(right)/(double)WordSectionContentWidth(section);
                    char buf[100];
                    CSSPut(properties,"margin-right",DFFormatDoublePct(buf,100,rightPct));
                }

                // hanging and firstLine attributes are mutually exclusive. If both are specified,
                // hanging takes precedence
                if (hanging != NULL) {
                    double indentPct = -100.0*atoi(hanging)/(double)WordSectionContentWidth(section);
                    char buf[100];
                    CSSPut(properties,"text-indent",DFFormatDoublePct(buf,100,indentPct));
                }
                else if (firstLine != NULL) {
                    double indentPct = 100.0*atoi(firstLine)/(double)WordSectionContentWidth(section);
                    char buf[100];
                    CSSPut(properties,"text-indent",DFFormatDoublePct(buf,100,indentPct));
                }

                break;
            }
            case WORD_SPACING: {
                const char *before = DFGetAttribute(child,WORD_BEFORE);
                if (before != NULL) { // units: 1/20th of a point
                    char buf[100];
                    CSSPut(properties,"margin-top",DFFormatDoublePt(buf,100,atoi(before)/20.0));
                }

                const char *after = DFGetAttribute(child,WORD_AFTER);
                if (after != NULL) { // units: 1/20th of a point
                    char buf[100];
                    CSSPut(properties,"margin-bottom",DFFormatDoublePt(buf,100,atoi(after)/20.0));
                }

                const char *line = DFGetAttribute(child,WORD_LINE);
                const char *lineRule = DFGetAttribute(child,WORD_LINERULE);
                if ((lineRule == NULL) || !strcmp(lineRule,"auto") || !strcmp(lineRule,"exact")) {
                    // Only other alternative for lineRule is "atLeast", which we ignore
                    if (line != NULL) { // units: 1/2.4th of a percent
                        char buf[100];
                        CSSPut(properties,"line-height",DFFormatDoublePct(buf,100,atoi(line)/2.4));
                    }
                }
                break;
            }
        }
    }
}

void WordPutPPr(DFNode *pPr, CSSProperties *properties, const char *styleId, WordSection *section, int outlineLvl)
{
    assert(pPr->tag == WORD_PPR);

    // The child elements of pPr have to be in a specific order. So we build up a structure based
    // on the existing elements (updated as appropriate from newProperties), and then rebuild
    // from that

    CSSProperties *oldp = CSSPropertiesNew();
    CSSProperties *newp = properties;
    const char *oldStyleId = NULL;
    const char *newStyleId = styleId;
    WordGetPPr(pPr,oldp,&oldStyleId,section);

    {
        DFNode *children[PREDEFINED_TAG_COUNT];
        childrenToArray(pPr,children);

        int existingOutlineLvl = -1;
        if (children[WORD_OUTLINELVL] != NULL) {
            const char *value = DFGetAttribute(children[WORD_OUTLINELVL],WORD_VAL);
            if (value != NULL)
                existingOutlineLvl = atoi(value);
        }

        // Style name
        if (!DFStringEquals(oldStyleId,newStyleId)) {
            if (newStyleId != NULL) {
                children[WORD_PSTYLE] = DFCreateElement(pPr->doc,WORD_PSTYLE);
                DFSetAttribute(children[WORD_PSTYLE],WORD_VAL,newStyleId);
            }
            else {
                children[WORD_PSTYLE] = NULL;
            }
        }

        // Paragraph border (pBdr)

        if (children[WORD_PBDR] == NULL)
            children[WORD_PBDR] = DFCreateElement(pPr->doc,WORD_PBDR);

        WordPutPBdr(children[WORD_PBDR],oldp,newp);

        if (children[WORD_PBDR]->first == NULL)
            children[WORD_PBDR] = NULL;

        // Numbering and outline level
        // Don't change these properties for styles with outline level >= 6, as these can't be
        // represented with the standard HTML heading elements, which only go from h1 - h6
        // (outline levels 0 - 5)
        if (existingOutlineLvl < 6) {
            if (children[WORD_NUMPR] == NULL)
                children[WORD_NUMPR] = DFCreateElement(pPr->doc,WORD_NUMPR);

            WordPutNumPr(children[WORD_NUMPR],newp);

            if (children[WORD_NUMPR]->first == NULL)
                children[WORD_NUMPR] = NULL;

            if ((outlineLvl >= 0) && (outlineLvl <= 5)) {
                if (children[WORD_OUTLINELVL] == NULL)
                    children[WORD_OUTLINELVL] = DFCreateElement(pPr->doc,WORD_OUTLINELVL);
                DFFormatAttribute(children[WORD_OUTLINELVL],WORD_VAL,"%d",outlineLvl);
            }
            else {
                children[WORD_OUTLINELVL] = NULL;
            }
        }

        // background-color

        char *oldBackgroundColor = CSSHexColor(CSSGet(oldp,"background-color"),0);
        char *newBackgroundColor = CSSHexColor(CSSGet(newp,"background-color"),0);
        if (!DFStringEquals(oldBackgroundColor,newBackgroundColor))
            WordPutShd(pPr->doc,&children[WORD_SHD],newBackgroundColor);
        free(oldBackgroundColor);
        free(newBackgroundColor);

        // text-align

        if (!DFStringEquals(CSSGet(oldp,"text-align"),CSSGet(newp,"text-align"))) {
            const char *newTextAlign = CSSGet(newp,"text-align");
            if (newTextAlign != NULL) {
                const char *val = NULL;
                if (!strcmp(newTextAlign,"left"))
                    val = "left";
                else if (!strcmp(newTextAlign,"right"))
                    val = "right";
                else if (!strcmp(newTextAlign,"center"))
                    val = "center";
                else if (!strcmp(newTextAlign,"justify"))
                    val = "both";
                if (val != NULL) {
                    children[WORD_JC] = DFCreateElement(pPr->doc,WORD_JC);
                    DFSetAttribute(children[WORD_JC],WORD_VAL,val);
                }
            }
            else {
                children[WORD_JC] = NULL;
            }
        }

        if ((section != NULL) && (WordSectionContentWidth(section) >= 0)) {
            const char *oldMarginLeft = CSSGet(oldp,"margin-left");
            const char *oldMarginRight = CSSGet(oldp,"margin-right");
            const char *oldTextIndent = CSSGet(oldp,"text-indent");
            const char *newMarginLeft = CSSGet(newp,"margin-left");
            const char *newMarginRight = CSSGet(newp,"margin-right");
            const char *newTextIndent = CSSGet(newp,"text-indent");

            // Special case of the List_Paragraph style, which is used by Word to ensure lists are indented. We
            // don't set this property for HTML, because it automatically indents lists. However we need to ensure
            // that it remains unchanged when updating the word document
            const char *newWordMarginLeft = CSSGet(newp,"-word-margin-left");
            if (newMarginLeft == NULL)
                newMarginLeft = newWordMarginLeft;

            if ((newMarginLeft == NULL) && (newMarginRight == NULL) && (newTextIndent == NULL)) {
                children[WORD_IND] = NULL;
            }
            else {
                if (children[WORD_IND] == NULL)
                    children[WORD_IND] = DFCreateElement(pPr->doc,WORD_IND);

                if (!DFStringEquals(oldMarginLeft,newMarginLeft)) {
                    if (newMarginLeft != NULL)
                        updateTwipsFromLength(children[WORD_IND],WORD_LEFT,newMarginLeft,WordSectionContentWidth(section));
                    else
                        DFRemoveAttribute(children[WORD_IND],WORD_LEFT);
                    DFRemoveAttribute(children[WORD_IND],WORD_START);
                }

                if (!DFStringEquals(oldMarginRight,newMarginRight)) {
                    if (newMarginRight != NULL)
                        updateTwipsFromLength(children[WORD_IND],WORD_RIGHT,newMarginRight,WordSectionContentWidth(section));
                    else
                        DFRemoveAttribute(children[WORD_IND],WORD_RIGHT);
                    DFRemoveAttribute(children[WORD_IND],WORD_END);
                }

                if (!DFStringEquals(oldTextIndent,newTextIndent)) {
                    if (newTextIndent != NULL) {
                        CSSLength length = CSSLengthFromString(newTextIndent);

                        if (CSSLengthIsValid(length)) {
                            double pts = CSSLengthToPts(length,WordSectionContentWidthPts(section));
                            int twips = (int)round(pts*20);

                            if (twips >= 0) {
                                DFFormatAttribute(children[WORD_IND],WORD_FIRSTLINE,"%d",twips);
                                DFRemoveAttribute(children[WORD_IND],WORD_HANGING);
                            }
                            else {
                                DFFormatAttribute(children[WORD_IND],WORD_HANGING,"%d",-twips);
                                DFRemoveAttribute(children[WORD_IND],WORD_FIRSTLINE);
                            }
                        }
                    }
                    else {
                        DFRemoveAttribute(children[WORD_IND],WORD_FIRSTLINE);
                        DFRemoveAttribute(children[WORD_IND],WORD_HANGING);
                    }
                }

            }
        }

        if (!DFStringEquals(CSSGet(oldp,"margin-top"),CSSGet(newp,"margin-top")) ||
            !DFStringEquals(CSSGet(oldp,"margin-bottom"),CSSGet(newp,"margin-bottom")) ||
            !DFStringEquals(CSSGet(oldp,"line-height"),CSSGet(newp,"line-height"))) {

            if ((CSSGet(newp,"margin-top") == NULL) &&
                (CSSGet(newp,"margin-bottom") == NULL) &&
                (CSSGet(newp,"line-height") == NULL)) {
                children[WORD_SPACING] = NULL;
            }
            else {
                children[WORD_SPACING] = DFCreateElement(pPr->doc,WORD_SPACING);

                if (DFStringEquals(CSSGet(newp,"margin-top"),"-word-auto")) {
                    DFSetAttribute(children[WORD_SPACING],WORD_BEFORE,"100");
                    DFSetAttribute(children[WORD_SPACING],WORD_BEFOREAUTOSPACING,"1");
                }
                else {
                    char *before = twipsFromCSS(CSSGet(newp,"margin-top"),WordSectionContentWidth(section));
                    DFSetAttribute(children[WORD_SPACING],WORD_BEFORE,before);
                    DFSetAttribute(children[WORD_SPACING],WORD_BEFOREAUTOSPACING,NULL);
                    free(before);
                }

                if (DFStringEquals(CSSGet(newp,"margin-bottom"),"-word-auto")) {
                    DFSetAttribute(children[WORD_SPACING],WORD_AFTER,"100");
                    DFSetAttribute(children[WORD_SPACING],WORD_AFTERAUTOSPACING,"1");
                }
                else {
                    char *after = twipsFromCSS(CSSGet(newp,"margin-bottom"),WordSectionContentWidth(section));
                    DFSetAttribute(children[WORD_SPACING],WORD_AFTER,after);
                    DFSetAttribute(children[WORD_SPACING],WORD_AFTERAUTOSPACING,NULL);
                    free(after);
                }

                CSSLength lineHeight = CSSLengthFromString(CSSGet(newp,"line-height"));
                if (CSSLengthIsValid(lineHeight) && (lineHeight.units == UnitsPct)) {
                    int value = (int)round(lineHeight.value*2.4);
                    DFFormatAttribute(children[WORD_SPACING],WORD_LINE,"%d",value);
                }
                
                if (children[WORD_SPACING]->attrsCount == 0)
                    children[WORD_SPACING] = NULL;
            }
        }
        
        replaceChildrenFromArray(pPr,children,WordPPR_Children);
    }
    CSSPropertiesRelease(oldp);
}