/*
 * Copyright (C) Research In Motion Limited 2010. All rights reserved.
 * Copyright (C) 2013 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 "core/svg/SVGPathStringSource.h"

#include "core/svg/SVGParserUtilities.h"
#include "platform/geometry/FloatPoint.h"

namespace blink {

SVGPathStringSource::SVGPathStringSource(const String& string)
    : m_is8BitSource(string.is8Bit())
    , m_previousCommand(PathSegUnknown)
    , m_string(string)
{
    ASSERT(!string.isNull());

    if (m_is8BitSource) {
        m_current.m_character8 = string.characters8();
        m_end.m_character8 = m_current.m_character8 + string.length();
    } else {
        m_current.m_character16 = string.characters16();
        m_end.m_character16 = m_current.m_character16 + string.length();
    }
    eatWhitespace();
}

void SVGPathStringSource::eatWhitespace()
{
    if (m_is8BitSource)
        skipOptionalSVGSpaces(m_current.m_character8, m_end.m_character8);
    else
        skipOptionalSVGSpaces(m_current.m_character16, m_end.m_character16);
}

static SVGPathSegType mapLetterToSegmentType(unsigned lookahead)
{
    switch (lookahead) {
    case 'Z':
    case 'z':
        return PathSegClosePath;
    case 'M':
        return PathSegMoveToAbs;
    case 'm':
        return PathSegMoveToRel;
    case 'L':
        return PathSegLineToAbs;
    case 'l':
        return PathSegLineToRel;
    case 'C':
        return PathSegCurveToCubicAbs;
    case 'c':
        return PathSegCurveToCubicRel;
    case 'Q':
        return PathSegCurveToQuadraticAbs;
    case 'q':
        return PathSegCurveToQuadraticRel;
    case 'A':
        return PathSegArcAbs;
    case 'a':
        return PathSegArcRel;
    case 'H':
        return PathSegLineToHorizontalAbs;
    case 'h':
        return PathSegLineToHorizontalRel;
    case 'V':
        return PathSegLineToVerticalAbs;
    case 'v':
        return PathSegLineToVerticalRel;
    case 'S':
        return PathSegCurveToCubicSmoothAbs;
    case 's':
        return PathSegCurveToCubicSmoothRel;
    case 'T':
        return PathSegCurveToQuadraticSmoothAbs;
    case 't':
        return PathSegCurveToQuadraticSmoothRel;
    default:
        return PathSegUnknown;
    }
}

static bool isNumberStart(unsigned lookahead)
{
    return (lookahead >= '0' && lookahead <= '9')
        || lookahead == '+'
        || lookahead == '-'
        || lookahead == '.';
}

static bool maybeImplicitCommand(unsigned lookahead, SVGPathSegType previousCommand, SVGPathSegType& nextCommand)
{
    // Check if the current lookahead may start a number - in which case it
    // could be the start of an implicit command. The 'close' command does not
    // have any parameters though and hence can't have an implicit
    // 'continuation'.
    if (!isNumberStart(lookahead) || previousCommand == PathSegClosePath)
        return false;
    // Implicit continuations of moveto command translate to linetos.
    if (previousCommand == PathSegMoveToAbs) {
        nextCommand = PathSegLineToAbs;
        return true;
    }
    if (previousCommand == PathSegMoveToRel) {
        nextCommand = PathSegLineToRel;
        return true;
    }
    nextCommand = previousCommand;
    return true;
}

void SVGPathStringSource::setErrorMark(SVGParseStatus status)
{
    if (m_error.status() != SVGParseStatus::NoError)
        return;
    size_t locus = m_is8BitSource
        ? m_current.m_character8 - m_string.characters8()
        : m_current.m_character16 - m_string.characters16();
    m_error = SVGParsingError(status, locus);
}

float SVGPathStringSource::parseNumberWithError()
{
    float numberValue = 0;
    bool error;
    if (m_is8BitSource)
        error = !parseNumber(m_current.m_character8, m_end.m_character8, numberValue);
    else
        error = !parseNumber(m_current.m_character16, m_end.m_character16, numberValue);
    if (UNLIKELY(error))
        setErrorMark(SVGParseStatus::ExpectedNumber);
    return numberValue;
}

bool SVGPathStringSource::parseArcFlagWithError()
{
    bool flagValue = false;
    bool error;
    if (m_is8BitSource)
        error = !parseArcFlag(m_current.m_character8, m_end.m_character8, flagValue);
    else
        error = !parseArcFlag(m_current.m_character16, m_end.m_character16, flagValue);
    if (UNLIKELY(error))
        setErrorMark(SVGParseStatus::ExpectedArcFlag);
    return flagValue;
}

PathSegmentData SVGPathStringSource::parseSegment()
{
    ASSERT(hasMoreData());
    PathSegmentData segment;
    unsigned lookahead = m_is8BitSource ? *m_current.m_character8 : *m_current.m_character16;
    SVGPathSegType command = mapLetterToSegmentType(lookahead);
    if (UNLIKELY(m_previousCommand == PathSegUnknown)) {
        // First command has to be a moveto.
        if (command != PathSegMoveToRel && command != PathSegMoveToAbs) {
            setErrorMark(SVGParseStatus::ExpectedMoveToCommand);
            return segment;
        }
        // Consume command letter.
        if (m_is8BitSource)
            m_current.m_character8++;
        else
            m_current.m_character16++;
    } else if (command == PathSegUnknown) {
        // Possibly an implicit command.
        ASSERT(m_previousCommand != PathSegUnknown);
        if (!maybeImplicitCommand(lookahead, m_previousCommand, command)) {
            setErrorMark(SVGParseStatus::ExpectedPathCommand);
            return segment;
        }
    } else {
        // Valid explicit command.
        if (m_is8BitSource)
            m_current.m_character8++;
        else
            m_current.m_character16++;
    }

    segment.command = m_previousCommand = command;

    ASSERT(m_error.status() == SVGParseStatus::NoError);

    switch (segment.command) {
    case PathSegCurveToCubicRel:
    case PathSegCurveToCubicAbs:
        segment.point1.setX(parseNumberWithError());
        segment.point1.setY(parseNumberWithError());
        /* fall through */
    case PathSegCurveToCubicSmoothRel:
    case PathSegCurveToCubicSmoothAbs:
        segment.point2.setX(parseNumberWithError());
        segment.point2.setY(parseNumberWithError());
        /* fall through */
    case PathSegMoveToRel:
    case PathSegMoveToAbs:
    case PathSegLineToRel:
    case PathSegLineToAbs:
    case PathSegCurveToQuadraticSmoothRel:
    case PathSegCurveToQuadraticSmoothAbs:
        segment.targetPoint.setX(parseNumberWithError());
        segment.targetPoint.setY(parseNumberWithError());
        break;
    case PathSegLineToHorizontalRel:
    case PathSegLineToHorizontalAbs:
        segment.targetPoint.setX(parseNumberWithError());
        break;
    case PathSegLineToVerticalRel:
    case PathSegLineToVerticalAbs:
        segment.targetPoint.setY(parseNumberWithError());
        break;
    case PathSegClosePath:
        eatWhitespace();
        break;
    case PathSegCurveToQuadraticRel:
    case PathSegCurveToQuadraticAbs:
        segment.point1.setX(parseNumberWithError());
        segment.point1.setY(parseNumberWithError());
        segment.targetPoint.setX(parseNumberWithError());
        segment.targetPoint.setY(parseNumberWithError());
        break;
    case PathSegArcRel:
    case PathSegArcAbs:
        segment.arcRadii().setX(parseNumberWithError());
        segment.arcRadii().setY(parseNumberWithError());
        segment.setArcAngle(parseNumberWithError());
        segment.arcLarge = parseArcFlagWithError();
        segment.arcSweep = parseArcFlagWithError();
        segment.targetPoint.setX(parseNumberWithError());
        segment.targetPoint.setY(parseNumberWithError());
        break;
    case PathSegUnknown:
        ASSERT_NOT_REACHED();
    }

    if (UNLIKELY(m_error.status() != SVGParseStatus::NoError))
        segment.command = PathSegUnknown;
    return segment;
}

} // namespace blink