/*
 *
 * Copyright 2018 gRPC authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

#include <grpc/support/port_platform.h>

#include "src/core/lib/iomgr/resolve_address_custom.h"

#include <string.h>

#include <string>

#include "absl/strings/str_format.h"

#include <grpc/support/alloc.h>
#include <grpc/support/log.h>

#include "src/core/lib/address_utils/sockaddr_utils.h"
#include "src/core/lib/gpr/string.h"
#include "src/core/lib/gpr/useful.h"
#include "src/core/lib/gprpp/host_port.h"
#include "src/core/lib/iomgr/iomgr_custom.h"
#include "src/core/lib/iomgr/port.h"

struct grpc_custom_resolver {
  grpc_closure* on_done = nullptr;
  grpc_resolved_addresses** addresses = nullptr;
  std::string host;
  std::string port;
};

static grpc_custom_resolver_vtable* resolve_address_vtable = nullptr;

static int retry_named_port_failure(grpc_custom_resolver* r,
                                    grpc_resolved_addresses** res) {
  // This loop is copied from resolve_address_posix.c
  const char* svc[][2] = {{"http", "80"}, {"https", "443"}};
  for (size_t i = 0; i < GPR_ARRAY_SIZE(svc); i++) {
    if (r->port == svc[i][0]) {
      r->port = svc[i][1];
      if (res) {
        grpc_error_handle error = resolve_address_vtable->resolve(
            r->host.c_str(), r->port.c_str(), res);
        if (error != GRPC_ERROR_NONE) {
          GRPC_ERROR_UNREF(error);
          return 0;
        }
      } else {
        resolve_address_vtable->resolve_async(r, r->host.c_str(),
                                              r->port.c_str());
      }
      return 1;
    }
  }
  return 0;
}

void grpc_custom_resolve_callback(grpc_custom_resolver* r,
                                  grpc_resolved_addresses* result,
                                  grpc_error_handle error) {
  GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
  grpc_core::ApplicationCallbackExecCtx callback_exec_ctx;
  grpc_core::ExecCtx exec_ctx;
  if (error == GRPC_ERROR_NONE) {
    *r->addresses = result;
  } else if (retry_named_port_failure(r, nullptr)) {
    return;
  }
  if (r->on_done) {
    grpc_core::ExecCtx::Run(DEBUG_LOCATION, r->on_done, error);
  }
  delete r;
}

static grpc_error_handle try_split_host_port(const char* name,
                                             const char* default_port,
                                             std::string* host,
                                             std::string* port) {
  /* parse name, splitting it into host and port parts */
  grpc_core::SplitHostPort(name, host, port);
  if (host->empty()) {
    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
        absl::StrFormat("unparseable host:port: '%s'", name));
  }
  if (port->empty()) {
    // TODO(murgatroid99): add tests for this case
    if (default_port == nullptr) {
      return GRPC_ERROR_CREATE_FROM_CPP_STRING(
          absl::StrFormat("no port in name '%s'", name));
    }
    *port = default_port;
  }
  return GRPC_ERROR_NONE;
}

static grpc_error_handle blocking_resolve_address_impl(
    const char* name, const char* default_port,
    grpc_resolved_addresses** addresses) {
  GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();

  grpc_custom_resolver resolver;
  grpc_error_handle err =
      try_split_host_port(name, default_port, &resolver.host, &resolver.port);
  if (err != GRPC_ERROR_NONE) {
    return err;
  }

  /* Call getaddrinfo */
  grpc_resolved_addresses* addrs;
  grpc_core::ExecCtx* curr = grpc_core::ExecCtx::Get();
  grpc_core::ExecCtx::Set(nullptr);
  err = resolve_address_vtable->resolve(resolver.host.c_str(),
                                        resolver.port.c_str(), &addrs);
  if (err != GRPC_ERROR_NONE) {
    if (retry_named_port_failure(&resolver, &addrs)) {
      GRPC_ERROR_UNREF(err);
      err = GRPC_ERROR_NONE;
    }
  }
  grpc_core::ExecCtx::Set(curr);
  if (err == GRPC_ERROR_NONE) {
    *addresses = addrs;
  }
  return err;
}

static void resolve_address_impl(const char* name, const char* default_port,
                                 grpc_pollset_set* /*interested_parties*/,
                                 grpc_closure* on_done,
                                 grpc_resolved_addresses** addrs) {
  GRPC_CUSTOM_IOMGR_ASSERT_SAME_THREAD();
  std::string host;
  std::string port;
  grpc_error_handle err = try_split_host_port(name, default_port, &host, &port);
  if (err != GRPC_ERROR_NONE) {
    grpc_core::ExecCtx::Run(DEBUG_LOCATION, on_done, err);
    return;
  }
  grpc_custom_resolver* r = new grpc_custom_resolver();
  r->on_done = on_done;
  r->addresses = addrs;
  r->host = std::move(host);
  r->port = std::move(port);

  /* Call getaddrinfo */
  resolve_address_vtable->resolve_async(r, r->host.c_str(), r->port.c_str());
}

static grpc_address_resolver_vtable custom_resolver_vtable = {
    resolve_address_impl, blocking_resolve_address_impl};

void grpc_custom_resolver_init(grpc_custom_resolver_vtable* impl) {
  resolve_address_vtable = impl;
  grpc_set_resolver_impl(&custom_resolver_vtable);
}
