/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "nsSMILParserUtils.h"

#include "mozilla/TextUtils.h"

#include "nsSMILKeySpline.h"

#include "nsISMILAttr.h"

#include "nsSMILValue.h"

#include "nsSMILTimeValue.h"

#include "nsSMILTimeValueSpecParams.h"

#include "nsSMILTypes.h"

#include "nsSMILRepeatCount.h"

#include "nsContentUtils.h"

#include "nsCharSeparatedTokenizer.h"

#include "SVGContentUtils.h"

using namespace mozilla;

using namespace mozilla::dom;

//------------------------------------------------------------------------------

// Helper functions and Constants

namespace {

const uint32_t MSEC_PER_SEC  = 1000;

const uint32_t MSEC_PER_MIN  = 1000 * 60;

const uint32_t MSEC_PER_HOUR = 1000 * 60 * 60;

#define ACCESSKEY_PREFIX_LC NS_LITERAL_STRING("accesskey(") // SMIL2+

#define ACCESSKEY_PREFIX_CC NS_LITERAL_STRING("accessKey(") // SVG/SMIL ANIM

#define REPEAT_PREFIX    NS_LITERAL_STRING("repeat(")

#define WALLCLOCK_PREFIX NS_LITERAL_STRING("wallclock(")

inline bool

SkipWhitespace(RangedPtr<const char16_t>& aIter,

               const RangedPtr<const char16_t>& aEnd)

{

  while (aIter != aEnd) {

    if (!nsContentUtils::IsHTMLWhitespace(*aIter)) {

      return true;

    }

    ++aIter;

  }

  return false;

}

inline bool

ParseColon(RangedPtr<const char16_t>& aIter,

           const RangedPtr<const char16_t>& aEnd)

{

  if (aIter == aEnd || *aIter != ':') {

    return false;

  }

  ++aIter;

  return true;

}

/*

 * Exactly two digits in the range 00 - 59 are expected.

 */

bool

ParseSecondsOrMinutes(RangedPtr<const char16_t>& aIter,

                      const RangedPtr<const char16_t>& aEnd,

                      uint32_t& aValue)

{

  if (aIter == aEnd || !mozilla::IsAsciiDigit(*aIter)) {

    return false;

  }

  RangedPtr<const char16_t> iter(aIter);

  if (++iter == aEnd || !mozilla::IsAsciiDigit(*iter)) {

     return false;

  }

  uint32_t value = 10 * mozilla::AsciiAlphanumericToNumber(*aIter) +

                   mozilla::AsciiAlphanumericToNumber(*iter);

  if (value > 59) {

    return false;

  }

  if (++iter != aEnd && mozilla::IsAsciiDigit(*iter)) {

    return false;

  }

  aValue = value;

  aIter = iter;

  return true;

}

inline bool

ParseClockMetric(RangedPtr<const char16_t>& aIter,

                 const RangedPtr<const char16_t>& aEnd,

                 uint32_t& aMultiplier)

{

  if (aIter == aEnd) {

    aMultiplier = MSEC_PER_SEC;

    return true;

  }

  switch (*aIter) {

  case 'h':

    if (++aIter == aEnd) {

      aMultiplier = MSEC_PER_HOUR;

      return true;

    }

    return false;

  case 'm':

    {

      const nsAString& metric = Substring(aIter.get(), aEnd.get());

      if (metric.EqualsLiteral("min")) {

        aMultiplier = MSEC_PER_MIN;

        aIter = aEnd;

        return true;

      }

      if (metric.EqualsLiteral("ms")) {

        aMultiplier = 1;

        aIter = aEnd;

        return true;

      }

    }

    return false;

  case 's':

    if (++aIter == aEnd) {

      aMultiplier = MSEC_PER_SEC;

      return true;

    }

  }

  return false;

}

/**

 * See http://www.w3.org/TR/SVG/animate.html#ClockValueSyntax

 */

bool

ParseClockValue(RangedPtr<const char16_t>& aIter,

                const RangedPtr<const char16_t>& aEnd,

                nsSMILTimeValue* aResult)

{

  if (aIter == aEnd) {

    return false;

  }

  // TIMECOUNT_VALUE     ::= Timecount ("." Fraction)? (Metric)?

  // PARTIAL_CLOCK_VALUE ::= Minutes ":" Seconds ("." Fraction)?

  // FULL_CLOCK_VALUE    ::= Hours ":" Minutes ":" Seconds ("." Fraction)?

  enum ClockType {

    TIMECOUNT_VALUE,

    PARTIAL_CLOCK_VALUE,

    FULL_CLOCK_VALUE

  };

  int32_t clockType = TIMECOUNT_VALUE;

  RangedPtr<const char16_t> iter(aIter);

  // Determine which type of clock value we have by counting the number

  // of colons in the string.

  do {

    switch (*iter) {

    case ':':

       if (clockType == FULL_CLOCK_VALUE) {

         return false;

       }

       ++clockType;

       break;

    case 'e':

    case 'E':

    case '-':

    case '+':

      // Exclude anything invalid (for clock values)

      // that number parsing might otherwise allow.

      return false;

    }

    ++iter;

  } while (iter != aEnd);

  iter = aIter;

  int32_t hours = 0, timecount;

  double fraction = 0.0;

  uint32_t minutes, seconds, multiplier;

  switch (clockType) {

    case FULL_CLOCK_VALUE:

      if (!SVGContentUtils::ParseInteger(iter, aEnd, hours) ||

          !ParseColon(iter, aEnd)) {

        return false;

      }

      MOZ_FALLTHROUGH;

    case PARTIAL_CLOCK_VALUE:

      if (!ParseSecondsOrMinutes(iter, aEnd, minutes) ||

          !ParseColon(iter, aEnd) ||

          !ParseSecondsOrMinutes(iter, aEnd, seconds)) {

        return false;

      }

      if (iter != aEnd &&

          (*iter != '.' ||

           !SVGContentUtils::ParseNumber(iter, aEnd, fraction))) {

        return false;

      }

      aResult->SetMillis(nsSMILTime(hours) * MSEC_PER_HOUR +

                         minutes * MSEC_PER_MIN +

                         seconds * MSEC_PER_SEC +

                         NS_round(fraction * MSEC_PER_SEC));

      aIter = iter;

      return true;

    case TIMECOUNT_VALUE:

      if (!SVGContentUtils::ParseInteger(iter, aEnd, timecount)) {

        return false;

      }

      if (iter != aEnd && *iter == '.' &&

          !SVGContentUtils::ParseNumber(iter, aEnd, fraction)) {

        return false;

      }

      if (!ParseClockMetric(iter, aEnd, multiplier)) {

        return false;

      }

      aResult->SetMillis(nsSMILTime(timecount) * multiplier +

                         NS_round(fraction * multiplier));

      aIter = iter;

      return true;

  }

  return false;

}

bool

ParseOffsetValue(RangedPtr<const char16_t>& aIter,

                 const RangedPtr<const char16_t>& aEnd,

                 nsSMILTimeValue* aResult)

{

  RangedPtr<const char16_t> iter(aIter);

  int32_t sign;

  if (!SVGContentUtils::ParseOptionalSign(iter, aEnd, sign) ||

      !SkipWhitespace(iter, aEnd) ||

      !ParseClockValue(iter, aEnd, aResult)) {

    return false;

  }

  if (sign == -1) {

    aResult->SetMillis(-aResult->GetMillis());

  }

  aIter = iter;

  return true;

}

bool

ParseOffsetValue(const nsAString& aSpec,

                 nsSMILTimeValue* aResult)

{

  RangedPtr<const char16_t> iter(SVGContentUtils::GetStartRangedPtr(aSpec));

  const RangedPtr<const char16_t> end(SVGContentUtils::GetEndRangedPtr(aSpec));

  return ParseOffsetValue(iter, end, aResult) && iter == end;

}

bool

ParseOptionalOffset(RangedPtr<const char16_t>& aIter,

                    const RangedPtr<const char16_t>& aEnd,

                    nsSMILTimeValue* aResult)

{

  if (aIter == aEnd) {

    aResult->SetMillis(0L);

    return true;

  }

  return SkipWhitespace(aIter, aEnd) &&

         ParseOffsetValue(aIter, aEnd, aResult);

}

void

MoveToNextToken(RangedPtr<const char16_t>& aIter,

                const RangedPtr<const char16_t>& aEnd,

                bool aBreakOnDot,

                bool& aIsAnyCharEscaped)

{

  aIsAnyCharEscaped = false;

  bool isCurrentCharEscaped = false;

  while (aIter != aEnd && !nsContentUtils::IsHTMLWhitespace(*aIter)) {

    if (isCurrentCharEscaped) {

      isCurrentCharEscaped = false;

    } else {

      if (*aIter == '+' || *aIter == '-' ||

          (aBreakOnDot && *aIter == '.')) {

        break;

      }

      if (*aIter == '\\') {

        isCurrentCharEscaped = true;

        aIsAnyCharEscaped = true;

      }

    }

    ++aIter;

  }

}

already_AddRefed<nsAtom>

ConvertUnescapedTokenToAtom(const nsAString& aToken)

{

  // Whether the token is an id-ref or event-symbol it should be a valid NCName

  if (aToken.IsEmpty() || NS_FAILED(nsContentUtils::CheckQName(aToken, false)))

    return nullptr;

  return NS_Atomize(aToken);

}

already_AddRefed<nsAtom>

ConvertTokenToAtom(const nsAString& aToken,

                   bool aUnescapeToken)

{

  // Unescaping involves making a copy of the string which we'd like to avoid if possible

  if (!aUnescapeToken) {

    return ConvertUnescapedTokenToAtom(aToken);

  }

  nsAutoString token(aToken);

  const char16_t* read = token.BeginReading();

  const char16_t* const end = token.EndReading();

  char16_t* write = token.BeginWriting();

  bool escape = false;

  while (read != end) {

    MOZ_ASSERT(write <= read, "Writing past where we've read");

    if (!escape && *read == '\\') {

      escape = true;

      ++read;

    } else {

      *write++ = *read++;

      escape = false;

    }

  }

  token.Truncate(write - token.BeginReading());

  return ConvertUnescapedTokenToAtom(token);

}

bool

ParseElementBaseTimeValueSpec(const nsAString& aSpec,

                              nsSMILTimeValueSpecParams& aResult)

{

  nsSMILTimeValueSpecParams result;

  //

  // The spec will probably look something like one of these

  //

  // element-name.begin

  // element-name.event-name

  // event-name

  // element-name.repeat(3)

  // event\.name

  //

  // Technically `repeat(3)' is permitted but the behaviour in this case is not

  // defined (for SMIL Animation) so we don't support it here.

  //

  RangedPtr<const char16_t> start(SVGContentUtils::GetStartRangedPtr(aSpec));

  RangedPtr<const char16_t> end(SVGContentUtils::GetEndRangedPtr(aSpec));

  if (start == end) {

    return false;

  }

  RangedPtr<const char16_t> tokenEnd(start);

  bool requiresUnescaping;

  MoveToNextToken(tokenEnd, end, true, requiresUnescaping);

  RefPtr<nsAtom> atom =

    ConvertTokenToAtom(Substring(start.get(), tokenEnd.get()),

                       requiresUnescaping);

  if (atom == nullptr) {

    return false;

  }

  // Parse the second token if there is one

  if (tokenEnd != end && *tokenEnd == '.') {

    result.mDependentElemID = atom;

    ++tokenEnd;

    start = tokenEnd;

    MoveToNextToken(tokenEnd, end, false, requiresUnescaping);

    const nsAString& token2 = Substring(start.get(), tokenEnd.get());

    // element-name.begin

    if (token2.EqualsLiteral("begin")) {

      result.mType = nsSMILTimeValueSpecParams::SYNCBASE;

      result.mSyncBegin = true;

    // element-name.end

    } else if (token2.EqualsLiteral("end")) {

      result.mType = nsSMILTimeValueSpecParams::SYNCBASE;

      result.mSyncBegin = false;

    // element-name.repeat(digit+)

    } else if (StringBeginsWith(token2, REPEAT_PREFIX)) {

      start += REPEAT_PREFIX.Length();

      int32_t repeatValue;

      if (start == tokenEnd || *start == '+' || *start == '-' ||

          !SVGContentUtils::ParseInteger(start, tokenEnd, repeatValue)) {

        return false;

      }

      if (start == tokenEnd || *start != ')') {

        return false;

      }

      result.mType = nsSMILTimeValueSpecParams::REPEAT;

      result.mRepeatIteration = repeatValue;

    // element-name.event-symbol

    } else {

      atom = ConvertTokenToAtom(token2, requiresUnescaping);

      if (atom == nullptr) {

        return false;

      }

      result.mType = nsSMILTimeValueSpecParams::EVENT;

      result.mEventSymbol = atom;

    }

  } else {

    // event-symbol

    result.mType = nsSMILTimeValueSpecParams::EVENT;

    result.mEventSymbol = atom;

  }

  // We've reached the end of the token, so we should now be either looking at

  // a '+', '-' (possibly with whitespace before it), or the end.

  if (!ParseOptionalOffset(tokenEnd, end, &result.mOffset) || tokenEnd != end) {

    return false;

  }

  aResult = result;

  return true;

}

} // namespace

//------------------------------------------------------------------------------

// Implementation

const nsDependentSubstring

nsSMILParserUtils::TrimWhitespace(const nsAString& aString)

{

  nsAString::const_iterator start, end;

  aString.BeginReading(start);

  aString.EndReading(end);

  // Skip whitespace characters at the beginning

  while (start != end && nsContentUtils::IsHTMLWhitespace(*start)) {

    ++start;

  }

  // Skip whitespace characters at the end.

  while (end != start) {

    --end;

    if (!nsContentUtils::IsHTMLWhitespace(*end)) {

      // Step back to the last non-whitespace character.

      ++end;

      break;

    }

  }

  return Substring(start, end);

}

bool

nsSMILParserUtils::ParseKeySplines(const nsAString& aSpec,

                                   FallibleTArray<nsSMILKeySpline>& aKeySplines)

{

  nsCharSeparatedTokenizerTemplate<nsContentUtils::IsHTMLWhitespace>

    controlPointTokenizer(aSpec, ';');

  while (controlPointTokenizer.hasMoreTokens()) {

    nsCharSeparatedTokenizerTemplate<nsContentUtils::IsHTMLWhitespace>

      tokenizer(controlPointTokenizer.nextToken(), ',',

                nsCharSeparatedTokenizer::SEPARATOR_OPTIONAL);

    double values[4];

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

      if (!tokenizer.hasMoreTokens() ||

          !SVGContentUtils::ParseNumber(tokenizer.nextToken(), values[i]) ||

          values[i] > 1.0 || values[i] < 0.0) {

        return false;

      }

    }

    if (tokenizer.hasMoreTokens() ||

        tokenizer.separatorAfterCurrentToken() ||

        !aKeySplines.AppendElement(nsSMILKeySpline(values[0],

                                                   values[1],

                                                   values[2],

                                                   values[3]),

                                   fallible)) {

      return false;

    }

  }

  return !aKeySplines.IsEmpty();

}

bool

nsSMILParserUtils::ParseSemicolonDelimitedProgressList(const nsAString& aSpec,

                                                       bool aNonDecreasing,

                                                       FallibleTArray<double>& aArray)

{

  nsCharSeparatedTokenizerTemplate<nsContentUtils::IsHTMLWhitespace>

    tokenizer(aSpec, ';');

  double previousValue = -1.0;

  while (tokenizer.hasMoreTokens()) {

    double value;

    if (!SVGContentUtils::ParseNumber(tokenizer.nextToken(), value)) {

      return false;

    }

    if (value > 1.0 || value < 0.0 ||

        (aNonDecreasing && value < previousValue)) {

      return false;

    }

    if (!aArray.AppendElement(value, fallible)) {

      return false;

    }

    previousValue = value;

  }

  return !aArray.IsEmpty();

}

// Helper class for ParseValues

class MOZ_STACK_CLASS SMILValueParser :

  public nsSMILParserUtils::GenericValueParser

{

public:

  SMILValueParser(const SVGAnimationElement* aSrcElement,

                  const nsISMILAttr* aSMILAttr,

                  FallibleTArray<nsSMILValue>* aValuesArray,

                  bool* aPreventCachingOfSandwich) :

    mSrcElement(aSrcElement),

    mSMILAttr(aSMILAttr),

    mValuesArray(aValuesArray),

    mPreventCachingOfSandwich(aPreventCachingOfSandwich)

  {}

  virtual bool Parse(const nsAString& aValueStr) override {

    nsSMILValue newValue;

    bool tmpPreventCachingOfSandwich = false;

    if (NS_FAILED(mSMILAttr->ValueFromString(aValueStr, mSrcElement, newValue,

                                             tmpPreventCachingOfSandwich)))

      return false;

    if (!mValuesArray->AppendElement(newValue, fallible)) {

      return false;

    }

    if (tmpPreventCachingOfSandwich) {

      *mPreventCachingOfSandwich = true;

    }

    return true;

  }

protected:

  const SVGAnimationElement* mSrcElement;

  const nsISMILAttr* mSMILAttr;

  FallibleTArray<nsSMILValue>* mValuesArray;

  bool* mPreventCachingOfSandwich;

};

bool

nsSMILParserUtils::ParseValues(const nsAString& aSpec,

                               const SVGAnimationElement* aSrcElement,

                               const nsISMILAttr& aAttribute,

                               FallibleTArray<nsSMILValue>& aValuesArray,

                               bool& aPreventCachingOfSandwich)

{

  // Assume all results can be cached, until we find one that can't.

  aPreventCachingOfSandwich = false;

  SMILValueParser valueParser(aSrcElement, &aAttribute,

                              &aValuesArray, &aPreventCachingOfSandwich);

  return ParseValuesGeneric(aSpec, valueParser);

}

bool

nsSMILParserUtils::ParseValuesGeneric(const nsAString& aSpec,

                                      GenericValueParser& aParser)

{

  nsCharSeparatedTokenizerTemplate<nsContentUtils::IsHTMLWhitespace>

    tokenizer(aSpec, ';');

  if (!tokenizer.hasMoreTokens()) { // Empty list

    return false;

  }

  while (tokenizer.hasMoreTokens()) {

    if (!aParser.Parse(tokenizer.nextToken())) {

      return false;

    }

  }

  return true;

}

bool

nsSMILParserUtils::ParseRepeatCount(const nsAString& aSpec,

                                    nsSMILRepeatCount& aResult)

{

  const nsAString& spec =

    nsSMILParserUtils::TrimWhitespace(aSpec);

  if (spec.EqualsLiteral("indefinite")) {

    aResult.SetIndefinite();

    return true;

  }

  double value;

  if (!SVGContentUtils::ParseNumber(spec, value) || value <= 0.0) {

    return false;

  }

  aResult = value;

  return true;

}

bool

nsSMILParserUtils::ParseTimeValueSpecParams(const nsAString& aSpec,

                                            nsSMILTimeValueSpecParams& aResult)

{

  const nsAString& spec = TrimWhitespace(aSpec);

  if (spec.EqualsLiteral("indefinite")) {

     aResult.mType = nsSMILTimeValueSpecParams::INDEFINITE;

     return true;

  }

  // offset type

  if (ParseOffsetValue(spec, &aResult.mOffset)) {

    aResult.mType = nsSMILTimeValueSpecParams::OFFSET;

    return true;

  }

  // wallclock type

  if (StringBeginsWith(spec, WALLCLOCK_PREFIX)) {

    return false; // Wallclock times not implemented

  }

  // accesskey type

  if (StringBeginsWith(spec, ACCESSKEY_PREFIX_LC) ||

      StringBeginsWith(spec, ACCESSKEY_PREFIX_CC)) {

    return false; // accesskey is not supported

  }

  // event, syncbase, or repeat

  return ParseElementBaseTimeValueSpec(spec, aResult);

}

bool

nsSMILParserUtils::ParseClockValue(const nsAString& aSpec,

                                   nsSMILTimeValue* aResult)

{

  RangedPtr<const char16_t> iter(SVGContentUtils::GetStartRangedPtr(aSpec));

  RangedPtr<const char16_t> end(SVGContentUtils::GetEndRangedPtr(aSpec));

  return ::ParseClockValue(iter, end, aResult) && iter == end;

}

int32_t

nsSMILParserUtils::CheckForNegativeNumber(const nsAString& aStr)

{

  int32_t absValLocation = -1;

  RangedPtr<const char16_t> start(SVGContentUtils::GetStartRangedPtr(aStr));

  RangedPtr<const char16_t> iter = start;

  RangedPtr<const char16_t> end(SVGContentUtils::GetEndRangedPtr(aStr));

  // Skip initial whitespace

  while (iter != end && nsContentUtils::IsHTMLWhitespace(*iter)) {

    ++iter;

  }

  // Check for dash

  if (iter != end && *iter == '-') {

    ++iter;

    // Check for numeric character

    if (iter != end && mozilla::IsAsciiDigit(*iter)) {

      absValLocation = iter - start;

    }

  }

  return absValLocation;

}