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

#include "chrome/browser/ash/floating_sso/cookie_sync_conversions.h"

#include <memory>
#include <optional>
#include <string>
#include <tuple>
#include <utility>

#include "base/strings/strcat.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/to_string.h"
#include "base/time/time.h"
#include "base/types/expected.h"
#include "components/sync/protocol/cookie_specifics.pb.h"
#include "net/cookies/canonical_cookie.h"
#include "net/cookies/cookie_constants.h"
#include "net/cookies/cookie_partition_key.h"
#include "net/cookies/unique_cookie_key.h"

namespace ash::floating_sso {

namespace {

base::Time DeserializeTime(int64_t proto_time) {
  return base::Time::FromDeltaSinceWindowsEpoch(base::Microseconds(proto_time));
}

net::CookieSameSite CookieSameSiteFromProtoEnum(
    const sync_pb::CookieSpecifics_CookieSameSite& proto_enum) {
  switch (proto_enum) {
    case sync_pb::CookieSpecifics_CookieSameSite_UNSPECIFIED:
      return net::CookieSameSite::UNSPECIFIED;
    case sync_pb::CookieSpecifics_CookieSameSite_NO_RESTRICTION:
      return net::CookieSameSite::NO_RESTRICTION;
    case sync_pb::CookieSpecifics_CookieSameSite_LAX_MODE:
      return net::CookieSameSite::LAX_MODE;
    case sync_pb::CookieSpecifics_CookieSameSite_STRICT_MODE:
      return net::CookieSameSite::STRICT_MODE;
  }
}

sync_pb::CookieSpecifics_CookieSameSite ProtoEnumFromCookieSameSite(
    const net::CookieSameSite& same_site) {
  switch (same_site) {
    case net::CookieSameSite::UNSPECIFIED:
      return sync_pb::CookieSpecifics_CookieSameSite_UNSPECIFIED;
    case net::CookieSameSite::NO_RESTRICTION:
      return sync_pb::CookieSpecifics_CookieSameSite_NO_RESTRICTION;
    case net::CookieSameSite::LAX_MODE:
      return sync_pb::CookieSpecifics_CookieSameSite_LAX_MODE;
    case net::CookieSameSite::STRICT_MODE:
      return sync_pb::CookieSpecifics_CookieSameSite_STRICT_MODE;
  }
}

net::CookiePriority CookiePriorityFromProtoEnum(
    const sync_pb::CookieSpecifics_CookiePriority& proto_enum) {
  switch (proto_enum) {
    case sync_pb::CookieSpecifics_CookiePriority_UNSPECIFIED_PRIORITY:
      return net::CookiePriority::COOKIE_PRIORITY_DEFAULT;
    case sync_pb::CookieSpecifics_CookiePriority_LOW:
      return net::CookiePriority::COOKIE_PRIORITY_LOW;
    case sync_pb::CookieSpecifics_CookiePriority_MEDIUM:
      return net::CookiePriority::COOKIE_PRIORITY_MEDIUM;
    case sync_pb::CookieSpecifics_CookiePriority_HIGH:
      return net::CookiePriority::COOKIE_PRIORITY_HIGH;
  }
}

sync_pb::CookieSpecifics_CookiePriority ProtoEnumFromCookiePriority(
    const net::CookiePriority& priority) {
  switch (priority) {
    case net::CookiePriority::COOKIE_PRIORITY_LOW:
      return sync_pb::CookieSpecifics_CookiePriority_LOW;
    case net::CookiePriority::COOKIE_PRIORITY_MEDIUM:
      return sync_pb::CookieSpecifics_CookiePriority_MEDIUM;
    case net::CookiePriority::COOKIE_PRIORITY_HIGH:
      return sync_pb::CookieSpecifics_CookiePriority_HIGH;
  }
}

net::CookieSourceScheme CookieSourceSchemeFromProtoEnum(
    const sync_pb::CookieSpecifics_CookieSourceScheme& proto_enum) {
  switch (proto_enum) {
    case sync_pb::CookieSpecifics_CookieSourceScheme_UNSET:
      return net::CookieSourceScheme::kUnset;
    case sync_pb::CookieSpecifics_CookieSourceScheme_NON_SECURE:
      return net::CookieSourceScheme::kNonSecure;
    case sync_pb::CookieSpecifics_CookieSourceScheme_SECURE:
      return net::CookieSourceScheme::kSecure;
  }
}

sync_pb::CookieSpecifics_CookieSourceScheme ProtoEnumFromCookieSourceScheme(
    const net::CookieSourceScheme& source_scheme) {
  switch (source_scheme) {
    case net::CookieSourceScheme::kUnset:
      return sync_pb::CookieSpecifics_CookieSourceScheme_UNSET;
    case net::CookieSourceScheme::kNonSecure:
      return sync_pb::CookieSpecifics_CookieSourceScheme_NON_SECURE;
    case net::CookieSourceScheme::kSecure:
      return sync_pb::CookieSpecifics_CookieSourceScheme_SECURE;
  }
}

net::CookieSourceType CookieSourceTypeFromProtoEnum(
    const sync_pb::CookieSpecifics_CookieSourceType& proto_enum) {
  switch (proto_enum) {
    case sync_pb::CookieSpecifics_CookieSourceType_UNKNOWN:
      return net::CookieSourceType::kUnknown;
    case sync_pb::CookieSpecifics_CookieSourceType_HTTP:
      return net::CookieSourceType::kHTTP;
    case sync_pb::CookieSpecifics_CookieSourceType_SCRIPT:
      return net::CookieSourceType::kScript;
    case sync_pb::CookieSpecifics_CookieSourceType_OTHER:
      return net::CookieSourceType::kOther;
  }
}

sync_pb::CookieSpecifics_CookieSourceType ProtoEnumFromCookieSourceType(
    const net::CookieSourceType& source_type) {
  switch (source_type) {
    case net::CookieSourceType::kUnknown:
      return sync_pb::CookieSpecifics_CookieSourceType_UNKNOWN;
    case net::CookieSourceType::kHTTP:
      return sync_pb::CookieSpecifics_CookieSourceType_HTTP;
    case net::CookieSourceType::kScript:
      return sync_pb::CookieSpecifics_CookieSourceType_SCRIPT;
    case net::CookieSourceType::kOther:
      return sync_pb::CookieSpecifics_CookieSourceType_OTHER;
  }
}

}  // namespace

int64_t ToMicrosSinceWindowsEpoch(const base::Time& t) {
  return t.ToDeltaSinceWindowsEpoch().InMicroseconds();
}

std::unique_ptr<net::CanonicalCookie> FromSyncProto(
    const sync_pb::CookieSpecifics& proto) {
  base::expected<std::optional<net::CookiePartitionKey>, std::string>
      partition_key = net::CookiePartitionKey::FromStorage(
          proto.partition_key().top_level_site(),
          proto.partition_key().has_cross_site_ancestor());
  if (!partition_key.has_value()) {
    return nullptr;
  }

  // Returns nullptr if the resulting cookie is not canonical.
  // ATTENTION: If you change this code after changing something in
  // `CanonicalCookie`, make sure that the changes are fully reflected in
  // components/sync/protocol/cookie_specifics.proto and in `ToSyncProto`
  // function below.
  std::unique_ptr<net::CanonicalCookie> cookie =
      net::CanonicalCookie::FromStorage(
          proto.name(),                                                    //
          proto.value(),                                                   //
          proto.domain(),                                                  //
          proto.path(),                                                    //
          DeserializeTime(proto.creation_time_windows_epoch_micros()),     //
          DeserializeTime(proto.expiry_time_windows_epoch_micros()),       //
          DeserializeTime(proto.last_access_time_windows_epoch_micros()),  //
          DeserializeTime(proto.last_update_time_windows_epoch_micros()),  //
          proto.secure(),                                                  //
          proto.httponly(),                                                //
          CookieSameSiteFromProtoEnum(proto.site_restrictions()),          //
          CookiePriorityFromProtoEnum(proto.priority()),                   //
          std::move(partition_key.value()),                                //
          CookieSourceSchemeFromProtoEnum(proto.source_scheme()),          //
          proto.source_port(),                                             //
          CookieSourceTypeFromProtoEnum(proto.source_type()));             //

  return cookie;
}

std::optional<std::string> SerializedKey(const net::CanonicalCookie& cookie) {
  base::expected<net::CookiePartitionKey::SerializedCookiePartitionKey,
                 std::string>
      serialized_partition_key =
          net::CookiePartitionKey::Serialize(cookie.PartitionKey());
  if (!serialized_partition_key.has_value()) {
    return std::nullopt;
  }

  const net::UniqueCookieKey strict_unique_key = cookie.StrictlyUniqueKey();
  const std::string& name = strict_unique_key.name();
  const std::string& domain = strict_unique_key.domain();
  const std::string& path = strict_unique_key.path();
  // `source_scheme()` and `port()` are guaranteed to return non-nullopt values,
  // since we created the key via StrictlyUniqueKey.
  const net::CookieSourceScheme source_scheme =
      strict_unique_key.source_scheme().value();
  const int source_port = strict_unique_key.port().value();

  // We just concatenate all involved strings.
  std::string serialized_key = base::StrCat(
      {serialized_partition_key->TopLevelSite(),
       base::ToString(serialized_partition_key->has_cross_site_ancestor()),
       name, domain, path,
       base::NumberToString(static_cast<int>(source_scheme)),
       base::NumberToString(source_port)});
  return serialized_key;
}

std::optional<sync_pb::CookieSpecifics> ToSyncProto(
    const net::CanonicalCookie& cookie) {
  base::expected<net::CookiePartitionKey::SerializedCookiePartitionKey,
                 std::string>
      serialized_partition_key =
          net::CookiePartitionKey::Serialize(cookie.PartitionKey());
  if (!serialized_partition_key.has_value()) {
    return std::nullopt;
  }

  std::optional<std::string> serialized_key = SerializedKey(cookie);
  // The only way for this to not have value is when partition key can't
  // be serialized, but we already handled it above.
  CHECK(serialized_key.has_value());

  sync_pb::CookieSpecifics proto;
  proto.set_unique_key(serialized_key.value());
  proto.set_name(cookie.Name());
  proto.set_value(cookie.Value());
  proto.set_domain(cookie.Domain());
  proto.set_path(cookie.Path());
  proto.set_creation_time_windows_epoch_micros(
      ToMicrosSinceWindowsEpoch(cookie.CreationDate()));
  proto.set_expiry_time_windows_epoch_micros(
      ToMicrosSinceWindowsEpoch(cookie.ExpiryDate()));
  proto.set_last_access_time_windows_epoch_micros(
      ToMicrosSinceWindowsEpoch(cookie.LastAccessDate()));
  proto.set_last_update_time_windows_epoch_micros(
      ToMicrosSinceWindowsEpoch(cookie.LastUpdateDate()));
  proto.set_secure(cookie.IsSecure());
  proto.set_httponly(cookie.IsHttpOnly());
  proto.set_site_restrictions(ProtoEnumFromCookieSameSite(cookie.SameSite()));
  proto.set_priority(ProtoEnumFromCookiePriority(cookie.Priority()));
  proto.set_source_scheme(
      ProtoEnumFromCookieSourceScheme(cookie.SourceScheme()));
  proto.mutable_partition_key()->set_top_level_site(
      serialized_partition_key->TopLevelSite());
  proto.mutable_partition_key()->set_has_cross_site_ancestor(
      serialized_partition_key->has_cross_site_ancestor());
  proto.set_source_port(cookie.SourcePort());
  proto.set_source_type(ProtoEnumFromCookieSourceType(cookie.SourceType()));

  return proto;
}

}  // namespace ash::floating_sso