// 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 "CSSStyle.h"
#include "CSSSheet.h"
#include "CSS.h"
#include "CSSProperties.h"
#include "CSSSelector.h"
#include "DFHTML.h"
#include "DFHashTable.h"
#include "DFString.h"
#include "DFCommon.h"
#include "DFPlatform.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

////////////////////////////////////////////////////////////////////////////////////////////////////
//                                                                                                //
//                                            CSSStyle                                            //
//                                                                                                //
////////////////////////////////////////////////////////////////////////////////////////////////////

// FIXME: The dirty property is supposed to be set whenever any aspect if this style changes,
// including any property of one of its rules, and the addition or removal of rules.

// I'm not sure if this is actually relevant in the context of the new model under which we set
// the stylesheet as a whole, because the in the old model styles were updated individually
// (which caused serialization of the entire stylesheet anyway, just in javascript).

static void ruleChanged(void *ctx, void *object, void *data)
{
    CSSStyle *style = (CSSStyle *)ctx;
    CSSProperties *properties = (CSSProperties *)object;
    if (properties->dirty) {
        properties->dirty = 0;
        if (!style->dirty) { // Minimise callback invocations
            style->dirty = 1;
            DFCallbackInvoke(style->changeCallbacks,style,NULL);
        }
    }
}

CSSStyle *CSSStyleNew(const char *selector)
{
    CSSStyle *style = (CSSStyle *)xcalloc(1,sizeof(CSSStyle));
    style->retainCount = 1;
    CSSStyleSetSelector(style,selector);
    style->rules = DFHashTableNew((DFCopyFunction)CSSPropertiesRetain,(DFFreeFunction)CSSPropertiesRelease);
    CSSStyleRuleForSuffix(style,""); // Create the base rule
    return style;
}

CSSStyle *CSSStyleRetain(CSSStyle *style)
{
    if (style != NULL)
        style->retainCount++;

    return style;
}

void CSSStyleRelease(CSSStyle *style)
{
    if ((style == NULL) || (--style->retainCount > 0))
        return;

    free(style->selector);
    free(style->elementName);
    free(style->className);
    const char **keys = DFHashTableCopyKeys(style->rules);
    for (int i = 0; keys[i]; i++) {
        CSSProperties *rule = DFHashTableLookup(style->rules,keys[i]);
        DFCallbackRemove(&rule->changeCallbacks,ruleChanged,style);
    }
    free(keys);
    DFHashTableRelease(style->rules);
    assert(style->changeCallbacks == NULL);
    free(style);
}

void CSSStyleSetSelector(CSSStyle *style, const char *newSelector)
{
    // Take a copy of newSelector first, just in case it's one of the values we're about to free
    char *selector = xstrdup(newSelector);

    free(style->selector);
    free(style->elementName);
    free(style->className);

    style->selector = selector;
    style->elementName = CSSSelectorCopyElementName(style->selector);
    style->className = CSSSelectorCopyClassName(style->selector);
    style->tag = CSSSelectorGetTag(style->selector);
    style->headingLevel = CSSSelectorHeadingLevel(style->selector);
    style->family = CSSSelectorFamily(style->selector);
}

int CSSStyleIsCustom(CSSStyle *style)
{
    if (CSSGetDefault(CSSStyleRule(style)))
        return 0;
    if (CSSIsBuiltinSelector(style->selector))
        return 0;
    return 1;
}

char *CSSStyleCopyParent(CSSStyle *style)
{
    const char *quotedValue = CSSGet(CSSStyleRule(style),"-uxwrite-parent");
    return DFUnquote(quotedValue);
}

void CSSStyleSetParent(CSSStyle *style, const char *newParent)
{
    char *quotedParent = DFQuote(newParent);
    CSSPut(CSSStyleRule(style),"-uxwrite-parent",quotedParent);
    free(quotedParent);
}

char *CSSStyleCopyNext(CSSStyle *style)
{
    const char *quotedValue = CSSGet(CSSStyleRule(style),"-uxwrite-next");
    return DFUnquote(quotedValue);
}

void CSSStyleSetNext(CSSStyle *style, const char *newNext)
{
    char *quotedNext = DFQuote(newNext);
    CSSPut(CSSStyleRule(style),"-uxwrite-next",quotedNext);
    free(quotedNext);
}

char *CSSStyleCopyDisplayName(CSSStyle *style)
{
    const char *quotedValue = CSSGet(CSSStyleRule(style),"-uxwrite-display-name");
    return DFUnquote(quotedValue);
}

void CSSStyleSetDisplayName(CSSStyle *style, const char *newDisplayName)
{
    char *quotedDisplayName = DFQuote(newDisplayName);
    CSSPut(CSSStyleRule(style),"-uxwrite-display-name",quotedDisplayName);
    free(quotedDisplayName);
}

const char **CSSStyleCopySuffixes(CSSStyle *style)
{
    return DFHashTableCopyKeys(style->rules);
}

CSSProperties *CSSStyleRuleForSuffix(CSSStyle *style, const char *suffix)
{
    if (style == NULL)
        return NULL;;

    CSSProperties *result = DFHashTableLookup(style->rules,suffix);
    if (result == NULL) {
        result = CSSPropertiesNew();
        DFHashTableAdd(style->rules,suffix,result);
        DFCallbackAdd(&result->changeCallbacks,ruleChanged,style);
        CSSPropertiesRelease(result);
    }
    return result;
}

static const char *suffixForTableComponent(const char *tableComponent)
{
    if (tableComponent == NULL)
        return NULL;
    else if (!strcmp(tableComponent,"wholeTable"))
        return DFTableSuffixWholeTable;
    else if (!strcmp(tableComponent,"cell"))
        return DFTableSuffixCell;
    else if (!strcmp(tableComponent,"firstRow"))
        return DFTableSuffixFirstRow;
    else if (!strcmp(tableComponent,"lastRow"))
        return DFTableSuffixLastRow;
    else if (!strcmp(tableComponent,"firstCol"))
        return DFTableSuffixFirstCol;
    else if (!strcmp(tableComponent,"lastCol"))
        return DFTableSuffixLastCol;
    else if (!strcmp(tableComponent,"band1Vert"))
        return DFTableSuffixBand1Vert;
    else if (!strcmp(tableComponent,"band2Vert"))
        return DFTableSuffixBand2Vert;
    else if (!strcmp(tableComponent,"band1Horz"))
        return DFTableSuffixBand1Horz;
    else if (!strcmp(tableComponent,"band2Horz"))
        return DFTableSuffixBand2Horz;
    else if (!strcmp(tableComponent,"nwCell"))
        return DFTableSuffixNWCell;
    else if (!strcmp(tableComponent,"neCell"))
        return DFTableSuffixNECell;
    else if (!strcmp(tableComponent,"swCell"))
        return DFTableSuffixSWCell;
    else if (!strcmp(tableComponent,"seCell"))
        return DFTableSuffixSECell;
    else
        return NULL;
}

CSSProperties *CSSStyleRuleForTableComponent(CSSStyle *style, const char *tableComponent)
{
    const char *suffix = suffixForTableComponent(tableComponent);
    if (suffix == NULL)
        return NULL;
    return CSSStyleRuleForSuffix(style,suffix);
}

CSSProperties *CSSStyleRule(CSSStyle *style)
{
    return CSSStyleRuleForSuffix(style,"");
}

int CSSStyleIsEmpty(CSSStyle *style)
{
    const char **allSuffixes = CSSStyleCopySuffixes(style);
    for (int i = 0; allSuffixes[i]; i++) {
        const char *suffix = allSuffixes[i];
        CSSProperties *properties = CSSStyleRuleForSuffix(style,suffix);
        if (DFHashTableCount(properties->hashTable) > 0) {
            free(allSuffixes);
            return 0;
        }
    }
    free(allSuffixes);
    return 1;
}

CSSProperties *CSSStyleCell(CSSStyle *style)
{
    return CSSStyleRuleForSuffix(style,DFTableSuffixCell);
}

CSSProperties *CSSStyleBefore(CSSStyle *style)
{
    return CSSStyleRuleForSuffix(style,"::before");
}

void CSSStyleAddDefaultHTMLProperties(CSSStyle *style)
{
    // FIXME: Not covered by tests
    char *elementName = CSSSelectorCopyElementName(style->selector);
    char *className = CSSSelectorCopyClassName(style->selector);
    if ((className == NULL) && (strlen(elementName) == 2) && (elementName[0] == 'h')) {
        CSSProperties *rule = CSSStyleRule(style);
        if (!strcmp(elementName,"h1")) {
            if (CSSGet(rule,"font-weight") == NULL)
                CSSPut(rule,"font-weight","bold");
            if (CSSGet(rule,"font-size") == NULL)
                CSSPut(rule,"font-size","24pt");
        }
        else if (!strcmp(elementName,"h2")) {
            if (CSSGet(rule,"font-weight") == NULL)
                CSSPut(rule,"font-weight","bold");
            if (CSSGet(rule,"font-size") == NULL)
                CSSPut(rule,"font-size","18pt");
        }
        else if (!strcmp(elementName,"h3")) {
            if (CSSGet(rule,"font-weight") == NULL)
                CSSPut(rule,"font-weight","bold");
            if (CSSGet(rule,"font-size") == NULL)
                CSSPut(rule,"font-size","14pt");
        }
        else if (!strcmp(elementName,"h4")) {
            if (CSSGet(rule,"font-weight") == NULL)
                CSSPut(rule,"font-weight","bold");
            if (CSSGet(rule,"font-size") == NULL)
                CSSPut(rule,"font-size","12pt");
        }
        else if (!strcmp(elementName,"h5")) {
            if (CSSGet(rule,"font-weight") == NULL)
                CSSPut(rule,"font-weight","bold");
            if (CSSGet(rule,"font-size") == NULL)
                CSSPut(rule,"font-size","10pt");
        }
        else if (!strcmp(elementName,"h6")) {
            if (CSSGet(rule,"font-weight") == NULL)
                CSSPut(rule,"font-weight","bold");
            if (CSSGet(rule,"font-size") == NULL)
                CSSPut(rule,"font-size","8pt");
        }
    }
    free(elementName);
    free(className);
}

void CSSStylePrint(CSSStyle *style, const char *indent)
{
    char *propertiesIndent = DFFormatString("%s    ",indent);

    const char **allSuffixes = CSSStyleCopySuffixes(style);
    DFSortStringsCaseInsensitive(allSuffixes);
    for (int suffixIndex = 0; allSuffixes[suffixIndex]; suffixIndex++) {
        const char *suffix = allSuffixes[suffixIndex];
        char *quotedSuffix = DFQuote(suffix);
        printf("%ssuffix %s\n",indent,quotedSuffix);
        free(quotedSuffix);
        CSSProperties *properties = CSSStyleRuleForSuffix(style,suffix);
        CSSPropertiesPrint(properties,propertiesIndent);
    }
    free(allSuffixes);

    free(propertiesIndent);
}