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

#include "cast/streaming/offer_messages.h"

#include <limits>
#include <utility>

#include "cast/streaming/rtp_defines.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "util/json/json_serialization.h"

using ::testing::ElementsAre;

namespace openscreen {
namespace cast {

namespace {

constexpr char kValidOffer[] = R"({
  "castMode": "mirroring",
  "receiverGetStatus": true,
  "supportedStreams": [
    {
      "index": 0,
      "type": "video_source",
      "codecName": "h264",
      "rtpProfile": "cast",
      "rtpPayloadType": 101,
      "ssrc": 19088743,
      "maxFrameRate": "60000/1000",
      "timeBase": "1/90000",
      "maxBitRate": 5000000,
      "profile": "main",
      "level": "4",
      "targetDelay": 200,
      "aesKey": "040d756791711fd3adb939066e6d8690",
      "aesIvMask": "9ff0f022a959150e70a2d05a6c184aed",
      "resolutions": [
        {
          "width": 1280,
          "height": 720
        },
        {
          "width": 640,
          "height": 360
        },
        {
          "width": 640,
          "height": 480
        }
      ]
    },
    {
      "index": 1,
      "type": "video_source",
      "codecName": "vp8",
      "rtpProfile": "cast",
      "rtpPayloadType": 100,
      "ssrc": 19088744,
      "maxFrameRate": "30000/1001",
      "targetDelay": 1000,
      "timeBase": "1/90000",
      "maxBitRate": 5000000,
      "profile": "main",
      "level": "5",
      "aesKey": "bbf109bf84513b456b13a184453b66ce",
      "aesIvMask": "edaf9e4536e2b66191f560d9c04b2a69"
    },
    {
      "index": 2,
      "type": "audio_source",
      "codecName": "opus",
      "targetDelay": 300,
      "rtpProfile": "cast",
      "rtpPayloadType": 96,
      "ssrc": 4294967295,
      "bitRate": 124000,
      "timeBase": "1/48000",
      "channels": 2,
      "aesKey": "51027e4e2347cbcb49d57ef10177aebc",
      "aesIvMask": "7f12a19be62a36c04ae4116caaeff6d1"
    }
  ]
})";

void ExpectFailureOnParse(
    absl::string_view body,
    absl::optional<Error::Code> expected = absl::nullopt) {
  ErrorOr<Json::Value> root = json::Parse(body);
  ASSERT_TRUE(root.is_value()) << root.error();
  ErrorOr<Offer> error_or_offer = Offer::Parse(std::move(root.value()));
  EXPECT_TRUE(error_or_offer.is_error());
  if (expected) {
    EXPECT_EQ(expected, error_or_offer.error().code());
  }
}

void ExpectEqualsValidOffer(const Offer& offer) {
  EXPECT_EQ(CastMode::kMirroring, offer.cast_mode);
  EXPECT_EQ(true, offer.supports_wifi_status_reporting);

  // Verify list of video streams.
  EXPECT_EQ(2u, offer.video_streams.size());
  const auto& video_streams = offer.video_streams;

  const bool flipped = video_streams[0].stream.index != 0;
  const VideoStream& vs_one = flipped ? video_streams[1] : video_streams[0];
  const VideoStream& vs_two = flipped ? video_streams[0] : video_streams[1];

  EXPECT_EQ(0, vs_one.stream.index);
  EXPECT_EQ(1, vs_one.stream.channels);
  EXPECT_EQ(Stream::Type::kVideoSource, vs_one.stream.type);
  EXPECT_EQ(VideoCodec::kH264, vs_one.codec);
  EXPECT_EQ(RtpPayloadType::kVideoH264, vs_one.stream.rtp_payload_type);
  EXPECT_EQ(19088743u, vs_one.stream.ssrc);
  EXPECT_EQ((SimpleFraction{60000, 1000}), vs_one.max_frame_rate);
  EXPECT_EQ(90000, vs_one.stream.rtp_timebase);
  EXPECT_EQ(5000000, vs_one.max_bit_rate);
  EXPECT_EQ("main", vs_one.profile);
  EXPECT_EQ("4", vs_one.level);
  EXPECT_THAT(vs_one.stream.aes_key,
              ElementsAre(0x04, 0x0d, 0x75, 0x67, 0x91, 0x71, 0x1f, 0xd3, 0xad,
                          0xb9, 0x39, 0x06, 0x6e, 0x6d, 0x86, 0x90));
  EXPECT_THAT(vs_one.stream.aes_iv_mask,
              ElementsAre(0x9f, 0xf0, 0xf0, 0x22, 0xa9, 0x59, 0x15, 0x0e, 0x70,
                          0xa2, 0xd0, 0x5a, 0x6c, 0x18, 0x4a, 0xed));

  const auto& resolutions = vs_one.resolutions;
  EXPECT_EQ(3u, resolutions.size());
  const Resolution& r_one = resolutions[0];
  EXPECT_EQ(1280, r_one.width);
  EXPECT_EQ(720, r_one.height);

  const Resolution& r_two = resolutions[1];
  EXPECT_EQ(640, r_two.width);
  EXPECT_EQ(360, r_two.height);

  const Resolution& r_three = resolutions[2];
  EXPECT_EQ(640, r_three.width);
  EXPECT_EQ(480, r_three.height);

  EXPECT_EQ(1, vs_two.stream.index);
  EXPECT_EQ(1, vs_two.stream.channels);
  EXPECT_EQ(Stream::Type::kVideoSource, vs_two.stream.type);
  EXPECT_EQ(VideoCodec::kVp8, vs_two.codec);
  EXPECT_EQ(RtpPayloadType::kVideoVp8, vs_two.stream.rtp_payload_type);
  EXPECT_EQ(19088744u, vs_two.stream.ssrc);
  EXPECT_EQ((SimpleFraction{30000, 1001}), vs_two.max_frame_rate);
  EXPECT_EQ(90000, vs_two.stream.rtp_timebase);
  EXPECT_EQ(5000000, vs_two.max_bit_rate);
  EXPECT_EQ("main", vs_two.profile);
  EXPECT_EQ("5", vs_two.level);
  EXPECT_THAT(vs_two.stream.aes_key,
              ElementsAre(0xbb, 0xf1, 0x09, 0xbf, 0x84, 0x51, 0x3b, 0x45, 0x6b,
                          0x13, 0xa1, 0x84, 0x45, 0x3b, 0x66, 0xce));
  EXPECT_THAT(vs_two.stream.aes_iv_mask,
              ElementsAre(0xed, 0xaf, 0x9e, 0x45, 0x36, 0xe2, 0xb6, 0x61, 0x91,
                          0xf5, 0x60, 0xd9, 0xc0, 0x4b, 0x2a, 0x69));

  const auto& resolutions_two = vs_two.resolutions;
  EXPECT_EQ(0u, resolutions_two.size());

  // Verify list of audio streams.
  EXPECT_EQ(1u, offer.audio_streams.size());
  const AudioStream& as = offer.audio_streams[0];
  EXPECT_EQ(2, as.stream.index);
  EXPECT_EQ(Stream::Type::kAudioSource, as.stream.type);
  EXPECT_EQ(AudioCodec::kOpus, as.codec);
  EXPECT_EQ(RtpPayloadType::kAudioOpus, as.stream.rtp_payload_type);
  EXPECT_EQ(std::numeric_limits<Ssrc>::max(), as.stream.ssrc);
  EXPECT_EQ(124000, as.bit_rate);
  EXPECT_EQ(2, as.stream.channels);

  EXPECT_THAT(as.stream.aes_key,
              ElementsAre(0x51, 0x02, 0x7e, 0x4e, 0x23, 0x47, 0xcb, 0xcb, 0x49,
                          0xd5, 0x7e, 0xf1, 0x01, 0x77, 0xae, 0xbc));
  EXPECT_THAT(as.stream.aes_iv_mask,
              ElementsAre(0x7f, 0x12, 0xa1, 0x9b, 0xe6, 0x2a, 0x36, 0xc0, 0x4a,
                          0xe4, 0x11, 0x6c, 0xaa, 0xef, 0xf6, 0xd1));
}

}  // namespace

TEST(OfferTest, ErrorOnEmptyOffer) {
  ExpectFailureOnParse("{}");
}

TEST(OfferTest, ErrorOnMissingMandatoryFields) {
  // It's okay if castMode is omitted, but if supportedStreams is omitted we
  // should fail here.
  ExpectFailureOnParse(R"({
    "castMode": "mirroring"
  })");
}

TEST(OfferTest, CanParseValidButStreamlessOffer) {
  ErrorOr<Json::Value> root = json::Parse(R"({
    "castMode": "mirroring",
    "supportedStreams": []
  })");
  ASSERT_TRUE(root.is_value()) << root.error();
  EXPECT_TRUE(Offer::Parse(std::move(root.value())).is_value());
}

TEST(OfferTest, ErrorOnMissingAudioStreamMandatoryField) {
  ExpectFailureOnParse(R"({
    "castMode": "mirroring",
    "supportedStreams": [{
      "index": 2,
      "codecName": "opus",
      "rtpProfile": "cast",
      "rtpPayloadType": 96,
      "ssrc": 19088743,
      "bitRate": 124000,
      "timeBase": "1/48000",
      "channels": 2
    }]})");

  ExpectFailureOnParse(R"({
    "castMode": "mirroring",
    "supportedStreams": [{
      "index": 2,
      "type": "audio_source",
      "codecName": "opus",
      "rtpProfile": "cast",
      "rtpPayloadType": 96,
      "bitRate": 124000,
      "timeBase": "1/48000",
      "channels": 2
    }]})");
}

TEST(OfferTest, CanParseValidButMinimalAudioOffer) {
  ErrorOr<Json::Value> root = json::Parse(R"({
    "castMode": "mirroring",
    "supportedStreams": [{
      "index": 2,
      "type": "audio_source",
      "codecName": "opus",
      "rtpProfile": "cast",
      "rtpPayloadType": 96,
      "ssrc": 19088743,
      "bitRate": 124000,
      "timeBase": "1/48000",
      "channels": 2,
      "aesKey": "51027e4e2347cbcb49d57ef10177aebc",
      "aesIvMask": "7f12a19be62a36c04ae4116caaeff6d1"
    }]
  })");
  ASSERT_TRUE(root.is_value());
  EXPECT_TRUE(Offer::Parse(std::move(root.value())).is_value());
}

TEST(OfferTest, CanParseValidZeroBitRateAudioOffer) {
  ErrorOr<Json::Value> root = json::Parse(R"({
    "castMode": "mirroring",
    "supportedStreams": [{
      "index": 2,
      "type": "audio_source",
      "codecName": "opus",
      "rtpProfile": "cast",
      "rtpPayloadType": 96,
      "ssrc": 19088743,
      "bitRate": 0,
      "timeBase": "1/48000",
      "channels": 5,
      "aesKey": "51029e4e2347cbcb49d57ef10177aebd",
      "aesIvMask": "7f12a19be62a36c04ae4116caaeff5d2"
    }]
  })");
  ASSERT_TRUE(root.is_value()) << root.error();
  const auto offer = Offer::Parse(std::move(root.value()));
  EXPECT_TRUE(offer.is_value()) << offer.error();
}

TEST(OfferTest, ErrorOnInvalidRtpTimebase) {
  ExpectFailureOnParse(R"({
    "castMode": "mirroring",
    "supportedStreams": [{
      "index": 2,
      "type": "audio_source",
      "codecName": "opus",
      "rtpProfile": "cast",
      "rtpPayloadType": 96,
      "ssrc": 19088743,
      "bitRate": 124000,
      "timeBase": "1/10000000",
      "channels": 2,
      "aesKey": "51027e4e2347cbcb49d57ef10177aebc",
      "aesIvMask": "7f12a19be62a36c04ae4116caaeff6d1"
    }]
  })");

  ExpectFailureOnParse(R"({
    "castMode": "mirroring",
    "supportedStreams": [{
      "index": 2,
      "type": "audio_source",
      "codecName": "opus",
      "rtpProfile": "cast",
      "rtpPayloadType": 96,
      "ssrc": 19088743,
      "bitRate": 124000,
      "timeBase": "0",
      "channels": 2,
      "aesKey": "51027e4e2347cbcb49d57ef10177aebc",
      "aesIvMask": "7f12a19be62a36c04ae4116caaeff6d1"
    }]
  })");

  ExpectFailureOnParse(R"({
    "castMode": "mirroring",
    "supportedStreams": [{
      "index": 2,
      "type": "audio_source",
      "codecName": "opus",
      "rtpProfile": "cast",
      "rtpPayloadType": 96,
      "ssrc": 19088743,
      "bitRate": 124000,
      "timeBase": "1/1",
      "channels": 2,
      "aesKey": "51027e4e2347cbcb49d57ef10177aebc",
      "aesIvMask": "7f12a19be62a36c04ae4116caaeff6d1"
    }]
  })");

  ExpectFailureOnParse(R"({
    "castMode": "mirroring",
    "supportedStreams": [{
      "index": 2,
      "type": "audio_source",
      "codecName": "opus",
      "rtpProfile": "cast",
      "rtpPayloadType": 96,
      "ssrc": 19088743,
      "bitRate": 124000,
      "timeBase": "really fast plz, kthx",
      "channels": 2,
      "aesKey": "51027e4e2347cbcb49d57ef10177aebc",
      "aesIvMask": "7f12a19be62a36c04ae4116caaeff6d1"
    }]
  })");
}

TEST(OfferTest, ErrorOnMissingVideoStreamMandatoryField) {
  ExpectFailureOnParse(R"({
    "castMode": "mirroring",
    "supportedStreams": [{
      "index": 2,
      "codecName": "video_source",
      "rtpProfile": "h264",
      "rtpPayloadType": 101,
      "ssrc": 19088743,
      "bitRate": 124000,
      "timeBase": "1/48000"
    }]
  })");

  ExpectFailureOnParse(R"({
    "castMode": "mirroring",
    "supportedStreams": [{
      "index": 2,
      "type": "video_source",
      "codecName": "h264",
      "rtpProfile": "cast",
      "rtpPayloadType": 101,
      "bitRate": 124000,
      "timeBase": "1/48000",
       "maxBitRate": 10000
    }]
  })");

  ExpectFailureOnParse(R"({
    "castMode": "mirroring",
    "supportedStreams": [{
      "index": 2,
      "type": "video_source",
      "codecName": "vp8",
      "rtpProfile": "cast",
      "rtpPayloadType": 100,
      "ssrc": 19088743,
      "timeBase": "1/48000",
       "resolutions": [],
       "maxBitRate": 10000
    }]
  })");

  ExpectFailureOnParse(R"({
    "castMode": "mirroring",
    "supportedStreams": [{
      "index": 2,
      "type": "video_source",
      "codecName": "vp8",
      "rtpProfile": "cast",
      "rtpPayloadType": 100,
      "ssrc": 19088743,
      "timeBase": "1/48000",
       "resolutions": [],
       "maxBitRate": 10000,
       "aesKey": "51027e4e2347cbcb49d57ef10177aebc"
    }]
  })");

  ExpectFailureOnParse(R"({
    "castMode": "mirroring",
    "supportedStreams": [{
      "index": 2,
      "type": "video_source",
      "codecName": "vp8",
      "rtpProfile": "cast",
      "rtpPayloadType": 100,
      "ssrc": 19088743,
      "timeBase": "1/48000",
       "resolutions": [],
       "maxBitRate": 10000,
       "aesIvMask": "7f12a19be62a36c04ae4116caaeff6d1"
    }]
  })");
}

TEST(OfferTest, CanParseValidButMinimalVideoOffer) {
  ErrorOr<Json::Value> root = json::Parse(R"({
    "castMode": "mirroring",
    "supportedStreams": [{
      "index": 2,
      "type": "video_source",
      "codecName": "vp8",
      "rtpProfile": "cast",
      "rtpPayloadType": 100,
      "ssrc": 19088743,
      "timeBase": "1/48000",
       "resolutions": [],
       "maxBitRate": 10000,
       "aesKey": "51027e4e2347cbcb49d57ef10177aebc",
       "aesIvMask": "7f12a19be62a36c04ae4116caaeff6d1"
    }]
  })");

  ASSERT_TRUE(root.is_value());
  EXPECT_TRUE(Offer::Parse(std::move(root.value())).is_value());
}

TEST(OfferTest, CanParseValidOffer) {
  ErrorOr<Json::Value> root = json::Parse(kValidOffer);
  ASSERT_TRUE(root.is_value());
  ErrorOr<Offer> offer = Offer::Parse(std::move(root.value()));

  ExpectEqualsValidOffer(offer.value());
}

TEST(OfferTest, ParseAndToJsonResultsInSameOffer) {
  ErrorOr<Json::Value> root = json::Parse(kValidOffer);
  ASSERT_TRUE(root.is_value());
  ErrorOr<Offer> offer = Offer::Parse(std::move(root.value()));

  ExpectEqualsValidOffer(offer.value());

  auto eoj = offer.value().ToJson();
  EXPECT_TRUE(eoj.is_value()) << eoj.error();
  ErrorOr<Offer> reparsed_offer = Offer::Parse(std::move(eoj.value()));
  ExpectEqualsValidOffer(reparsed_offer.value());
}

// We don't want to enforce that a given offer must have both audio and
// video, so we don't assert on either.
TEST(OfferTest, ToJsonSucceedsWithMissingStreams) {
  ErrorOr<Json::Value> root = json::Parse(kValidOffer);
  ASSERT_TRUE(root.is_value());
  ErrorOr<Offer> offer = Offer::Parse(std::move(root.value()));
  ExpectEqualsValidOffer(offer.value());
  const Offer valid_offer = std::move(offer.value());

  Offer missing_audio_streams = valid_offer;
  missing_audio_streams.audio_streams.clear();
  EXPECT_TRUE(missing_audio_streams.ToJson().is_value());

  Offer missing_video_streams = valid_offer;
  missing_video_streams.audio_streams.clear();
  EXPECT_TRUE(missing_video_streams.ToJson().is_value());
}

TEST(OfferTest, ToJsonFailsWithInvalidStreams) {
  ErrorOr<Json::Value> root = json::Parse(kValidOffer);
  ASSERT_TRUE(root.is_value());
  ErrorOr<Offer> offer = Offer::Parse(std::move(root.value()));
  ExpectEqualsValidOffer(offer.value());
  const Offer valid_offer = std::move(offer.value());

  Offer video_stream_invalid = valid_offer;
  video_stream_invalid.video_streams[0].max_frame_rate.denominator = 0;
  EXPECT_TRUE(video_stream_invalid.ToJson().is_error());

  Offer audio_stream_invalid = valid_offer;
  video_stream_invalid.audio_streams[0].bit_rate = 0;
  EXPECT_TRUE(video_stream_invalid.ToJson().is_error());
}

TEST(OfferTest, FailsIfUnencrypted) {
  // Video stream missing AES fields.
  ExpectFailureOnParse(R"({
    "castMode": "mirroring",
    "supportedStreams": [{
      "index": 2,
      "type": "video_source",
      "codecName": "vp8",
      "rtpProfile": "cast",
      "rtpPayloadType": 100,
      "ssrc": 19088743,
      "timeBase": "1/48000",
       "resolutions": [],
       "maxBitRate": 10000,
       "aesIvMask": "7f12a19be62a36c04ae4116caaeff6d1"
    }]
  })",
                       Error::Code::kUnencryptedOffer);

  ExpectFailureOnParse(R"({
    "castMode": "mirroring",
    "supportedStreams": [{
      "index": 2,
      "type": "video_source",
      "codecName": "vp8",
      "rtpProfile": "cast",
      "rtpPayloadType": 100,
      "ssrc": 19088743,
      "timeBase": "1/48000",
       "resolutions": [],
       "maxBitRate": 10000,
       "aesKey": "51027e4e2347cbcb49d57ef10177aebc"
    }]
  })",
                       Error::Code::kUnencryptedOffer);

  // Audio stream missing AES fields.
  ExpectFailureOnParse(R"({
    "castMode": "mirroring",
    "supportedStreams": [{
      "index": 2,
      "type": "audio_source",
      "codecName": "opus",
      "rtpProfile": "cast",
      "rtpPayloadType": 96,
      "ssrc": 19088743,
      "bitRate": 124000,
      "timeBase": "1/48000",
      "channels": 2,
      "aesIvMask": "7f12a19be62a36c04ae4116caaeff6d1"
    }]
  })",
                       Error::Code::kUnencryptedOffer);

  ExpectFailureOnParse(R"({
    "castMode": "mirroring",
    "supportedStreams": [{
      "index": 2,
      "type": "audio_source",
      "codecName": "opus",
      "rtpProfile": "cast",
      "rtpPayloadType": 96,
      "ssrc": 19088743,
      "bitRate": 124000,
      "timeBase": "1/48000",
      "channels": 2,
      "aesKey": "51027e4e2347cbcb49d57ef10177aebc"
    }]
  })",
                       Error::Code::kUnencryptedOffer);

  // And finally, fields provided but not properly formatted.
  ExpectFailureOnParse(R"({
    "castMode": "mirroring",
    "supportedStreams": [{
      "index": 2,
      "type": "audio_source",
      "codecName": "opus",
      "rtpProfile": "cast",
      "rtpPayloadType": 96,
      "ssrc": 19088743,
      "bitRate": 124000,
      "timeBase": "1/48000",
      "channels": 2,
      "aesKey": "51027e4e2347$bcb49d57ef10177aebc",
      "aesIvMask": "7f12a19be62a36c04ae4116caaeff6d1"
    }]
  })",
                       Error::Code::kUnencryptedOffer);
}

}  // namespace cast
}  // namespace openscreen