/*

 * Copyright (C) 2002, 2003 The Karbon Developers

 *               2006       Alexander Kellett <lypanov@kde.org>

 *               2006, 2007 Rob Buis <buis@kde.org>

 * Copyrigth (C) 2007, 2009 Apple, Inc.  All rights reserved.

 * Copyright (C) Research In Motion Limited 2010. 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)

#include "SVGPathParser.h"

#include "AffineTransform.h"

#include "SVGParserUtilities.h"

#include <wtf/MathExtras.h>

static const float gOneOverThree = 1 / 3.f;

namespace WebCore {

SVGPathParser::SVGPathParser(SVGPathConsumer* consumer)

    : m_consumer(consumer)

{

}

SVGPathParser::~SVGPathParser()

{

}

void SVGPathParser::parseClosePathSegment()

{

    // Reset m_currentPoint for the next path.

    if (m_normalized)

        m_currentPoint = m_subPathPoint;

    m_pathClosed = true;

    m_consumer->closePath();

}

bool SVGPathParser::parseMoveToSegment()

{

    float toX;

    float toY;

    if (!parseNumber(m_ptr, m_end, toX) || !parseNumber(m_ptr, m_end, toY))

        return false;

    FloatPoint toPoint(toX, toY);

    if (m_normalized) {

        if (m_mode == RelativeCoordinates)

            m_currentPoint += toPoint;

        else

            m_currentPoint = toPoint;

        m_subPathPoint = m_currentPoint;

        m_consumer->moveTo(m_currentPoint, m_pathClosed, AbsoluteCoordinates);

    } else

        m_consumer->moveTo(toPoint, m_pathClosed, m_mode);

    m_pathClosed = false;

    return true;

}

bool SVGPathParser::parseLineToSegment()

{

    float toX;

    float toY;

    if (!parseNumber(m_ptr, m_end, toX) || !parseNumber(m_ptr, m_end, toY))

        return false;

    FloatPoint toPoint(toX, toY);

    if (m_normalized) {

        if (m_mode == RelativeCoordinates)

            m_currentPoint += toPoint;

        else

            m_currentPoint = toPoint;

        m_consumer->lineTo(m_currentPoint, AbsoluteCoordinates);

    } else

        m_consumer->lineTo(toPoint, m_mode);

    return true;

}

bool SVGPathParser::parseLineToHorizontalSegment()

{

    float toX;

    if (!parseNumber(m_ptr, m_end, toX))

        return false;

    if (m_normalized) {

        if (m_mode == RelativeCoordinates)

            m_currentPoint.move(toX, 0);

        else

            m_currentPoint.setX(toX);

        m_consumer->lineTo(m_currentPoint, AbsoluteCoordinates);

    } else

        m_consumer->lineToHorizontal(toX, m_mode);

    return true;

}

bool SVGPathParser::parseLineToVerticalSegment()

{

    float toY;

    if (!parseNumber(m_ptr, m_end, toY))

        return false;

    if (m_normalized) {

        if (m_mode == RelativeCoordinates)

            m_currentPoint.move(0, toY);

        else

            m_currentPoint.setY(toY);

        m_consumer->lineTo(m_currentPoint, AbsoluteCoordinates);

    } else

        m_consumer->lineToVertical(toY, m_mode);

    return true;

}

bool SVGPathParser::parseCurveToCubicSegment()

{

    float x1;

    float y1;

    float x2;

    float y2;

    float toX;

    float toY; 

    if (!parseNumber(m_ptr, m_end, x1)

        || !parseNumber(m_ptr, m_end, y1)

        || !parseNumber(m_ptr, m_end, x2)

        || !parseNumber(m_ptr, m_end, y2)

        || !parseNumber(m_ptr, m_end, toX)

        || !parseNumber(m_ptr, m_end, toY))

        return false;

    FloatPoint point1(x1, y1);

    FloatPoint point2(x2, y2);

    FloatPoint point3(toX, toY);

    if (m_normalized) {

        if (m_mode == RelativeCoordinates) {

            point1 += m_currentPoint;

            point2 += m_currentPoint;

            point3 += m_currentPoint;

        }

        m_consumer->curveToCubic(point1, point2, point3, AbsoluteCoordinates);

        m_controlPoint = point2;

        m_currentPoint = point3;

    } else

        m_consumer->curveToCubic(point1, point2, point3, m_mode);

    return true;

}

bool SVGPathParser::parseCurveToCubicSmoothSegment()

{

    float x2;

    float y2;

    float toX;

    float toY; 

    if (!parseNumber(m_ptr, m_end, x2)

        || !parseNumber(m_ptr, m_end, y2)

        || !parseNumber(m_ptr, m_end, toX)

        || !parseNumber(m_ptr, m_end, toY))

        return false;

    if (m_lastCommand != 'c'

        && m_lastCommand != 'C'

        && m_lastCommand != 's'

        && m_lastCommand != 'S')

        m_controlPoint = m_currentPoint;

    FloatPoint point2(x2, y2);

    FloatPoint point3(toX, toY);

    if (m_normalized) {

        FloatPoint point1 = m_currentPoint;

        point1.scale(2, 2);

        point1.move(-m_controlPoint.x(), -m_controlPoint.y());

        if (m_mode == RelativeCoordinates) {

            point2 += m_currentPoint;

            point3 += m_currentPoint;

        }

        m_consumer->curveToCubic(point1, point2, point3, AbsoluteCoordinates);

        m_controlPoint = point2;

        m_currentPoint = point3;

    } else

        m_consumer->curveToCubicSmooth(point2, point3, m_mode);

    return true;

}

bool SVGPathParser::parseCurveToQuadraticSegment()

{

    float x1;

    float y1;

    float toX;

    float toY;

    if (!parseNumber(m_ptr, m_end, x1)

        || !parseNumber(m_ptr, m_end, y1)

        || !parseNumber(m_ptr, m_end, toX)

        || !parseNumber(m_ptr, m_end, toY))

        return false;

    FloatPoint point3(toX, toY);

    if (m_normalized) {

        FloatPoint point1 = m_currentPoint;

        point1.move(2 * x1, 2 * y1);

        FloatPoint point2(toX + 2 * x1, toY + 2 * y1);

        if (m_mode == RelativeCoordinates) {

            point1.move(2 * m_currentPoint.x(), 2 * m_currentPoint.y());

            point2.move(3 * m_currentPoint.x(), 3 * m_currentPoint.y());

            point3 += m_currentPoint;

        }

        point1.scale(gOneOverThree, gOneOverThree);

        point2.scale(gOneOverThree, gOneOverThree);

        m_consumer->curveToCubic(point1, point2, point3, AbsoluteCoordinates);

        m_controlPoint = FloatPoint(x1, y1);

        if (m_mode == RelativeCoordinates)

            m_controlPoint += m_currentPoint;

        m_currentPoint = point3;

    } else

        m_consumer->curveToQuadratic(FloatPoint(x1, y1), point3, m_mode);

    return true;

}

bool SVGPathParser::parseCurveToQuadraticSmoothSegment()

{

    float toX;

    float toY;

    if (!parseNumber(m_ptr, m_end, toX) || !parseNumber(m_ptr, m_end, toY))

        return false;

    if (m_lastCommand != 'q'

        && m_lastCommand != 'Q'

        && m_lastCommand != 't'

        && m_lastCommand != 'T')

        m_controlPoint = m_currentPoint;

    if (m_normalized) {

        FloatPoint cubicPoint = m_currentPoint;

        cubicPoint.scale(2, 2);

        cubicPoint.move(-m_controlPoint.x(), -m_controlPoint.y());

        FloatPoint point1(m_currentPoint.x() + 2 * cubicPoint.x(), m_currentPoint.y() + 2 * cubicPoint.y());

        FloatPoint point2(toX + 2 * cubicPoint.x(), toY + 2 * cubicPoint.y());

        FloatPoint point3(toX, toY);

        if (m_mode == RelativeCoordinates) {

            point2 += m_currentPoint;

            point3 += m_currentPoint;

        }

        point1.scale(gOneOverThree, gOneOverThree);

        point2.scale(gOneOverThree, gOneOverThree);

        m_consumer->curveToCubic(point1, point2, point3, AbsoluteCoordinates);

        m_controlPoint = cubicPoint;

        m_currentPoint = point3;

    } else

        m_consumer->curveToQuadraticSmooth(FloatPoint(toX, toY), m_mode);

    return true;

}

bool SVGPathParser::parseArcToSegment()

{

    bool largeArc;

    bool sweep;

    float angle;

    float rx;

    float ry;

    float toX;

    float toY;

    if (!parseNumber(m_ptr, m_end, rx)

        || !parseNumber(m_ptr, m_end, ry)

        || !parseNumber(m_ptr, m_end, angle)

        || !parseArcFlag(m_ptr, m_end, largeArc)

        || !parseArcFlag(m_ptr, m_end, sweep)

        || !parseNumber(m_ptr, m_end, toX)

        || !parseNumber(m_ptr, m_end, toY))

        return false;

    FloatPoint point2 = FloatPoint(toX, toY);

    // If rx = 0 or ry = 0 then this arc is treated as a straight line segment (a "lineto") joining the endpoints.

    // http://www.w3.org/TR/SVG/implnote.html#ArcOutOfRangeParameters

    rx = fabsf(rx);

    ry = fabsf(ry);

    if (!rx || !ry) {

        if (m_normalized) {

            if (m_mode == RelativeCoordinates)

                m_currentPoint += point2;

            else

                m_currentPoint = point2;

            m_consumer->lineTo(m_currentPoint, AbsoluteCoordinates);

        } else

            m_consumer->lineTo(point2, m_mode);

        return true;

    }

    if (m_normalized) {

        FloatPoint point1 = m_currentPoint;

        if (m_mode == RelativeCoordinates)

            point2 += m_currentPoint;

        m_currentPoint = point2;

        return decomposeArcToCubic(angle, rx, ry, point1, point2, largeArc, sweep);

    }

    m_consumer->arcTo(point2, rx, ry, angle, largeArc, sweep, m_mode);

    return true;

}

bool SVGPathParser::parsePathDataString(const String& s, bool normalized)

{

    m_ptr = s.characters();

    m_end = m_ptr + s.length();

    m_normalized = normalized;

    m_controlPoint = FloatPoint();

    m_currentPoint = FloatPoint();

    m_subPathPoint = FloatPoint();

    m_pathClosed = true;

    // Skip any leading spaces.

    if (!skipOptionalSpaces(m_ptr, m_end))

        return false;

    char command = *(m_ptr++);

    m_lastCommand = ' ';

    // Path must start with moveto.

    if (command != 'm' && command != 'M')

        return false;

    while (true) {

        // Skip spaces between command and first coordinate.

        skipOptionalSpaces(m_ptr, m_end);

        m_mode = command >= 'a' && command <= 'z' ? RelativeCoordinates : AbsoluteCoordinates;

        switch (command) {

        case 'm':

        case 'M':

            if (!parseMoveToSegment())

                return false;

            break;

        case 'l':

        case 'L':

            if (!parseLineToSegment())

                return false;

            break;

        case 'h':

        case 'H':

            if (!parseLineToHorizontalSegment())

                return false;

            break;

        case 'v':

        case 'V':

            if (!parseLineToVerticalSegment())

                return false;

            break;

        case 'z':

        case 'Z':

            parseClosePathSegment();

            break;

        case 'c':

        case 'C':

            if (!parseCurveToCubicSegment())

                return false;

            break;

        case 's':

        case 'S':

            if (!parseCurveToCubicSmoothSegment())

                return false;

            break;

        case 'q':

        case 'Q':

            if (!parseCurveToQuadraticSegment())

                return false;

            break;

        case 't':

        case 'T':

            if (!parseCurveToQuadraticSmoothSegment())

                return false;

            break;

        case 'a':

        case 'A':

            if (!parseArcToSegment())

                return false;

            break;

        default:

            return false;

        }

        m_lastCommand = command;

        if (m_ptr >= m_end)

            return true;

        // Check for remaining coordinates in the current command.

        if ((*m_ptr == '+' || *m_ptr == '-' || *m_ptr == '.' || (*m_ptr >= '0' && *m_ptr <= '9'))

            && command != 'z' && command != 'Z') {

            if (command == 'M')

                command = 'L';

            else if (command == 'm')

                command = 'l';

        } else

            command = *(m_ptr++);

        if (m_lastCommand != 'C' && m_lastCommand != 'c'

            && m_lastCommand != 'S' && m_lastCommand != 's'

            && m_lastCommand != 'Q' && m_lastCommand != 'q'

            && m_lastCommand != 'T' && m_lastCommand != 't')

            m_controlPoint = m_currentPoint;

    }

    return false;

}

// This works by converting the SVG arc to "simple" beziers.

// Partly adapted from Niko's code in kdelibs/kdecore/svgicons.

// See also SVG implementation notes: http://www.w3.org/TR/SVG/implnote.html#ArcConversionEndpointToCenter

bool SVGPathParser::decomposeArcToCubic(float angle, float rx, float ry, FloatPoint& point1, FloatPoint& point2, bool largeArcFlag, bool sweepFlag)

{

    FloatSize midPointDistance = point1 - point2;

    midPointDistance.scale(0.5f);

    AffineTransform pointTransform;

    pointTransform.rotate(-angle);

    FloatPoint transformedMidPoint = pointTransform.mapPoint(FloatPoint(midPointDistance.width(), midPointDistance.height()));

    float squareRx = rx * rx;

    float squareRy = ry * ry;

    float squareX = transformedMidPoint.x() * transformedMidPoint.x();

    float squareY = transformedMidPoint.y() * transformedMidPoint.y();

    // Check if the radii are big enough to draw the arc, scale radii if not.

    // http://www.w3.org/TR/SVG/implnote.html#ArcCorrectionOutOfRangeRadii

    float radiiScale = squareX / squareRx + squareY / squareRy;

    if (radiiScale > 1) {

        rx *= sqrtf(radiiScale);

        ry *= sqrtf(radiiScale);

    }

    pointTransform.makeIdentity();

    pointTransform.scale(1 / rx, 1 / ry);

    pointTransform.rotate(-angle);

    point1 = pointTransform.mapPoint(point1);

    point2 = pointTransform.mapPoint(point2);

    FloatSize delta = point2 - point1;

    float d = delta.width() * delta.width() + delta.height() * delta.height();

    float scaleFactorSquared = std::max(1 / d - 0.25f, 0.f);

    float scaleFactor = sqrtf(scaleFactorSquared);

    if (sweepFlag == largeArcFlag)

        scaleFactor = -scaleFactor;

    delta.scale(scaleFactor);

    FloatPoint centerPoint = FloatPoint(0.5f * (point1.x() + point2.x()) - delta.height(),

                                        0.5f * (point1.y() + point2.y()) + delta.width());

    float theta1 = atan2f(point1.y() - centerPoint.y(), point1.x() - centerPoint.x());

    float theta2 = atan2f(point2.y() - centerPoint.y(), point2.x() - centerPoint.x());

    float thetaArc = theta2 - theta1;

    if (thetaArc < 0 && sweepFlag)

        thetaArc += 2 * piFloat;

    else if (thetaArc > 0 && !sweepFlag)

        thetaArc -= 2 * piFloat;

    pointTransform.makeIdentity();

    pointTransform.rotate(angle);

    pointTransform.scale(rx, ry);

    // Some results of atan2 on some platform implementations are not exact enough. So that we get more

    // cubic curves than expected here. Adding 0.001f reduces the count of sgements to the correct count.

    int segments = ceilf(fabsf(thetaArc / (piOverTwoFloat + 0.001f)));

    for (int i = 0; i < segments; ++i) {

        float startTheta = theta1 + i * thetaArc / segments;

        float endTheta = theta1 + (i + 1) * thetaArc / segments;

        float t = (8 / 6.f) * tanf(0.25f * (endTheta - startTheta));

        if (!isfinite(t))

            return false;

        float sinStartTheta = sinf(startTheta);

        float cosStartTheta = cosf(startTheta);

        float sinEndTheta = sinf(endTheta);

        float cosEndTheta = cosf(endTheta);

        point1 = FloatPoint(cosStartTheta - t * sinStartTheta, sinStartTheta + t * cosStartTheta);

        point1.move(centerPoint.x(), centerPoint.y());

        FloatPoint point3 = FloatPoint(cosEndTheta, sinEndTheta);

        point3.move(centerPoint.x(), centerPoint.y());

        point2 = point3;

        point2.move(t * sinEndTheta, -t * cosEndTheta);

        m_consumer->curveToCubic(pointTransform.mapPoint(point1), pointTransform.mapPoint(point2),

                                 pointTransform.mapPoint(point3), AbsoluteCoordinates);

    }

    return true;

}

}

#endif // ENABLE(SVG)