// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "media/formats/hls/tags.h"

#include <cstddef>
#include <type_traits>
#include <utility>

#include "base/logging.h"
#include "base/notreached.h"
#include "base/time/time.h"
#include "media/base/mime_util.h"
#include "media/formats/hls/items.h"
#include "media/formats/hls/parse_status.h"
#include "media/formats/hls/variable_dictionary.h"

namespace media::hls {

namespace {

template <typename T>
ParseStatus::Or<T> ParseEmptyTag(TagItem tag) {
  DCHECK(tag.GetName() == ToTagName(T::kName));
  if (tag.GetContent().has_value()) {
    return ParseStatusCode::kMalformedTag;
  }

  return T{};
}

template <typename T>
ParseStatus::Or<T> ParseDecimalIntegerTag(TagItem tag,
                                          types::DecimalInteger T::*field) {
  DCHECK(tag.GetName() == ToTagName(T::kName));
  if (!tag.GetContent().has_value()) {
    return ParseStatusCode::kMalformedTag;
  }

  auto value =
      types::ParseDecimalInteger(tag.GetContent()->SkipVariableSubstitution());
  if (!value.has_value()) {
    return ParseStatus(ParseStatusCode::kMalformedTag)
        .AddCause(std::move(value).error());
  }

  T out;
  out.*field = std::move(value).value();
  return out;
}

template <typename T>
ParseStatus::Or<T> ParseISO8601DateTimeTag(TagItem tag, base::Time T::*field) {
  CHECK(tag.GetName() == ToTagName(T::kName));
  if (!tag.GetContent().has_value()) {
    return ParseStatusCode::kMalformedTag;
  }
  const auto content = tag.GetContent()->SkipVariableSubstitution().Str();
  std::string content_nullterm = std::string(content);
  T out;
  base::Time time;
  if (base::Time::FromString(content_nullterm.c_str(), &time)) {
    out.*field = time;
  } else {
    return ParseStatusCode::kMalformedTag;
  }
  return out;
}

// Attributes expected in `EXT-X-DEFINE` tag contents.
// These must remain sorted alphabetically.
enum class XDefineTagAttribute {
  kImport,
  kName,
  kValue,
  kMaxValue = kValue,
};

constexpr std::string_view GetAttributeName(XDefineTagAttribute attribute) {
  switch (attribute) {
    case XDefineTagAttribute::kImport:
      return "IMPORT";
    case XDefineTagAttribute::kName:
      return "NAME";
    case XDefineTagAttribute::kValue:
      return "VALUE";
  }

  NOTREACHED_NORETURN();
}

// Attributes expected in `EXT-X-MEDIA` tag contents.
// These must remain sorted alphabetically.
enum class XMediaTagAttribute {
  kAssocLanguage,
  kAutoselect,
  kChannels,
  kCharacteristics,
  kDefault,
  kForced,
  kGroupId,
  kInstreamId,
  kLanguage,
  kName,
  kStableRenditionId,
  kType,
  kUri,
  kMaxValue = kUri,
};

constexpr std::string_view GetAttributeName(XMediaTagAttribute attribute) {
  switch (attribute) {
    case XMediaTagAttribute::kAssocLanguage:
      return "ASSOC-LANGUAGE";
    case XMediaTagAttribute::kAutoselect:
      return "AUTOSELECT";
    case XMediaTagAttribute::kChannels:
      return "CHANNELS";
    case XMediaTagAttribute::kCharacteristics:
      return "CHARACTERISTICS";
    case XMediaTagAttribute::kDefault:
      return "DEFAULT";
    case XMediaTagAttribute::kForced:
      return "FORCED";
    case XMediaTagAttribute::kGroupId:
      return "GROUP-ID";
    case XMediaTagAttribute::kInstreamId:
      return "INSTREAM-ID";
    case XMediaTagAttribute::kLanguage:
      return "LANGUAGE";
    case XMediaTagAttribute::kName:
      return "NAME";
    case XMediaTagAttribute::kStableRenditionId:
      return "STABLE-RENDITION-ID";
    case XMediaTagAttribute::kType:
      return "TYPE";
    case XMediaTagAttribute::kUri:
      return "URI";
  }

  NOTREACHED_NORETURN();
}

// Attributes expected in `EXT-X-STREAM-INF` tag contents.
// These must remain sorted alphabetically.
enum class XStreamInfTagAttribute {
  kAudio,
  kAverageBandwidth,
  kBandwidth,
  kCodecs,
  kFrameRate,
  kProgramId,  // Ignored for backwards compatibility
  kResolution,
  kScore,
  kVideo,
  kMaxValue = kVideo,
};

constexpr std::string_view GetAttributeName(XStreamInfTagAttribute attribute) {
  switch (attribute) {
    case XStreamInfTagAttribute::kAudio:
      return "AUDIO";
    case XStreamInfTagAttribute::kVideo:
      return "VIDEO";
    case XStreamInfTagAttribute::kAverageBandwidth:
      return "AVERAGE-BANDWIDTH";
    case XStreamInfTagAttribute::kBandwidth:
      return "BANDWIDTH";
    case XStreamInfTagAttribute::kCodecs:
      return "CODECS";
    case XStreamInfTagAttribute::kFrameRate:
      return "FRAME-RATE";
    case XStreamInfTagAttribute::kProgramId:
      return "PROGRAM-ID";
    case XStreamInfTagAttribute::kResolution:
      return "RESOLUTION";
    case XStreamInfTagAttribute::kScore:
      return "SCORE";
  }

  NOTREACHED_NORETURN();
}

// Attributes expected in `EXT-X-SKIP` tag contents.
// These must remain sorted alphabetically.
enum class XSkipTagAttribute {
  kRecentlyRemovedDateranges,
  kSkippedSegments,
  kMaxValue = kSkippedSegments,
};

constexpr std::string_view GetAttributeName(XSkipTagAttribute attribute) {
  switch (attribute) {
    case XSkipTagAttribute::kRecentlyRemovedDateranges:
      return "RECENTLY-REMOVED-DATERANGES";
    case XSkipTagAttribute::kSkippedSegments:
      return "SKIPPED-SEGMENTS";
  }
  NOTREACHED_NORETURN();
}

enum class XRenditionReportTagAttribute {
  kLastMSN,
  kLastPart,
  kUri,
  kMaxValue = kUri,
};

constexpr std::string_view GetAttributeName(XRenditionReportTagAttribute attr) {
  switch (attr) {
    case XRenditionReportTagAttribute::kUri:
      return "URI";
    case XRenditionReportTagAttribute::kLastMSN:
      return "LAST-MSN";
    case XRenditionReportTagAttribute::kLastPart:
      return "LAST-PART";
  }
  NOTREACHED_NORETURN();
}

// Attributes expected in `EXT-X-MAP` tag contents.
// These must remain sorted alphabetically.
enum class XMapTagAttribute {
  kByteRange,
  kUri,
  kMaxValue = kUri,
};

constexpr std::string_view GetAttributeName(XMapTagAttribute attribute) {
  switch (attribute) {
    case XMapTagAttribute::kByteRange:
      return "BYTERANGE";
    case XMapTagAttribute::kUri:
      return "URI";
  }

  NOTREACHED_NORETURN();
}

// Attributes expected in `EXT-X-PART` tag contents.
// These must remain sorted alphabetically.
enum class XPartTagAttribute {
  kByteRange,
  kDuration,
  kGap,
  kIndependent,
  kUri,
  kMaxValue = kUri,
};

constexpr std::string_view GetAttributeName(XPartTagAttribute attribute) {
  switch (attribute) {
    case XPartTagAttribute::kByteRange:
      return "BYTERANGE";
    case XPartTagAttribute::kDuration:
      return "DURATION";
    case XPartTagAttribute::kGap:
      return "GAP";
    case XPartTagAttribute::kIndependent:
      return "INDEPENDENT";
    case XPartTagAttribute::kUri:
      return "URI";
  }
}

// Attributes expected in `EXT-X-PART-INF` tag contents.
// These must remain sorted alphabetically.
enum class XPartInfTagAttribute {
  kPartTarget,
  kMaxValue = kPartTarget,
};

constexpr std::string_view GetAttributeName(XPartInfTagAttribute attribute) {
  switch (attribute) {
    case XPartInfTagAttribute::kPartTarget:
      return "PART-TARGET";
  }

  NOTREACHED_NORETURN();
}

// Attributes expected in `EXT-X-SERVER-CONTROL` tag contents.
// These must remain sorted alphabetically.
enum class XServerControlTagAttribute {
  kCanBlockReload,
  kCanSkipDateRanges,
  kCanSkipUntil,
  kHoldBack,
  kPartHoldBack,
  kMaxValue = kPartHoldBack,
};

constexpr std::string_view GetAttributeName(
    XServerControlTagAttribute attribute) {
  switch (attribute) {
    case XServerControlTagAttribute::kCanBlockReload:
      return "CAN-BLOCK-RELOAD";
    case XServerControlTagAttribute::kCanSkipDateRanges:
      return "CAN-SKIP-DATERANGES";
    case XServerControlTagAttribute::kCanSkipUntil:
      return "CAN-SKIP-UNTIL";
    case XServerControlTagAttribute::kHoldBack:
      return "HOLD-BACK";
    case XServerControlTagAttribute::kPartHoldBack:
      return "PART-HOLD-BACK";
  }

  NOTREACHED_NORETURN();
}

enum class XKeyTagAttribute {
  kIv,
  kKeyFormat,
  kKeyFormatVersions,
  kMethod,
  kUri,
  kMaxValue = kUri,
};

constexpr std::string_view GetAttributeName(XKeyTagAttribute attribute) {
  switch (attribute) {
    case XKeyTagAttribute::kIv:
      return "IV";
    case XKeyTagAttribute::kKeyFormat:
      return "KEYFORMAT";
    case XKeyTagAttribute::kKeyFormatVersions:
      return "KEYFORMATVERSIONS";
    case XKeyTagAttribute::kMethod:
      return "METHOD";
    case XKeyTagAttribute::kUri:
      return "URI";
  }
  NOTREACHED_NORETURN();
}

template <typename T, size_t kLast>
constexpr bool IsAttributeEnumSorted(std::index_sequence<kLast>) {
  return true;
}

template <typename T, size_t kLHS, size_t kRHS, size_t... kRest>
constexpr bool IsAttributeEnumSorted(
    std::index_sequence<kLHS, kRHS, kRest...>) {
  const auto lhs = GetAttributeName(static_cast<T>(kLHS));
  const auto rhs = GetAttributeName(static_cast<T>(kRHS));
  return lhs < rhs &&
         IsAttributeEnumSorted<T>(std::index_sequence<kRHS, kRest...>{});
}

// Wraps `AttributeMap::MakeStorage` by mapping the (compile-time) sequence
// of size_t's to a sequence of the corresponding attribute enum names.
template <typename T, std::size_t... Indices>
constexpr std::array<types::AttributeMap::Item, sizeof...(Indices)>
MakeTypedAttributeMapStorage(std::index_sequence<Indices...> seq) {
  static_assert(IsAttributeEnumSorted<T>(seq),
                "Enum keys must be sorted alphabetically");
  return types::AttributeMap::MakeStorage(
      GetAttributeName(static_cast<T>(Indices))...);
}

// Helper for using AttributeMap with an enum of keys.
// The result of running `GetAttributeName` across `0..T::kMaxValue` (inclusive)
// must produced an ordered set of strings.
template <typename T>
struct TypedAttributeMap {
  static_assert(std::is_enum<T>::value, "T must be an enum");
  static_assert(std::is_same<decltype(GetAttributeName(std::declval<T>())),
                             std::string_view>::value,
                "GetAttributeName must be overloaded for T to return a "
                "std::string_view");
  static constexpr size_t kNumKeys = static_cast<size_t>(T::kMaxValue) + 1;

  TypedAttributeMap()
      : attributes_(MakeTypedAttributeMapStorage<T>(
            std::make_index_sequence<kNumKeys>())) {}

  // Wraps `AttributeMap::FillUntilError` using the built-in storage object.
  ParseStatus FillUntilError(types::AttributeListIterator* iter) {
    types::AttributeMap map(attributes_);
    return map.FillUntilError(iter);
  }

  // Returns whether the entry corresponding to the given key has a value.
  bool HasValue(T key) const {
    return attributes_[static_cast<size_t>(key)].second.has_value();
  }

  // Returns the value stored in the entry for the given key.
  SourceString GetValue(T key) const {
    return attributes_[static_cast<size_t>(key)].second.value();
  }

  size_t Size() const {
    return std::count_if(attributes_.begin(), attributes_.end(),
                         [](const types::AttributeMap::Item& item) {
                           return item.second.has_value();
                         });
  }

 private:
  std::array<types::AttributeMap::Item, kNumKeys> attributes_;
};

#define RETURN_IF_ERROR(var_not_expr)                   \
  do {                                                  \
    if (!var_not_expr.has_value()) {                    \
      return std::move(var_not_expr).error().AddHere(); \
    }                                                   \
  } while (0)

template <template <typename...> typename SpecifiedContainer, typename Type>
struct is_specialization_of : std::false_type {};

template <template <typename...> typename SpecifiedContainer, typename... Types>
struct is_specialization_of<SpecifiedContainer, SpecifiedContainer<Types...>>
    : std::true_type {};

// ParseField exists to help with the pattern where we need to parse some field
// from a dictionary of tag attributes where some of those fields are optional.
// It is designed to provide support for either optional or required fields,
// depending on the return-type specialization:
// When Result=std::optional<X>, ParseField will return a nullopt rather than
// an error if the `field_name` field can't be found in `map`.
// When Result=T (where T is not std::optional<X>), ParseField will fail with
// a ParseStatus if `field_name` is not found in map.
// A function pointer must also be provided which does the parsing from
// SourceString => Result, provided that the `field_name` key is present.
template <typename Result,
          typename AttrEnum,
          typename ParseFn,
          typename... ParseFnArgs>
ParseStatus::Or<Result> ParseField(AttrEnum field_name,
                                   TypedAttributeMap<AttrEnum> map,
                                   ParseFn parser,
                                   ParseFnArgs&&... args) {
  if (map.HasValue(field_name)) {
    auto maybe =
        parser(map.GetValue(field_name), std::forward<ParseFnArgs>(args)...);
    if (!maybe.has_value()) {
      ParseStatus result = ParseStatusCode::kMalformedTag;
      return std::move(result).AddCause(std::move(maybe).error());
    }
    return Result(std::move(maybe).value());
  }
  if constexpr (is_specialization_of<std::optional, Result>::value) {
    return Result(std::nullopt);
  }
  return ParseStatusCode::kMalformedTag;
}

}  // namespace

// static
ParseStatus::Or<M3uTag> M3uTag::Parse(TagItem tag) {
  return ParseEmptyTag<M3uTag>(tag);
}

// static
XDefineTag XDefineTag::CreateDefinition(types::VariableName name,
                                        std::string_view value) {
  return XDefineTag{.name = name, .value = value};
}

// static
XDefineTag XDefineTag::CreateImport(types::VariableName name) {
  return XDefineTag{.name = name, .value = std::nullopt};
}

// static
ParseStatus::Or<XDefineTag> XDefineTag::Parse(TagItem tag) {
  DCHECK(tag.GetName() == ToTagName(XDefineTag::kName));

  if (!tag.GetContent().has_value()) {
    return ParseStatusCode::kMalformedTag;
  }

  // Parse the attribute-list.
  // Quoted strings in EXT-X-DEFINE tags are unique in that they aren't subject
  // to variable substitution. For that reason, we use the
  // `ParseQuotedStringWithoutSubstitution` function here.
  TypedAttributeMap<XDefineTagAttribute> map;
  types::AttributeListIterator iter(*tag.GetContent());
  auto result = map.FillUntilError(&iter);

  if (result.code() != ParseStatusCode::kReachedEOF) {
    return ParseStatus(ParseStatusCode::kMalformedTag)
        .AddCause(std::move(result));
  }

  // "NAME" and "IMPORT" are mutually exclusive
  if (map.HasValue(XDefineTagAttribute::kName) &&
      map.HasValue(XDefineTagAttribute::kImport)) {
    return ParseStatusCode::kMalformedTag;
  }

  if (map.HasValue(XDefineTagAttribute::kName)) {
    auto var_name = types::ParseQuotedStringWithoutSubstitution(
                        map.GetValue(XDefineTagAttribute::kName))
                        .MapValue(types::VariableName::Parse);
    if (!var_name.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(var_name).error());
    }

    // If "NAME" is defined, "VALUE" must also be defined
    if (!map.HasValue(XDefineTagAttribute::kValue)) {
      return ParseStatusCode::kMalformedTag;
    }

    auto value = types::ParseQuotedStringWithoutSubstitution(
        map.GetValue(XDefineTagAttribute::kValue), /*allow_empty*/ true);
    if (!value.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag);
    }

    return XDefineTag::CreateDefinition(std::move(var_name).value(),
                                        std::move(value).value().Str());
  }

  if (map.HasValue(XDefineTagAttribute::kImport)) {
    auto var_name = types::ParseQuotedStringWithoutSubstitution(
                        map.GetValue(XDefineTagAttribute::kImport))
                        .MapValue(types::VariableName::Parse);
    if (!var_name.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(var_name).error());
    }

    // "VALUE" doesn't make any sense here, but the spec doesn't explicitly
    // forbid it. It may be used in the future to provide a default value for
    // undefined imported variables, so we won't error on it.
    return XDefineTag::CreateImport(std::move(var_name).value());
  }

  // Without "NAME" or "IMPORT", the tag is malformed
  return ParseStatusCode::kMalformedTag;
}

// static
ParseStatus::Or<XIndependentSegmentsTag> XIndependentSegmentsTag::Parse(
    TagItem tag) {
  return ParseEmptyTag<XIndependentSegmentsTag>(tag);
}

// static
ParseStatus::Or<XVersionTag> XVersionTag::Parse(TagItem tag) {
  auto result = ParseDecimalIntegerTag(tag, &XVersionTag::version);
  if (!result.has_value()) {
    return std::move(result).error();
  }

  // Reject invalid version numbers.
  // For valid version numbers, caller will decide if the version is supported.
  auto out = std::move(result).value();
  if (out.version == 0) {
    return ParseStatusCode::kInvalidPlaylistVersion;
  }

  return out;
}

struct XMediaTag::CtorArgs {
  decltype(XMediaTag::type) type;
  decltype(XMediaTag::uri) uri;
  decltype(XMediaTag::instream_id) instream_id;
  decltype(XMediaTag::group_id) group_id;
  decltype(XMediaTag::language) language;
  decltype(XMediaTag::associated_language) associated_language;
  decltype(XMediaTag::name) name;
  decltype(XMediaTag::stable_rendition_id) stable_rendition_id;
  decltype(XMediaTag::is_default) is_default;
  decltype(XMediaTag::autoselect) autoselect;
  decltype(XMediaTag::forced) forced;
  decltype(XMediaTag::characteristics) characteristics;
  decltype(XMediaTag::channels) channels;
};

XMediaTag::XMediaTag(CtorArgs args)
    : type(std::move(args.type)),
      uri(std::move(args.uri)),
      instream_id(std::move(args.instream_id)),
      group_id(std::move(args.group_id)),
      language(std::move(args.language)),
      associated_language(std::move(args.associated_language)),
      name(std::move(args.name)),
      stable_rendition_id(std::move(args.stable_rendition_id)),
      is_default(std::move(args.is_default)),
      autoselect(std::move(args.autoselect)),
      forced(std::move(args.forced)),
      characteristics(std::move(args.characteristics)),
      channels(std::move(args.channels)) {}

XMediaTag::~XMediaTag() = default;

XMediaTag::XMediaTag(const XMediaTag&) = default;

XMediaTag::XMediaTag(XMediaTag&&) = default;

XMediaTag& XMediaTag::operator=(const XMediaTag&) = default;

XMediaTag& XMediaTag::operator=(XMediaTag&&) = default;

// static
ParseStatus::Or<XMediaTag> XMediaTag::Parse(
    TagItem tag,
    const VariableDictionary& variable_dict,
    VariableDictionary::SubstitutionBuffer& sub_buffer) {
  DCHECK(tag.GetName() == ToTagName(XMediaTag::kName));
  if (!tag.GetContent().has_value()) {
    return ParseStatusCode::kMalformedTag;
  }

  // Parse the attribute-list
  TypedAttributeMap<XMediaTagAttribute> map;
  types::AttributeListIterator iter(*tag.GetContent());
  auto map_result = map.FillUntilError(&iter);

  if (map_result.code() != ParseStatusCode::kReachedEOF) {
    return ParseStatus(ParseStatusCode::kMalformedTag)
        .AddCause(std::move(map_result));
  }

  // Parse the 'TYPE' attribute
  MediaType type;
  if (map.HasValue(XMediaTagAttribute::kType)) {
    auto str = map.GetValue(XMediaTagAttribute::kType);
    if (str.Str() == "AUDIO") {
      type = MediaType::kAudio;
    } else if (str.Str() == "VIDEO") {
      type = MediaType::kVideo;
    } else if (str.Str() == "SUBTITLES") {
      type = MediaType::kSubtitles;
    } else if (str.Str() == "CLOSED-CAPTIONS") {
      type = MediaType::kClosedCaptions;
    } else {
      return ParseStatusCode::kMalformedTag;
    }
  } else {
    return ParseStatusCode::kMalformedTag;
  }

  // Parse the 'URI' attribute
  std::optional<ResolvedSourceString> uri;
  if (map.HasValue(XMediaTagAttribute::kUri)) {
    // This attribute MUST NOT be defined for closed-captions renditions
    if (type == MediaType::kClosedCaptions) {
      return ParseStatusCode::kMalformedTag;
    }

    auto result = types::ParseQuotedString(
        map.GetValue(XMediaTagAttribute::kUri), variable_dict, sub_buffer);
    if (!result.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(result).error());
    }

    uri = std::move(result).value();
  } else {
    // URI MUST be defined for subtitle renditions
    if (type == MediaType::kSubtitles) {
      return ParseStatusCode::kMalformedTag;
    }
  }

  // Parse the 'GROUP-ID' attribute
  std::optional<ResolvedSourceString> group_id;
  if (map.HasValue(XMediaTagAttribute::kGroupId)) {
    auto result = types::ParseQuotedString(
        map.GetValue(XMediaTagAttribute::kGroupId), variable_dict, sub_buffer);
    if (!result.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(result).error());
    }

    group_id = std::move(result).value();
  } else {
    return ParseStatusCode::kMalformedTag;
  }

  // Parse the 'LANGUAGE' attribute
  std::optional<ResolvedSourceString> language;
  if (map.HasValue(XMediaTagAttribute::kLanguage)) {
    auto result = types::ParseQuotedString(
        map.GetValue(XMediaTagAttribute::kLanguage), variable_dict, sub_buffer);
    if (!result.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(result).error());
    }

    language = std::move(result).value();
  }

  // Parse the 'ASSOC-LANGUAGE' attribute
  std::optional<ResolvedSourceString> assoc_language;
  if (map.HasValue(XMediaTagAttribute::kAssocLanguage)) {
    auto result = types::ParseQuotedString(
        map.GetValue(XMediaTagAttribute::kAssocLanguage), variable_dict,
        sub_buffer);
    if (!result.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(result).error());
    }

    assoc_language = std::move(result).value();
  }

  // Parse the 'NAME' attribute
  std::optional<ResolvedSourceString> name;
  if (map.HasValue(XMediaTagAttribute::kName)) {
    auto result = types::ParseQuotedString(
        map.GetValue(XMediaTagAttribute::kName), variable_dict, sub_buffer);
    if (!result.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(result).error());
    }

    name = std::move(result).value();
  } else {
    return ParseStatusCode::kMalformedTag;
  }

  // Parse the 'STABLE-RENDITION-ID' attribute
  std::optional<types::StableId> stable_rendition_id;
  if (map.HasValue(XMediaTagAttribute::kStableRenditionId)) {
    auto result = types::ParseQuotedString(
                      map.GetValue(XMediaTagAttribute::kStableRenditionId),
                      variable_dict, sub_buffer)
                      .MapValue(types::StableId::Parse);
    if (!result.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(result).error());
    }
    stable_rendition_id = std::move(result).value();
  }

  // Parse the 'DEFAULT' attribute
  bool is_default = false;
  if (map.HasValue(XMediaTagAttribute::kDefault)) {
    if (map.GetValue(XMediaTagAttribute::kDefault).Str() == "YES") {
      is_default = true;
    }
  }

  // Parse the 'AUTOSELECT' attribute
  bool autoselect = is_default;
  if (map.HasValue(XMediaTagAttribute::kAutoselect)) {
    if (map.GetValue(XMediaTagAttribute::kAutoselect).Str() == "YES") {
      autoselect = true;
    } else if (is_default) {
      // If the 'DEFAULT' attribute is 'YES', then the value of this attribute
      // must also be 'YES', if present.
      return ParseStatusCode::kMalformedTag;
    }
  }

  // Parse the 'FORCED' attribute
  bool forced = false;
  if (map.HasValue(XMediaTagAttribute::kForced)) {
    // The FORCED attribute MUST NOT be present unless TYPE=SUBTITLES
    if (type != MediaType::kSubtitles) {
      return ParseStatusCode::kMalformedTag;
    }

    if (map.GetValue(XMediaTagAttribute::kForced).Str() == "YES") {
      forced = true;
    }
  }

  // Parse the 'INSTREAM-ID' attribute
  std::optional<types::InstreamId> instream_id;
  if (map.HasValue(XMediaTagAttribute::kInstreamId)) {
    // The INSTREAM-ID attribute MUST NOT be present unless TYPE=CLOSED-CAPTIONS
    if (type != MediaType::kClosedCaptions) {
      return ParseStatusCode::kMalformedTag;
    }

    auto result =
        types::ParseQuotedString(map.GetValue(XMediaTagAttribute::kInstreamId),
                                 variable_dict, sub_buffer)
            .MapValue(types::InstreamId::Parse);
    if (!result.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(result).error());
    }

    instream_id = std::move(result).value();
  }
  // This attribute is REQUIRED if TYPE=CLOSED-CAPTIONS
  else if (type == MediaType::kClosedCaptions) {
    return ParseStatusCode::kMalformedTag;
  }

  // Parse the 'CHARACTERISTICS' attribute
  std::vector<std::string> characteristics;
  if (map.HasValue(XMediaTagAttribute::kCharacteristics)) {
    auto result = types::ParseQuotedString(
        map.GetValue(XMediaTagAttribute::kCharacteristics), variable_dict,
        sub_buffer);
    if (!result.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(result).error());
    }
    auto value = std::move(result).value();

    while (!value.Empty()) {
      const auto mct = value.ConsumeDelimiter(',');
      if (mct.Empty()) {
        return ParseStatusCode::kMalformedTag;
      }

      characteristics.emplace_back(mct.Str());
    }
  }

  // Parse the 'CHANNELS' attribute
  std::optional<types::AudioChannels> channels;
  if (map.HasValue(XMediaTagAttribute::kChannels)) {
    // Currently only supported type with channel information is `kAudio`.
    if (type == MediaType::kAudio) {
      auto result =
          types::ParseQuotedString(map.GetValue(XMediaTagAttribute::kChannels),
                                   variable_dict, sub_buffer)
              .MapValue(types::AudioChannels::Parse);
      if (!result.has_value()) {
        return ParseStatus(ParseStatusCode::kMalformedTag)
            .AddCause(std::move(result).error());
      }

      channels = std::move(result).value();
    }
  }

  return XMediaTag(XMediaTag::CtorArgs{
      .type = type,
      .uri = uri,
      .instream_id = instream_id,
      .group_id = group_id.value(),
      .language = language,
      .associated_language = assoc_language,
      .name = name.value(),
      .stable_rendition_id = std::move(stable_rendition_id),
      .is_default = is_default,
      .autoselect = autoselect,
      .forced = forced,
      .characteristics = std::move(characteristics),
      .channels = std::move(channels),
  });
}

XStreamInfTag::XStreamInfTag() = default;

XStreamInfTag::~XStreamInfTag() = default;

XStreamInfTag::XStreamInfTag(const XStreamInfTag&) = default;

XStreamInfTag::XStreamInfTag(XStreamInfTag&&) = default;

XStreamInfTag& XStreamInfTag::operator=(const XStreamInfTag&) = default;

XStreamInfTag& XStreamInfTag::operator=(XStreamInfTag&&) = default;

// static
ParseStatus::Or<XStreamInfTag> XStreamInfTag::Parse(
    TagItem tag,
    const VariableDictionary& variable_dict,
    VariableDictionary::SubstitutionBuffer& sub_buffer) {
  DCHECK(tag.GetName() == ToTagName(XStreamInfTag::kName));
  XStreamInfTag out;

  if (!tag.GetContent().has_value()) {
    return ParseStatusCode::kMalformedTag;
  }

  // Parse the attribute-list
  TypedAttributeMap<XStreamInfTagAttribute> map;
  types::AttributeListIterator iter(*tag.GetContent());
  auto map_result = map.FillUntilError(&iter);

  if (map_result.code() != ParseStatusCode::kReachedEOF) {
    return ParseStatus(ParseStatusCode::kMalformedTag)
        .AddCause(std::move(map_result));
  }

  // Extract the 'BANDWIDTH' attribute
  if (map.HasValue(XStreamInfTagAttribute::kBandwidth)) {
    auto bandwidth = types::ParseDecimalInteger(
        map.GetValue(XStreamInfTagAttribute::kBandwidth)
            .SkipVariableSubstitution());
    if (!bandwidth.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(bandwidth).error());
    }

    out.bandwidth = std::move(bandwidth).value();
  } else {
    return ParseStatusCode::kMalformedTag;
  }

  // Extract the 'AVERAGE-BANDWIDTH' attribute
  if (map.HasValue(XStreamInfTagAttribute::kAverageBandwidth)) {
    auto average_bandwidth = types::ParseDecimalInteger(
        map.GetValue(XStreamInfTagAttribute::kAverageBandwidth)
            .SkipVariableSubstitution());
    if (!average_bandwidth.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(average_bandwidth).error());
    }

    out.average_bandwidth = std::move(average_bandwidth).value();
  }

  // Extract the 'SCORE' attribute
  if (map.HasValue(XStreamInfTagAttribute::kScore)) {
    auto score = types::ParseDecimalFloatingPoint(
        map.GetValue(XStreamInfTagAttribute::kScore)
            .SkipVariableSubstitution());
    if (!score.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(score).error());
    }

    out.score = std::move(score).value();
  }

  // Extract the 'CODECS' attribute
  if (map.HasValue(XStreamInfTagAttribute::kCodecs)) {
    auto codecs_string =
        types::ParseQuotedString(map.GetValue(XStreamInfTagAttribute::kCodecs),
                                 variable_dict, sub_buffer);
    if (!codecs_string.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(codecs_string).error());
    }

    // Split the list of codecs
    std::vector<std::string> codecs;
    SplitCodecs(std::move(codecs_string).value().Str(), &codecs);
    out.codecs = std::move(codecs);
  }

  // Extract the 'RESOLUTION' attribute
  if (map.HasValue(XStreamInfTagAttribute::kResolution)) {
    auto resolution = types::DecimalResolution::Parse(
        map.GetValue(XStreamInfTagAttribute::kResolution)
            .SkipVariableSubstitution());
    if (!resolution.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(resolution).error());
    }
    out.resolution = std::move(resolution).value();
  }

  // Extract the 'FRAME-RATE' attribute
  if (map.HasValue(XStreamInfTagAttribute::kFrameRate)) {
    auto frame_rate = types::ParseDecimalFloatingPoint(
        map.GetValue(XStreamInfTagAttribute::kFrameRate)
            .SkipVariableSubstitution());
    if (!frame_rate.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(frame_rate).error());
    }
    out.frame_rate = std::move(frame_rate).value();
  }

  // Extract the 'AUDIO' attribute
  if (map.HasValue(XStreamInfTagAttribute::kAudio)) {
    auto audio =
        types::ParseQuotedString(map.GetValue(XStreamInfTagAttribute::kAudio),
                                 variable_dict, sub_buffer);
    if (!audio.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(audio).error());
    }
    out.audio = std::move(audio).value();
  }

  // Extract the 'VIDEO' attribute
  if (map.HasValue(XStreamInfTagAttribute::kVideo)) {
    auto video =
        types::ParseQuotedString(map.GetValue(XStreamInfTagAttribute::kVideo),
                                 variable_dict, sub_buffer);
    if (!video.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(video).error());
    }
    out.video = std::move(video).value();
  }

  return out;
}

// static
ParseStatus::Or<InfTag> InfTag::Parse(TagItem tag) {
  DCHECK(tag.GetName() == ToTagName(InfTag::kName));

  if (!tag.GetContent()) {
    return ParseStatusCode::kMalformedTag;
  }
  auto content = *tag.GetContent();

  // Inf tags have the form #EXTINF:<duration>,[<title>]
  // Find the comma.
  auto comma = content.Str().find_first_of(',');
  SourceString duration_str = content;
  SourceString title_str = content;
  if (comma == std::string_view::npos) {
    // While the HLS spec does require commas at the end of inf tags, it's
    // incredibly common for sites to elide the comma if there is no title
    // attribute present. In this case, we should assert that there is at least
    // a trailing newline, and then strip it to generate a nameless tag.
    title_str = content.Substr(0, 0);
    if (*content.Str().end() != '\n') {
      duration_str = content;
    } else {
      duration_str = content.Substr(0, content.Str().length() - 1);
    }
  } else {
    duration_str = content.Substr(0, comma);
    title_str = content.Substr(comma + 1);
  }

  // Extract duration
  // TODO(crbug.com/40210233): Below version 3 this should be rounded to an
  // integer
  auto duration_result =
      types::ParseDecimalFloatingPoint(duration_str.SkipVariableSubstitution());
  if (!duration_result.has_value()) {
    return ParseStatus(ParseStatusCode::kMalformedTag)
        .AddCause(std::move(duration_result).error());
  }
  const auto duration = base::Seconds(std::move(duration_result).value());

  if (duration.is_max()) {
    return ParseStatusCode::kValueOverflowsTimeDelta;
  }

  return InfTag{.duration = duration, .title = title_str};
}

// static
ParseStatus::Or<XBitrateTag> XBitrateTag::Parse(TagItem tag) {
  return ParseDecimalIntegerTag(tag, &XBitrateTag::bitrate);
}

// static
ParseStatus::Or<XByteRangeTag> XByteRangeTag::Parse(TagItem tag) {
  DCHECK(tag.GetName() == ToTagName(XByteRangeTag::kName));
  if (!tag.GetContent().has_value()) {
    return ParseStatusCode::kMalformedTag;
  }

  auto range = types::parsing::ByteRangeExpression::Parse(
      tag.GetContent()->SkipVariableSubstitution());
  if (!range.has_value()) {
    return ParseStatus(ParseStatusCode::kMalformedTag)
        .AddCause(std::move(range).error());
  }

  return XByteRangeTag{.range = std::move(range).value()};
}

// static
ParseStatus::Or<XDiscontinuityTag> XDiscontinuityTag::Parse(TagItem tag) {
  return ParseEmptyTag<XDiscontinuityTag>(tag);
}

// static
ParseStatus::Or<XDiscontinuitySequenceTag> XDiscontinuitySequenceTag::Parse(
    TagItem tag) {
  return ParseDecimalIntegerTag(tag, &XDiscontinuitySequenceTag::number);
}

// static
ParseStatus::Or<XEndListTag> XEndListTag::Parse(TagItem tag) {
  return ParseEmptyTag<XEndListTag>(tag);
}

// static
ParseStatus::Or<XGapTag> XGapTag::Parse(TagItem tag) {
  return ParseEmptyTag<XGapTag>(tag);
}

// static
ParseStatus::Or<XIFramesOnlyTag> XIFramesOnlyTag::Parse(TagItem tag) {
  return ParseEmptyTag<XIFramesOnlyTag>(tag);
}

// static
ParseStatus::Or<XMapTag> XMapTag::Parse(
    TagItem tag,
    const VariableDictionary& variable_dict,
    VariableDictionary::SubstitutionBuffer& sub_buffer) {
  DCHECK(tag.GetName() == ToTagName(XMapTag::kName));
  if (!tag.GetContent().has_value()) {
    return ParseStatusCode::kMalformedTag;
  }

  // Parse the attribute-list
  TypedAttributeMap<XMapTagAttribute> map;
  types::AttributeListIterator iter(*tag.GetContent());
  auto map_result = map.FillUntilError(&iter);

  if (map_result.code() != ParseStatusCode::kReachedEOF) {
    return ParseStatus(ParseStatusCode::kMalformedTag)
        .AddCause(std::move(map_result));
  }

  std::optional<ResolvedSourceString> uri;
  if (map.HasValue(XMapTagAttribute::kUri)) {
    auto result = types::ParseQuotedString(map.GetValue(XMapTagAttribute::kUri),
                                           variable_dict, sub_buffer);
    if (!result.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(result).error());
    }

    uri = std::move(result).value();
  } else {
    return ParseStatusCode::kMalformedTag;
  }

  std::optional<types::parsing::ByteRangeExpression> byte_range;
  if (map.HasValue(XMapTagAttribute::kByteRange)) {
    auto result =
        types::ParseQuotedString(map.GetValue(XMapTagAttribute::kByteRange),
                                 variable_dict, sub_buffer)
            .MapValue(types::parsing::ByteRangeExpression::Parse);
    if (!result.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(result).error());
    }

    byte_range = std::move(result).value();
  }

  return XMapTag{.uri = uri.value(), .byte_range = byte_range};
}

// static
ParseStatus::Or<XMediaSequenceTag> XMediaSequenceTag::Parse(TagItem tag) {
  return ParseDecimalIntegerTag(tag, &XMediaSequenceTag::number);
}

// static
ParseStatus::Or<XPartTag> XPartTag::Parse(
    TagItem tag,
    const VariableDictionary& vars,
    VariableDictionary::SubstitutionBuffer& subs) {
  DCHECK(tag.GetName() == ToTagName(XPartTag::kName));
  if (!tag.GetContent().has_value()) {
    return ParseStatusCode::kMalformedTag;
  }

  TypedAttributeMap<XPartTagAttribute> map;
  types::AttributeListIterator iter(*tag.GetContent());
  auto map_result = map.FillUntilError(&iter);

  if (map_result.code() != ParseStatusCode::kReachedEOF) {
    return ParseStatus(ParseStatusCode::kMalformedTag)
        .AddCause(std::move(map_result));
  }

  auto uri = ParseField<ResolvedSourceString>(
      XPartTagAttribute::kUri, map,
      &types::parsing::Quoted<types::parsing::RawStr>::ParseWithSubstitution,
      vars, subs);
  RETURN_IF_ERROR(uri);

  auto duration = ParseField<base::TimeDelta>(
      XPartTagAttribute::kDuration, map,
      &types::parsing::TimeDelta::ParseWithoutSubstitution);
  RETURN_IF_ERROR(duration);

  auto byte_range =
      ParseField<std::optional<types::parsing::ByteRangeExpression>>(
          XPartTagAttribute::kByteRange, map,
          &types::parsing::Quoted<
              types::parsing::ByteRangeExpression>::ParseWithSubstitution,
          vars, subs);
  RETURN_IF_ERROR(byte_range);

  auto independent = ParseField<std::optional<bool>>(
      XPartTagAttribute::kIndependent, map,
      &types::parsing::YesOrNo::ParseWithoutSubstitution);
  RETURN_IF_ERROR(independent);

  auto gap = ParseField<std::optional<bool>>(
      XPartTagAttribute::kGap, map,
      &types::parsing::YesOrNo::ParseWithoutSubstitution);
  RETURN_IF_ERROR(gap);

  return XPartTag{.uri = std::move(uri).value(),
                  .duration = std::move(duration).value(),
                  .byte_range = std::move(byte_range).value(),
                  .independent = (*independent).value_or(false),
                  .gap = (*gap).value_or(false)};
}

// static
ParseStatus::Or<XPartInfTag> XPartInfTag::Parse(TagItem tag) {
  DCHECK(tag.GetName() == ToTagName(XPartInfTag::kName));
  if (!tag.GetContent().has_value()) {
    return ParseStatusCode::kMalformedTag;
  }

  // Parse the attribute-list
  TypedAttributeMap<XPartInfTagAttribute> map;
  types::AttributeListIterator iter(*tag.GetContent());
  auto map_result = map.FillUntilError(&iter);

  if (map_result.code() != ParseStatusCode::kReachedEOF) {
    return ParseStatus(ParseStatusCode::kMalformedTag)
        .AddCause(std::move(map_result));
  }

  // Extract the 'PART-TARGET' attribute
  base::TimeDelta part_target;
  if (map.HasValue(XPartInfTagAttribute::kPartTarget)) {
    auto result = types::ParseDecimalFloatingPoint(
        map.GetValue(XPartInfTagAttribute::kPartTarget)
            .SkipVariableSubstitution());

    if (!result.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(result).error());
    }

    part_target = base::Seconds(std::move(result).value());

    if (part_target.is_max()) {
      return ParseStatusCode::kValueOverflowsTimeDelta;
    }
  } else {
    return ParseStatusCode::kMalformedTag;
  }

  return XPartInfTag{.target_duration = part_target};
}

// static
ParseStatus::Or<XPlaylistTypeTag> XPlaylistTypeTag::Parse(TagItem tag) {
  DCHECK(tag.GetName() == ToTagName(XPlaylistTypeTag::kName));

  // This tag requires content
  if (!tag.GetContent().has_value() || tag.GetContent()->Empty()) {
    return ParseStatusCode::kMalformedTag;
  }

  if (tag.GetContent()->Str() == "EVENT") {
    return XPlaylistTypeTag{.type = PlaylistType::kEvent};
  }
  if (tag.GetContent()->Str() == "VOD") {
    return XPlaylistTypeTag{.type = PlaylistType::kVOD};
  }

  return ParseStatusCode::kUnknownPlaylistType;
}

// static
ParseStatus::Or<XServerControlTag> XServerControlTag::Parse(TagItem tag) {
  DCHECK(tag.GetName() == ToTagName(XServerControlTag::kName));
  if (!tag.GetContent().has_value()) {
    return ParseStatusCode::kMalformedTag;
  }

  // Parse the attribute-list
  TypedAttributeMap<XServerControlTagAttribute> map;
  types::AttributeListIterator iter(*tag.GetContent());
  auto map_result = map.FillUntilError(&iter);

  if (map_result.code() != ParseStatusCode::kReachedEOF) {
    return ParseStatus(ParseStatusCode::kMalformedTag)
        .AddCause(std::move(map_result));
  }

  // Extract the 'CAN-SKIP-UNTIL' attribute
  std::optional<base::TimeDelta> can_skip_until;
  if (map.HasValue(XServerControlTagAttribute::kCanSkipUntil)) {
    auto result = types::ParseDecimalFloatingPoint(
        map.GetValue(XServerControlTagAttribute::kCanSkipUntil)
            .SkipVariableSubstitution());

    if (!result.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(result).error());
    }

    can_skip_until = base::Seconds(std::move(result).value());

    if (can_skip_until->is_max()) {
      return ParseStatusCode::kValueOverflowsTimeDelta;
    }
  }

  // Extract the 'CAN-SKIP-DATERANGES' attribute
  bool can_skip_dateranges = false;
  if (map.HasValue(XServerControlTagAttribute::kCanSkipDateRanges)) {
    if (map.GetValue(XServerControlTagAttribute::kCanSkipDateRanges).Str() ==
        "YES") {
      // The existence of this attribute requires the 'CAN-SKIP-UNTIL'
      // attribute.
      if (!can_skip_until.has_value()) {
        return ParseStatusCode::kMalformedTag;
      }

      can_skip_dateranges = true;
    }
  }

  // Extract the 'HOLD-BACK' attribute
  std::optional<base::TimeDelta> hold_back;
  if (map.HasValue(XServerControlTagAttribute::kHoldBack)) {
    auto result = types::ParseDecimalFloatingPoint(
        map.GetValue(XServerControlTagAttribute::kHoldBack)
            .SkipVariableSubstitution());

    if (!result.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(result).error());
    }

    hold_back = base::Seconds(std::move(result).value());

    if (hold_back->is_max()) {
      return ParseStatusCode::kValueOverflowsTimeDelta;
    }
  }

  // Extract the 'PART-HOLD-BACK' attribute
  std::optional<base::TimeDelta> part_hold_back;
  if (map.HasValue(XServerControlTagAttribute::kPartHoldBack)) {
    auto result = types::ParseDecimalFloatingPoint(
        map.GetValue(XServerControlTagAttribute::kPartHoldBack)
            .SkipVariableSubstitution());

    if (!result.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(result).error());
    }

    part_hold_back = base::Seconds(std::move(result).value());

    if (part_hold_back->is_max()) {
      return ParseStatusCode::kValueOverflowsTimeDelta;
    }
  }

  // Extract the 'CAN-BLOCK-RELOAD' attribute
  bool can_block_reload = false;
  if (map.HasValue(XServerControlTagAttribute::kCanBlockReload)) {
    if (map.GetValue(XServerControlTagAttribute::kCanBlockReload).Str() ==
        "YES") {
      can_block_reload = true;
    }
  }

  return XServerControlTag{
      .skip_boundary = can_skip_until,
      .can_skip_dateranges = can_skip_dateranges,
      .hold_back = hold_back,
      .part_hold_back = part_hold_back,
      .can_block_reload = can_block_reload,
  };
}

// static
ParseStatus::Or<XTargetDurationTag> XTargetDurationTag::Parse(TagItem tag) {
  DCHECK(tag.GetName() == ToTagName(XTargetDurationTag::kName));
  if (!tag.GetContent().has_value()) {
    return ParseStatusCode::kMalformedTag;
  }

  auto duration_result = types::ParseDecimalInteger(
      tag.GetContent().value().SkipVariableSubstitution());
  if (!duration_result.has_value()) {
    return ParseStatus(ParseStatusCode::kMalformedTag)
        .AddCause(std::move(duration_result).error());
  }

  auto duration = base::Seconds(std::move(duration_result).value());
  if (duration.is_max()) {
    return ParseStatusCode::kValueOverflowsTimeDelta;
  }

  return XTargetDurationTag{.duration = duration};
}

XSkipTag::XSkipTag() = default;
XSkipTag::~XSkipTag() = default;
XSkipTag::XSkipTag(const XSkipTag&) = default;
XSkipTag::XSkipTag(XSkipTag&&) = default;

ParseStatus::Or<XSkipTag> XSkipTag::Parse(
    TagItem tag,
    const VariableDictionary& variable_dict,
    VariableDictionary::SubstitutionBuffer& sub_buffer) {
  DCHECK(tag.GetName() == ToTagName(XSkipTag::kName));
  if (!tag.GetContent().has_value()) {
    return ParseStatusCode::kMalformedTag;
  }

  XSkipTag out;
  TypedAttributeMap<XSkipTagAttribute> map;
  types::AttributeListIterator iter(*tag.GetContent());
  auto map_result = map.FillUntilError(&iter);

  if (map_result.code() != ParseStatusCode::kReachedEOF) {
    return ParseStatus(ParseStatusCode::kMalformedTag)
        .AddCause(std::move(map_result));
  }

  if (!map.HasValue(XSkipTagAttribute::kSkippedSegments)) {
    return ParseStatusCode::kMalformedTag;
  }

  auto skip_result = types::ParseDecimalInteger(
      map.GetValue(XSkipTagAttribute::kSkippedSegments)
          .SkipVariableSubstitution());

  if (!skip_result.has_value()) {
    return ParseStatus(ParseStatusCode::kMalformedTag)
        .AddCause(std::move(skip_result).error());
  }

  out.skipped_segments = std::move(skip_result).value();

  if (map.HasValue(XSkipTagAttribute::kRecentlyRemovedDateranges)) {
    // TODO(bug/314833987): Should this list have substitution?
    auto removed_result = types::ParseQuotedString(
        map.GetValue(XSkipTagAttribute::kRecentlyRemovedDateranges),
        variable_dict, sub_buffer, /*allow_empty=*/true);
    if (!removed_result.has_value()) {
      return ParseStatus(ParseStatusCode::kMalformedTag)
          .AddCause(std::move(removed_result).error());
    }

    auto tab_joined_daterange_ids = std::move(removed_result).value();
    std::vector<std::string> removed_dateranges = {};

    while (!tab_joined_daterange_ids.Empty()) {
      const auto daterange_id = tab_joined_daterange_ids.ConsumeDelimiter('\t');
      if (daterange_id.Empty()) {
        return ParseStatusCode::kMalformedTag;
      }
      // TODO(bug/314833987): What type should this be parsed into?
      removed_dateranges.emplace_back(daterange_id.Str());
    }
    out.recently_removed_dateranges = std::move(removed_dateranges);
  }

  return out;
}

ParseStatus::Or<XRenditionReportTag> XRenditionReportTag::Parse(
    TagItem tag,
    const VariableDictionary& variable_dict,
    VariableDictionary::SubstitutionBuffer& sub_buffer) {
  CHECK(tag.GetName() == ToTagName(XRenditionReportTag::kName));
  if (!tag.GetContent().has_value()) {
    return ParseStatusCode::kMalformedTag;
  }
  XRenditionReportTag out;
  TypedAttributeMap<XRenditionReportTagAttribute> map;
  types::AttributeListIterator iter(*tag.GetContent());
  auto map_result = map.FillUntilError(&iter);

  if (map_result.code() != ParseStatusCode::kReachedEOF) {
    return std::move(map_result).AddHere();
  }

  if (map.HasValue(XRenditionReportTagAttribute::kUri)) {
    auto uri_result = types::ParseQuotedString(
        map.GetValue(XRenditionReportTagAttribute::kUri), variable_dict,
        sub_buffer);
    if (!uri_result.has_value()) {
      return std::move(uri_result).error().AddHere();
    }
    out.uri = std::move(uri_result).value();
  }

  if (map.HasValue(XRenditionReportTagAttribute::kLastMSN)) {
    auto msn_result = types::ParseDecimalInteger(
        map.GetValue(XRenditionReportTagAttribute::kLastMSN)
            .SkipVariableSubstitution());
    if (!msn_result.has_value()) {
      return std::move(msn_result).error().AddHere();
    }
    out.last_msn = std::move(msn_result).value();
  }

  if (map.HasValue(XRenditionReportTagAttribute::kLastPart)) {
    auto part_result = types::ParseDecimalInteger(
        map.GetValue(XRenditionReportTagAttribute::kLastPart)
            .SkipVariableSubstitution());
    if (!part_result.has_value()) {
      return std::move(part_result).error().AddHere();
    }
    out.last_part = std::move(part_result).value();
  }

  return out;
}

ParseStatus::Or<XProgramDateTimeTag> XProgramDateTimeTag::Parse(TagItem tag) {
  return ParseISO8601DateTimeTag(tag, &XProgramDateTimeTag::time);
}

template <typename Attrs>
ParseStatus::Or<TypedAttributeMap<Attrs>> RequireNonEmptyMap(
    std::optional<SourceString> content) {
  if (!content.has_value()) {
    return ParseStatusCode::kMalformedTag;
  }

  TypedAttributeMap<Attrs> map;
  types::AttributeListIterator iter(*content);
  auto map_result = map.FillUntilError(&iter);

  if (map_result.code() != ParseStatusCode::kReachedEOF) {
    return ParseStatus(ParseStatusCode::kMalformedTag)
        .AddCause(std::move(map_result));
  }

  return map;
}

namespace {

constexpr char const* kMethodNone = "NONE";
constexpr char const* kMethodAES128 = "AES-128";
constexpr char const* kMethodAES256 = "AES-256";
constexpr char const* kMethodSampleAES = "SAMPLE-AES";
constexpr char const* kMethodSampleAESCTR = "SAMPLE-AES-CTR";
constexpr char const* kMethodSampleAESCENC = "SAMPLE-AES-CENC";
constexpr char const* kMethodISO230017 = "ISO-23001-7";

constexpr char const* kFmtClearkey = "org.w3.clearkey";
constexpr char const* kFmtWidevine =
    "urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed";
constexpr char const* kFmtIdentity = "identity";

ParseStatus::Or<XKeyTagMethod> RecognizeMethod(SourceString content) {
  if (content.Str() == kMethodNone) {
    return XKeyTagMethod::kNone;
  }
  if (content.Str() == kMethodAES128) {
    return XKeyTagMethod::kAES128;
  } else if (content.Str() == kMethodAES256) {
    return XKeyTagMethod::kAES256;
  } else if (content.Str() == kMethodSampleAES) {
    return XKeyTagMethod::kSampleAES;
  } else if (content.Str() == kMethodSampleAESCTR) {
    return XKeyTagMethod::kSampleAESCTR;
  } else if (content.Str() == kMethodSampleAESCENC) {
    return XKeyTagMethod::kSampleAESCENC;
  } else if (content.Str() == kMethodISO230017) {
    return XKeyTagMethod::kISO230017;
  } else {
    return ParseStatusCode::kMalformedTag;
  }
}

ParseStatus::Or<XKeyTagKeyFormat> RecognizeFormat(
    std::optional<ResolvedSourceString> content) {
  if (!content.has_value()) {
    return XKeyTagKeyFormat::kIdentity;
  } else if (content->Str() == kFmtClearkey) {
    return XKeyTagKeyFormat::kClearKey;
  } else if (content->Str() == kFmtWidevine) {
    return XKeyTagKeyFormat::kWidevine;
  } else if (content->Str() == kFmtIdentity) {
    return XKeyTagKeyFormat::kIdentity;
  } else {
    return XKeyTagKeyFormat::kUnsupported;
  }
}

template <typename T>
ParseStatus::Or<T> ValidateKeyTag(
    XKeyTagMethod method,
    ResolvedSourceString uri,
    std::optional<XKeyTag::IVHex::Container> iv,
    XKeyTagKeyFormat keyformat,
    std::optional<ResolvedSourceString> keyformat_versions) {
  // Check for incompatible fields. Some methods _must not_ have an IV
  // present, while some formats only have a specific set of allowable
  // methods.
  if (iv.has_value()) {
    switch (method) {
      case XKeyTagMethod::kSampleAESCTR:
      case XKeyTagMethod::kSampleAESCENC:
      case XKeyTagMethod::kISO230017:
        return ParseStatusCode::kMalformedTag;
      default:
        break;
    }
  }
  switch (keyformat) {
    case XKeyTagKeyFormat::kIdentity:
    case XKeyTagKeyFormat::kUnsupported:
      break;  // Identity and others always are ok.
    case XKeyTagKeyFormat::kClearKey:
    case XKeyTagKeyFormat::kWidevine:
      switch (method) {
        case XKeyTagMethod::kSampleAES:
        case XKeyTagMethod::kSampleAESCTR:
        case XKeyTagMethod::kSampleAESCENC:
        case XKeyTagMethod::kISO230017:
          break;  // Acceptable methods for widevine and clearkey
        case XKeyTagMethod::kNone:
        case XKeyTagMethod::kAES128:
        case XKeyTagMethod::kAES256:
          return ParseStatusCode::kMalformedTag;
      }
      break;
  }

  return T{.method = method,
           .uri = std::move(uri),
           .iv = std::move(iv),
           .keyformat = keyformat,
           .keyformat_versions = std::move(keyformat_versions)};
}

template <typename T>
ParseStatus::Or<T> ParseKeyTag(TagItem tag,
                               const VariableDictionary& vars,
                               VariableDictionary::SubstitutionBuffer& subs) {
  return RequireNonEmptyMap<XKeyTagAttribute>(tag.GetContent())
      .MapValue([&](auto map) -> ParseStatus::Or<T> {
        auto enc_method = ParseField<XKeyTagMethod>(XKeyTagAttribute::kMethod,
                                                    map, &RecognizeMethod);
        RETURN_IF_ERROR(enc_method);

        if constexpr (T::kAllowEmptyMethod) {
          if (*enc_method == XKeyTagMethod::kNone) {
            if (map.Size() != 1) {
              return ParseStatusCode::kMalformedTag;
            }
            return T{.method = *enc_method};
          }
        }

        auto enc_uri = ParseField<ResolvedSourceString>(
            XKeyTagAttribute::kUri, map,
            &types::parsing::Quoted<
                types::parsing::RawStr>::ParseWithSubstitution,
            vars, subs);
        RETURN_IF_ERROR(enc_uri);

        auto enc_iv = ParseField<std::optional<XKeyTag::IVHex::Container>>(
            XKeyTagAttribute::kIv, map,
            &XKeyTag::IVHex::ParseWithoutSubstitution);
        RETURN_IF_ERROR(enc_iv);

        auto enc_keyformat =
            ParseField<std::optional<ResolvedSourceString>>(
                XKeyTagAttribute::kKeyFormat, map,
                &types::parsing::Quoted<
                    types::parsing::RawStr>::ParseWithoutSubstitution)
                .MapValue(&RecognizeFormat);
        RETURN_IF_ERROR(enc_keyformat);

        auto enc_keyformat_versions =
            ParseField<std::optional<ResolvedSourceString>>(
                XKeyTagAttribute::kKeyFormatVersions, map,
                &types::parsing::RawStr::ParseWithoutSubstitution);
        RETURN_IF_ERROR(enc_keyformat_versions);

        return ValidateKeyTag<T>(*enc_method, *enc_uri, *enc_iv, *enc_keyformat,
                                 *enc_keyformat_versions);
      });
}

}  // namespace

ParseStatus::Or<XKeyTag> XKeyTag::Parse(
    TagItem tag,
    const VariableDictionary& vars,
    VariableDictionary::SubstitutionBuffer& subs) {
  DCHECK(tag.GetName() == ToTagName(XKeyTag::kName));
  return ParseKeyTag<XKeyTag>(tag, vars, subs);
}

ParseStatus::Or<XSessionKeyTag> XSessionKeyTag::Parse(
    TagItem tag,
    const VariableDictionary& vars,
    VariableDictionary::SubstitutionBuffer& subs) {
  DCHECK(tag.GetName() == ToTagName(XSessionKeyTag::kName));
  return ParseKeyTag<XSessionKeyTag>(tag, vars, subs);
}

#undef RETURN_IF_ERROR

}  // namespace media::hls