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