/*

    Copyright (C) 2004, 2005 Nikolas Zimmermann <wildfox@kde.org>

                  2004, 2005, 2006 Rob Buis <buis@kde.org>

    Copyright (C) 2008 Apple Inc. All rights reserved.

    This library is free software; you can redistribute it and/or

    modify it under the terms of the GNU Library General Public

    License as published by the Free Software Foundation; either

    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License

    along with this library; see the file COPYING.LIB.  If not, write to

    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

    Boston, MA 02110-1301, USA.

*/

#include "config.h"

#if ENABLE(SVG) && ENABLE(SVG_ANIMATION)

#include "SVGAnimateElement.h"

#include "ColorDistance.h"

#include "FloatConversion.h"

#include "SVGColor.h"

#include "SVGParserUtilities.h"

#include "SVGPathSegList.h"

#include "SVGPathSegListBuilder.h"

#include "SVGPointList.h"

#include <math.h>

using namespace std;

namespace WebCore {

SVGAnimateElement::SVGAnimateElement(const QualifiedName& tagName, Document* doc)

    : SVGAnimationElement(tagName, doc)

    , m_propertyType(StringProperty)

    , m_fromNumber(0)

    , m_toNumber(0)

    , m_animatedNumber(numeric_limits<double>::infinity())

{

}

SVGAnimateElement::~SVGAnimateElement()

{

}

static bool parseNumberValueAndUnit(const String& in, double& value, String& unit)

{

    // FIXME: These are from top of my head, figure out all property types that can be animated as numbers.

    unsigned unitLength = 0;

    String parse = in.stripWhiteSpace();

    if (parse.endsWith("%"))

        unitLength = 1;

    else if (parse.endsWith("px") || parse.endsWith("pt") || parse.endsWith("em"))

        unitLength = 2;

    else if (parse.endsWith("deg") || parse.endsWith("rad"))

        unitLength = 3;

    else if (parse.endsWith("grad"))

        unitLength = 4;

    String newUnit = parse.right(unitLength);

    String number = parse.left(parse.length() - unitLength);

    if ((!unit.isEmpty() && newUnit != unit) || number.isEmpty())

        return false;

    UChar last = number[number.length() - 1];

    if (last < '0' || last > '9')

        return false;

    unit = newUnit;

    bool ok;

    value = number.toDouble(&ok);

    return ok;

}

SVGAnimateElement::PropertyType SVGAnimateElement::determinePropertyType(const String& attribute) const

{

    // FIXME: We need a full property table for figuring this out reliably.

    if (hasTagName(SVGNames::animateColorTag))

        return ColorProperty;

    if (attribute == "d")

        return PathProperty;

    if (attribute == "points")

        return PointsProperty;

    if (attribute == "color" || attribute == "fill" || attribute == "stroke")

        return ColorProperty;

    return NumberProperty;

}

void SVGAnimateElement::calculateAnimatedValue(float percentage, unsigned repeat, SVGSMILElement* resultElement)

{

    ASSERT(percentage >= 0.f && percentage <= 1.f);

    ASSERT(resultElement);

    if (hasTagName(SVGNames::setTag))

        percentage = 1.f;

    if (!resultElement->hasTagName(SVGNames::animateTag) && !resultElement->hasTagName(SVGNames::animateColorTag) 

        && !resultElement->hasTagName(SVGNames::setTag))

        return;

    SVGAnimateElement* results = static_cast<SVGAnimateElement*>(resultElement);

    // Can't accumulate over a string property.

    if (results->m_propertyType == StringProperty && m_propertyType != StringProperty)

        return;

    if (m_propertyType == NumberProperty) {

        // To animation uses contributions from the lower priority animations as the base value.

        if (animationMode() == ToAnimation)

            m_fromNumber = results->m_animatedNumber;

        double number = (m_toNumber - m_fromNumber) * percentage + m_fromNumber;

        // FIXME: This is not correct for values animation.

        if (isAccumulated() && repeat)

            number += m_toNumber * repeat;

        if (isAdditive() && animationMode() != ToAnimation)

            results->m_animatedNumber += number;

        else 

            results->m_animatedNumber = number;

        return;

    } 

    if (m_propertyType == ColorProperty) {

        if (animationMode() == ToAnimation)

            m_fromColor = results->m_animatedColor;

        Color color = ColorDistance(m_fromColor, m_toColor).scaledDistance(percentage).addToColorAndClamp(m_fromColor);

        // FIXME: Accumulate colors.

        if (isAdditive() && animationMode() != ToAnimation)

            results->m_animatedColor = ColorDistance::addColorsAndClamp(results->m_animatedColor, color);

        else

            results->m_animatedColor = color;

        return;

    }

    AnimationMode animationMode = this->animationMode();

    if (m_propertyType == PathProperty) {

        if (percentage == 0)

            results->m_animatedPath = m_fromPath;

        else if (percentage == 1.f)

            results->m_animatedPath = m_toPath;

        else {

            if (m_fromPath && m_toPath)

                results->m_animatedPath = SVGPathSegList::createAnimated(m_fromPath.get(), m_toPath.get(), percentage);

            else

                results->m_animatedPath.clear();

            // Fall back to discrete animation if the paths are not compatible

            if (!results->m_animatedPath)

                results->m_animatedPath = ((animationMode == FromToAnimation && percentage > 0.5f) || animationMode == ToAnimation || percentage == 1.0f) 

                    ? m_toPath : m_fromPath;

        }

        return;

    } else if (m_propertyType == PointsProperty) {

        if (percentage == 0)

            results->m_animatedPoints = m_fromPoints;

        else if (percentage == 1.f)

            results->m_animatedPoints = m_toPoints;

        else {

            if (m_fromPoints && m_toPoints)

                results->m_animatedPoints = SVGPointList::createAnimated(m_fromPoints.get(), m_toPoints.get(), percentage);

            else

                results->m_animatedPoints.clear();

            // Fall back to discrete animation if the points are not compatible

            if (!results->m_animatedPoints)

                results->m_animatedPoints = ((animationMode == FromToAnimation && percentage > 0.5f) || animationMode == ToAnimation || percentage == 1.0f) 

                    ? m_toPoints : m_fromPoints;

        }

        return;

    }

    ASSERT(animationMode == FromToAnimation || animationMode == ToAnimation || animationMode == ValuesAnimation);

    if ((animationMode == FromToAnimation && percentage > 0.5f) || animationMode == ToAnimation || percentage == 1.0f)

        results->m_animatedString = m_toString;

    else

        results->m_animatedString = m_fromString;

    // Higher priority replace animation overrides any additive results so far.

    results->m_propertyType = StringProperty;

}

bool SVGAnimateElement::calculateFromAndToValues(const String& fromString, const String& toString)

{

    // FIXME: Needs more solid way determine target attribute type.

    m_propertyType = determinePropertyType(attributeName());

    if (m_propertyType == ColorProperty) {

        m_fromColor = SVGColor::colorFromRGBColorString(fromString);

        m_toColor = SVGColor::colorFromRGBColorString(toString);

        if ((m_fromColor.isValid() && m_toColor.isValid()) || (m_toColor.isValid() && animationMode() == ToAnimation))

            return true;

    } else if (m_propertyType == NumberProperty) {

        m_numberUnit = String();

        if (parseNumberValueAndUnit(toString, m_toNumber, m_numberUnit)) {

            // For to-animations the from number is calculated later

            if (animationMode() == ToAnimation || parseNumberValueAndUnit(fromString, m_fromNumber, m_numberUnit))

                return true;

        }

    } else if (m_propertyType == PathProperty) {

        m_fromPath = SVGPathSegList::create(SVGNames::dAttr);

        SVGPathSegListBuilder fromParser(m_fromPath.get());

        if (fromParser.build(fromString, UnalteredParsing)) {

            m_toPath = SVGPathSegList::create(SVGNames::dAttr);

            SVGPathSegListBuilder toParser(m_toPath.get());

            if (toParser.build(toString, UnalteredParsing))

                return true;

        }

        m_fromPath.clear();

        m_toPath.clear();

    } else if (m_propertyType == PointsProperty) {

        m_fromPoints = SVGPointList::create(SVGNames::pointsAttr);

        if (pointsListFromSVGData(m_fromPoints.get(), fromString)) {

            m_toPoints = SVGPointList::create(SVGNames::pointsAttr);

            if (pointsListFromSVGData(m_toPoints.get(), toString))

                return true;

        }

        m_fromPoints.clear();

        m_toPoints.clear();

    }

    m_fromString = fromString;

    m_toString = toString;

    m_propertyType = StringProperty;

    return true;

}

bool SVGAnimateElement::calculateFromAndByValues(const String& fromString, const String& byString)

{

    ASSERT(!hasTagName(SVGNames::setTag));

    m_propertyType = determinePropertyType(attributeName());

    if (m_propertyType == ColorProperty) {

        m_fromColor = fromString.isEmpty() ? Color() : SVGColor::colorFromRGBColorString(fromString);

        m_toColor = ColorDistance::addColorsAndClamp(m_fromColor, SVGColor::colorFromRGBColorString(byString));

        if (!m_fromColor.isValid() || !m_toColor.isValid())

            return false;

    } else {

        m_numberUnit = String();

        m_fromNumber = 0;

        if (!fromString.isEmpty() && !parseNumberValueAndUnit(fromString, m_fromNumber, m_numberUnit))

            return false;

        if (!parseNumberValueAndUnit(byString, m_toNumber, m_numberUnit))

            return false;

        m_toNumber += m_fromNumber;

    }

    return true;

}

void SVGAnimateElement::resetToBaseValue(const String& baseString)

{

    m_animatedString = baseString;

    PropertyType lastType = m_propertyType;

    m_propertyType = determinePropertyType(attributeName());

    if (m_propertyType == ColorProperty) {

        m_animatedColor = baseString.isEmpty() ? Color() : SVGColor::colorFromRGBColorString(baseString);

        if (isContributing(elapsed())) {

            m_propertyType = lastType;

            return;

        }

    } else if (m_propertyType == NumberProperty) {

        if (baseString.isEmpty()) {

            m_animatedNumber = 0;

            m_numberUnit = String();

            return;

        }

        if (parseNumberValueAndUnit(baseString, m_animatedNumber, m_numberUnit))

            return;

    } else if (m_propertyType == PathProperty) {

        m_animatedPath.clear();

        return;

    } else if (m_propertyType == PointsProperty) {

        m_animatedPoints.clear();

        return;

    }

    m_propertyType = StringProperty;

}

void SVGAnimateElement::applyResultsToTarget()

{

    String valueToApply;

    if (m_propertyType == ColorProperty)

        valueToApply = m_animatedColor.name();

    else if (m_propertyType == NumberProperty)

        valueToApply = String::number(m_animatedNumber) + m_numberUnit;

    else if (m_propertyType == PathProperty) {

        if (!m_animatedPath || !m_animatedPath->numberOfItems())

            valueToApply = m_animatedString;

        else {

            // We need to keep going to string and back because we are currently only able to paint

            // "processed" paths where complex shapes are replaced with simpler ones. Path 

            // morphing needs to be done with unprocessed paths.

            // FIXME: This could be optimized if paths were not processed at parse time.

            unsigned itemCount = m_animatedPath->numberOfItems();

            ExceptionCode ec;

            for (unsigned n = 0; n < itemCount; ++n) {

                RefPtr<SVGPathSeg> segment = m_animatedPath->getItem(n, ec);

                valueToApply.append(segment->toString() + " ");

            }

        }

    } else if (m_propertyType == PointsProperty) {

        if (!m_animatedPoints || !m_animatedPoints->numberOfItems())

            valueToApply = m_animatedString;

        else

            valueToApply = m_animatedPoints->valueAsString();

    } else

        valueToApply = m_animatedString;

    setTargetAttributeAnimatedValue(valueToApply);

}

float SVGAnimateElement::calculateDistance(const String& fromString, const String& toString)

{

    m_propertyType = determinePropertyType(attributeName());

    if (m_propertyType == NumberProperty) {

        double from;

        double to;

        String unit;

        if (!parseNumberValueAndUnit(fromString, from, unit))

            return -1.f;

        if (!parseNumberValueAndUnit(toString, to, unit))

            return -1.f;

        return narrowPrecisionToFloat(fabs(to - from));

    } else if (m_propertyType == ColorProperty) {

        Color from = SVGColor::colorFromRGBColorString(fromString);

        if (!from.isValid())

            return -1.f;

        Color to = SVGColor::colorFromRGBColorString(toString);

        if (!to.isValid())

            return -1.f;

        return ColorDistance(from, to).distance();

    }

    return -1.f;

}

}

// vim:ts=4:noet

#endif // ENABLE(SVG)