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

#include "fuchsia_web/webengine/browser/url_request_rewrite_type_converters.h"

#include "base/strings/strcat.h"
#include "base/strings/string_piece.h"
#include "base/strings/string_util.h"
#include "fuchsia_web/common/string_util.h"
#include "net/base/url_util.h"

namespace {

std::string NormalizeHost(base::StringPiece host) {
  return GURL(base::StrCat({url::kHttpScheme, "://", host})).host();
}

}  // namespace

namespace mojo {

template <>
struct TypeConverter<url_rewrite::mojom::UrlRequestRewriteAddHeadersPtr,
                     fuchsia::web::UrlRequestRewriteAddHeaders> {
  static url_rewrite::mojom::UrlRequestRewriteAddHeadersPtr Convert(
      const fuchsia::web::UrlRequestRewriteAddHeaders& input) {
    url_rewrite::mojom::UrlRequestRewriteAddHeadersPtr add_headers =
        url_rewrite::mojom::UrlRequestRewriteAddHeaders::New();
    if (input.has_headers()) {
      for (const auto& header : input.headers()) {
        base::StringPiece header_name = BytesAsString(header.name);
        base::StringPiece header_value = BytesAsString(header.value);
        url_rewrite::mojom::UrlHeaderPtr url_header =
            url_rewrite::mojom::UrlHeader::New(std::string(header_name),
                                               std::string(header_value));
        add_headers->headers.push_back(std::move(url_header));
      }
    }
    return add_headers;
  }
};

template <>
struct TypeConverter<url_rewrite::mojom::UrlRequestRewriteRemoveHeaderPtr,
                     fuchsia::web::UrlRequestRewriteRemoveHeader> {
  static url_rewrite::mojom::UrlRequestRewriteRemoveHeaderPtr Convert(
      const fuchsia::web::UrlRequestRewriteRemoveHeader& input) {
    url_rewrite::mojom::UrlRequestRewriteRemoveHeaderPtr remove_header =
        url_rewrite::mojom::UrlRequestRewriteRemoveHeader::New();
    if (input.has_query_pattern())
      remove_header->query_pattern = absl::make_optional(input.query_pattern());
    if (input.has_header_name()) {
      remove_header->header_name =
          std::string(BytesAsString(input.header_name()));
    }
    return remove_header;
  }
};

template <>
struct TypeConverter<
    url_rewrite::mojom::UrlRequestRewriteSubstituteQueryPatternPtr,
    fuchsia::web::UrlRequestRewriteSubstituteQueryPattern> {
  static url_rewrite::mojom::UrlRequestRewriteSubstituteQueryPatternPtr Convert(
      const fuchsia::web::UrlRequestRewriteSubstituteQueryPattern& input) {
    url_rewrite::mojom::UrlRequestRewriteSubstituteQueryPatternPtr
        substitute_query_pattern =
            url_rewrite::mojom::UrlRequestRewriteSubstituteQueryPattern::New();
    if (input.has_pattern())
      substitute_query_pattern->pattern = input.pattern();
    if (input.has_substitution())
      substitute_query_pattern->substitution = input.substitution();
    return substitute_query_pattern;
  }
};

template <>
struct TypeConverter<url_rewrite::mojom::UrlRequestRewriteReplaceUrlPtr,
                     fuchsia::web::UrlRequestRewriteReplaceUrl> {
  static url_rewrite::mojom::UrlRequestRewriteReplaceUrlPtr Convert(
      const fuchsia::web::UrlRequestRewriteReplaceUrl& input) {
    url_rewrite::mojom::UrlRequestRewriteReplaceUrlPtr replace_url =
        url_rewrite::mojom::UrlRequestRewriteReplaceUrl::New();
    if (input.has_url_ends_with())
      replace_url->url_ends_with = input.url_ends_with();
    if (input.has_new_url())
      replace_url->new_url = GURL(input.new_url());
    return replace_url;
  }
};

template <>
struct TypeConverter<url_rewrite::mojom::UrlRequestRewriteAppendToQueryPtr,
                     fuchsia::web::UrlRequestRewriteAppendToQuery> {
  static url_rewrite::mojom::UrlRequestRewriteAppendToQueryPtr Convert(
      const fuchsia::web::UrlRequestRewriteAppendToQuery& input) {
    url_rewrite::mojom::UrlRequestRewriteAppendToQueryPtr append_to_query =
        url_rewrite::mojom::UrlRequestRewriteAppendToQuery::New();
    if (input.has_query())
      append_to_query->query = input.query();
    return append_to_query;
  }
};

template <>
struct TypeConverter<url_rewrite::mojom::UrlRequestAccessPolicy,
                     fuchsia::web::UrlRequestAction> {
  static url_rewrite::mojom::UrlRequestAccessPolicy Convert(
      const fuchsia::web::UrlRequestAction& input) {
    switch (input) {
      case fuchsia::web::UrlRequestAction::ALLOW:
        return url_rewrite::mojom::UrlRequestAccessPolicy::kAllow;
      case fuchsia::web::UrlRequestAction::DENY:
        return url_rewrite::mojom::UrlRequestAccessPolicy::kDeny;
    }
  }
};

template <>
struct TypeConverter<url_rewrite::mojom::UrlRequestActionPtr,
                     fuchsia::web::UrlRequestRewrite> {
  static url_rewrite::mojom::UrlRequestActionPtr Convert(
      const fuchsia::web::UrlRequestRewrite& input) {
    switch (input.Which()) {
      case fuchsia::web::UrlRequestRewrite::Tag::kAddHeaders:
        return url_rewrite::mojom::UrlRequestAction::NewAddHeaders(
            mojo::ConvertTo<url_rewrite::mojom::UrlRequestRewriteAddHeadersPtr>(
                input.add_headers()));
      case fuchsia::web::UrlRequestRewrite::Tag::kRemoveHeader:
        return url_rewrite::mojom::UrlRequestAction::NewRemoveHeader(
            mojo::ConvertTo<
                url_rewrite::mojom::UrlRequestRewriteRemoveHeaderPtr>(
                input.remove_header()));
      case fuchsia::web::UrlRequestRewrite::Tag::kSubstituteQueryPattern:
        return url_rewrite::mojom::UrlRequestAction::NewSubstituteQueryPattern(
            mojo::ConvertTo<
                url_rewrite::mojom::UrlRequestRewriteSubstituteQueryPatternPtr>(
                input.substitute_query_pattern()));
      case fuchsia::web::UrlRequestRewrite::Tag::kReplaceUrl:
        return url_rewrite::mojom::UrlRequestAction::NewReplaceUrl(
            mojo::ConvertTo<url_rewrite::mojom::UrlRequestRewriteReplaceUrlPtr>(
                input.replace_url()));
      case fuchsia::web::UrlRequestRewrite::Tag::kAppendToQuery:
        return url_rewrite::mojom::UrlRequestAction::NewAppendToQuery(
            mojo::ConvertTo<
                url_rewrite::mojom::UrlRequestRewriteAppendToQueryPtr>(
                input.append_to_query()));
      default:
        return nullptr;
    }
  }
};

template <>
struct TypeConverter<url_rewrite::mojom::UrlRequestRulePtr,
                     fuchsia::web::UrlRequestRewriteRule> {
  static url_rewrite::mojom::UrlRequestRulePtr Convert(
      const fuchsia::web::UrlRequestRewriteRule& input) {
    url_rewrite::mojom::UrlRequestRulePtr rule =
        url_rewrite::mojom::UrlRequestRule::New();

    if (input.has_hosts_filter()) {
      // Convert host names in case they contain non-ASCII characters.
      const base::StringPiece kWildcard("*.");

      std::vector<std::string> hosts;
      for (const base::StringPiece host : input.hosts_filter()) {
        if (base::StartsWith(host, kWildcard, base::CompareCase::SENSITIVE)) {
          hosts.push_back(
              base::StrCat({kWildcard, NormalizeHost(host.substr(2))}));
        } else {
          hosts.push_back(NormalizeHost(host));
        }
      }
      rule->hosts_filter = std::move(hosts);
    }

    if (input.has_schemes_filter())
      rule->schemes_filter = absl::make_optional(input.schemes_filter());

    if (input.has_rewrites()) {
      rule->actions =
          mojo::ConvertTo<std::vector<url_rewrite::mojom::UrlRequestActionPtr>>(
              input.rewrites());
    } else if (input.has_action()) {
      rule->actions = std::vector<url_rewrite::mojom::UrlRequestActionPtr>();
      rule->actions.push_back(url_rewrite::mojom::UrlRequestAction::NewPolicy(
          mojo::ConvertTo<url_rewrite::mojom::UrlRequestAccessPolicy>(
              input.action())));
    }

    return rule;
  }
};

url_rewrite::mojom::UrlRequestRewriteRulesPtr
TypeConverter<url_rewrite::mojom::UrlRequestRewriteRulesPtr,
              std::vector<fuchsia::web::UrlRequestRewriteRule>>::
    Convert(const std::vector<fuchsia::web::UrlRequestRewriteRule>& input) {
  url_rewrite::mojom::UrlRequestRewriteRulesPtr rules =
      url_rewrite::mojom::UrlRequestRewriteRules::New();
  for (const auto& rule : input) {
    rules->rules.push_back(
        mojo::ConvertTo<url_rewrite::mojom::UrlRequestRulePtr>(rule));
  }
  return rules;
}

}  // namespace mojo