// Copyright 2019 The Fuchsia 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 "src/connectivity/network/mdns/service/config.h"

#include <lib/syslog/cpp/macros.h>

#include <sstream>

#include "src/connectivity/network/mdns/service/mdns_names.h"
#include "src/lib/json_parser/rapidjson_validation.h"

namespace mdns {
namespace {

const char kSchema[] = R"({
  "type": "object",
  "additionalProperties": false,
  "properties": {
    "port": {
      "type": "integer",
      "minimum": 1,
      "maximum": 65535
    },
    "v4_multicast_address": {
      "type": "string",
      "minLength": 7,
      "maxLength": 15
    },
    "v6_multicast_address": {
      "type": "string",
      "minLength": 4,
      "maxLength": 39
    },
    "perform_host_name_probe": {
      "type": "boolean"
    },
    "publications": {
      "type": "array",
      "items": {
        "type": "object",
        "additionalProperties": false,
        "properties": {
          "service": {
            "type": "string",
            "minLength": 8,
            "maxLength": 22
          },
          "instance": {
            "type": "string",
            "minLength": 1,
            "maxLength": 63
          },
          "port": {
            "type": "integer",
            "minimum": 1,
            "maximum": 65535
          },
          "text": {
            "type": "array",
            "items": {
              "type": "string",
              "maxLength": 255
            }
          },
          "perform_probe": {
            "type": "boolean"
          },
          "media": {
            "type": "string",
            "enum": ["wired", "wireless", "both"]
          }
        },
        "required": ["service","port"]
      }
    }
  }
})";

const char kPortKey[] = "port";
const char kV4MultcastAddressKey[] = "v4_multicast_address";
const char kV6MultcastAddressKey[] = "v6_multicast_address";
const char kPerformHostNameProbeKey[] = "perform_host_name_probe";
const char kPublicationsKey[] = "publications";
const char kServiceKey[] = "service";
const char kInstanceKey[] = "instance";
const char kTextKey[] = "text";
const char kPerformProbeKey[] = "perform_probe";
const char kMediaKey[] = "media";
const char kMediaValueWired[] = "wired";
const char kMediaValueWireless[] = "wireless";
const char kMediaValueBoth[] = "both";

}  // namespace

//  static
const char Config::kConfigDir[] = "/config/data";

void Config::ReadConfigFiles(const std::string& host_name, const std::string& config_dir) {
  FX_DCHECK(MdnsNames::IsValidHostName(host_name));

  auto schema_result = json_parser::InitSchema(kSchema);
  FX_CHECK(schema_result.is_ok()) << schema_result.error_value().ToString();
  auto schema = std::move(schema_result.value());
  // |ParseFromDirectory| treats a non-existent directory the same as an empty directory, which
  // is what we want.
  parser_.ParseFromDirectory(config_dir, [this, &schema, &host_name](rapidjson::Document document) {
    auto validation_result = json_parser::ValidateSchema(document, schema);
    if (validation_result.is_error()) {
      parser_.ReportError(validation_result.error_value());
      return;
    }

    IntegrateDocument(document, host_name);
  });
}

void Config::IntegrateDocument(const rapidjson::Document& document, const std::string& host_name) {
  FX_DCHECK(document.IsObject());

  if (document.HasMember(kPortKey)) {
    FX_DCHECK(document[kPortKey].IsUint());
    FX_DCHECK(document[kPortKey].GetUint() >= 1);
    FX_DCHECK(document[kPortKey].GetUint() <= 65535);
    addresses_.SetPort(inet::IpPort::From_uint16_t(document[kPortKey].GetUint()));
  }

  if (document.HasMember(kV4MultcastAddressKey)) {
    FX_DCHECK(document[kV4MultcastAddressKey].IsString());
    auto address =
        inet::IpAddress::FromString(document[kV4MultcastAddressKey].GetString(), AF_INET);
    if (!address.is_valid()) {
      parser_.ReportError((std::stringstream() << kV4MultcastAddressKey << " value "
                                               << document[kV4MultcastAddressKey].GetString()
                                               << " is not a valid IPV4 address.")
                              .str());
      return;
    }

    addresses_.SetMulticastAddress(address);
  }

  if (document.HasMember(kV6MultcastAddressKey)) {
    FX_DCHECK(document[kV6MultcastAddressKey].IsString());
    auto address =
        inet::IpAddress::FromString(document[kV6MultcastAddressKey].GetString(), AF_INET6);
    if (!address.is_valid()) {
      parser_.ReportError((std::stringstream() << kV6MultcastAddressKey << " value "
                                               << document[kV6MultcastAddressKey].GetString()
                                               << " is not a valid IPV6 address.")
                              .str());
      return;
    }

    addresses_.SetMulticastAddress(address);
  }

  if (document.HasMember(kPerformHostNameProbeKey)) {
    FX_DCHECK(document[kPerformHostNameProbeKey].IsBool());
    SetPerformHostNameProbe(document[kPerformHostNameProbeKey].GetBool());
    if (parser_.HasError()) {
      return;
    }
  }

  if (document.HasMember(kPublicationsKey)) {
    FX_DCHECK(document[kPublicationsKey].IsArray());
    for (auto& item : document[kPublicationsKey].GetArray()) {
      IntegratePublication(item, host_name);
      if (parser_.HasError()) {
        return;
      }
    }
  }
}

void Config::IntegratePublication(const rapidjson::Value& value, const std::string& host_name) {
  FX_DCHECK(value.IsObject());
  FX_DCHECK(value.HasMember(kServiceKey));
  FX_DCHECK(value[kServiceKey].IsString());
  FX_DCHECK(value.HasMember(kPortKey));
  FX_DCHECK(value[kPortKey].IsUint());
  FX_DCHECK(value[kPortKey].GetUint() >= 1);
  FX_DCHECK(value[kPortKey].GetUint() <= 65535);

  auto service = value[kServiceKey].GetString();
  if (!MdnsNames::IsValidServiceName(service)) {
    parser_.ReportError((std::stringstream()
                         << kServiceKey << " value " << service << " is not a valid service name.")
                            .str());
    return;
  }

  std::string instance;
  if (value.HasMember(kInstanceKey)) {
    instance = value[kInstanceKey].GetString();
    if (!MdnsNames::IsValidInstanceName(instance)) {
      parser_.ReportError((std::stringstream() << kInstanceKey << " value " << instance
                                               << " is not a valid instance name.")
                              .str());
      return;
    }
  } else {
    instance = host_name;
    if (!MdnsNames::IsValidInstanceName(instance)) {
      parser_.ReportError((std::stringstream() << "Publication of service " << service
                                               << " specifies that the host name should be "
                                                  "used as the instance name, but "
                                               << host_name << "is not a valid instance name.")
                              .str());
      return;
    }
  }

  std::vector<std::string> text;
  if (value.HasMember(kTextKey)) {
    FX_DCHECK(value[kTextKey].IsArray());
    for (auto& item : value[kTextKey].GetArray()) {
      FX_DCHECK(item.IsString());
      if (!MdnsNames::IsValidTextString(item.GetString())) {
        parser_.ReportError((std::stringstream() << kTextKey << " item value " << item.GetString()
                                                 << " is not avalid text string.")
                                .str());
        return;
      }

      text.push_back(item.GetString());
    }
  }

  bool perform_probe = true;
  if (value.HasMember(kPerformProbeKey)) {
    FX_DCHECK(value[kPerformProbeKey].IsBool());
    perform_probe = value[kPerformProbeKey].GetBool();
  }

  Media media = Media::kBoth;
  if (value.HasMember(kMediaKey)) {
    FX_DCHECK(value[kMediaKey].IsString());
    std::string media_string = value[kMediaKey].GetString();
    if (media_string == kMediaValueWired) {
      media = Media::kWired;
    } else if (media_string == kMediaValueWireless) {
      media = Media::kWireless;
    } else {
      FX_DCHECK(media_string == kMediaValueBoth);
    }
  }

  publications_.emplace_back(Publication{
      .service_ = service,
      .instance_ = instance,
      .publication_ =
          Mdns::Publication::Create(inet::IpPort::From_uint16_t(value[kPortKey].GetUint()), text),
      .perform_probe_ = perform_probe,
      .media_ = media});
}

void Config::SetPerformHostNameProbe(bool perform_host_name_probe) {
  if (perform_host_name_probe_.has_value() &&
      perform_host_name_probe_.value() != perform_host_name_probe) {
    parser_.ReportError(
        (std::stringstream() << "Conflicting " << kPerformHostNameProbeKey << " value.").str());
    return;
  }

  perform_host_name_probe_ = perform_host_name_probe;
}

}  // namespace mdns