/*
 *
 * Copyright (C) 2023 The Android Open Source Project
 *
 * 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 <android-base/strings.h>
#include <assert.h>
#include <gflags/gflags.h>
#include <grpcpp/ext/proto_server_reflection_plugin.h>
#include <grpcpp/grpcpp.h>
#include <grpcpp/health_check_service_interface.h>
#include <sys/msg.h>
#include <unistd.h>

#include <algorithm>
#include <array>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <memory>
#include <string>

#include "wmediumd.grpc.pb.h"
#include "wmediumd/api.h"
#include "wmediumd/grpc.h"
#include "wmediumd/wmediumd.h"

using google::protobuf::Empty;
using grpc::Server;
using grpc::ServerBuilder;
using grpc::ServerContext;
using grpc::Status;
using grpc::StatusCode;
using wmediumdserver::ListStationsResponse;
using wmediumdserver::LoadConfigRequest;
using wmediumdserver::SetCiviclocRequest;
using wmediumdserver::SetLciRequest;
using wmediumdserver::SetPositionRequest;
using wmediumdserver::SetSnrRequest;
using wmediumdserver::SetTxpowerRequest;
using wmediumdserver::StartPcapRequest;
using wmediumdserver::WmediumdService;

#define MAC_ADDR_LEN 6
#define STR_MAC_ADDR_LEN 17

static std::atomic<long> msg_type_response_increment{MSG_TYPE_RESPONSE_BASE};

template <class T>
static void AppendBinaryRepresentation(std::string& buf, const T& data) {
  std::copy(reinterpret_cast<const char*>(&data),
            reinterpret_cast<const char*>(&data) + sizeof(T),
            std::back_inserter(buf));
}

bool IsValidMacAddr(const std::string& mac_address) {
  if (mac_address.size() != STR_MAC_ADDR_LEN) {
    return false;
  }

  if (mac_address[2] != ':' || mac_address[5] != ':' || mac_address[8] != ':' ||
      mac_address[11] != ':' || mac_address[14] != ':') {
    return false;
  }

  for (int i = 0; i < STR_MAC_ADDR_LEN; ++i) {
    if ((i - 2) % 3 == 0) continue;
    char c = mac_address[i];

    if (isupper(c)) {
      c = tolower(c);
    }

    if ((c < '0' || c > '9') && (c < 'a' || c > 'f')) return false;
  }

  return true;
}

static std::array<uint8_t, 6> ParseMacAddress(const std::string& mac_address) {
  auto split_mac = android::base::Split(mac_address, ":");
  std::array<uint8_t, 6> mac;
  for (int i = 0; i < 6; i++) {
    char* end_ptr;
    mac[i] = (uint8_t)strtol(split_mac[i].c_str(), &end_ptr, 16);
  }

  return mac;
}

std::string MacToString(const char* mac_address) {
  char ret[STR_MAC_ADDR_LEN + 1];
  sprintf(ret, MAC_FMT, MAC_ARGS(mac_address));
  return ret;
}

class WmediumdServiceImpl final : public WmediumdService::Service {
 public:
  WmediumdServiceImpl(int event_fd, int msq_id)
      : event_fd_(event_fd), msq_id_(msq_id) {}

  Status ListStations(ServerContext* context, const Empty* request,
                      ListStationsResponse* response) override {
    struct wmediumd_grpc_response_message response_message;
    SendAndReceiveGrpcMessage(REQUEST_LIST_STATIONS, &response_message);
    if (response_message.data_type != RESPONSE_ACK_LIST_STATIONS) {
      return Status(StatusCode::FAILED_PRECONDITION,
                    "Failed to execute ListStations");
    }
    if (response_message.data_size < sizeof(struct wmediumd_station_infos)) {
      return Status(StatusCode::FAILED_PRECONDITION,
                    "Invalid size of wmediumd_station_infos");
    }

    // Construct response message
    const auto* response_data_payload =
        reinterpret_cast<const wmediumd_station_infos*>(
            &response_message.data_payload);
    response->set_station_count(response_data_payload->count);
    for (uint32_t i = 0; i < response_data_payload->count; ++i) {
      const auto* station = reinterpret_cast<const wmediumd_station_info*>(
          &response_data_payload->stations[i]);
      auto* response_station = response->add_stations();
      response_station->set_mac_address(MacToString(station->addr));
      response_station->set_mac_hw_address(MacToString(station->hwaddr));
      response_station->set_x_pos(station->x);
      response_station->set_y_pos(station->y);
      response_station->set_tx_power(station->tx_power);
      response_station->set_lci((char*)station + station->lci_offset);
      response_station->set_civicloc((char*)station + station->civicloc_offset);
    }
    return Status::OK;
  }

  Status LoadConfig(ServerContext* context, const LoadConfigRequest* request,
                    Empty* reply) override {
    // Construct request payload
    ssize_t size =
        sizeof(struct wmediumd_load_config) + (request->path().length() + 1);
    struct wmediumd_load_config* request_data_payload =
        (struct wmediumd_load_config*)malloc(size);
    strcpy(request_data_payload->config_path, request->path().c_str());

    struct wmediumd_grpc_response_message response_message;
    SendAndReceiveGrpcMessage(REQUEST_LOAD_CONFIG, size, request_data_payload,
                              &response_message);
    free(request_data_payload);
    if (response_message.data_type != RESPONSE_ACK) {
      return Status(StatusCode::FAILED_PRECONDITION,
                    "Failed to execute LoadConfig");
    }
    return Status::OK;
  }

  Status ReloadConfig(ServerContext* context, const Empty* request,
                      Empty* reply) override {
    struct wmediumd_grpc_response_message response_message;
    SendAndReceiveGrpcMessage(REQUEST_RELOAD_CONFIG, &response_message);
    if (response_message.data_type != RESPONSE_ACK) {
      return Status(StatusCode::FAILED_PRECONDITION,
                    "Failed to execute ReloadConfig");
    }
    return Status::OK;
  }

  Status SetCivicloc(ServerContext* context, const SetCiviclocRequest* request,
                     Empty* reply) override {
    // Validate parameters
    if (!IsValidMacAddr(request->mac_address())) {
      return Status(StatusCode::INVALID_ARGUMENT, "Got invalid mac address");
    }
    auto mac = ParseMacAddress(request->mac_address());

    // Construct request payload
    ssize_t size = sizeof(struct wmediumd_set_civicloc) +
                   (request->civicloc().length() + 1);
    struct wmediumd_set_civicloc* request_data_payload =
        (struct wmediumd_set_civicloc*)malloc(size);
    memcpy(request_data_payload->mac, &mac, sizeof(mac));
    strcpy(request_data_payload->civicloc, request->civicloc().c_str());

    struct wmediumd_grpc_response_message response_message;
    SendAndReceiveGrpcMessage(REQUEST_SET_CIVICLOC, size, request_data_payload,
                              &response_message);
    free(request_data_payload);
    if (response_message.data_type != RESPONSE_ACK) {
      return Status(StatusCode::FAILED_PRECONDITION,
                    "Failed to execute SetCivicloc");
    }
    return Status::OK;
  }

  Status SetLci(ServerContext* context, const SetLciRequest* request,
                Empty* reply) override {
    // Validate parameters
    if (!IsValidMacAddr(request->mac_address())) {
      return Status(StatusCode::INVALID_ARGUMENT, "Got invalid mac address");
    }
    auto mac = ParseMacAddress(request->mac_address());

    // Construct request payload
    ssize_t size =
        sizeof(struct wmediumd_set_lci) + (request->lci().length() + 1);
    struct wmediumd_set_lci* request_data_payload =
        (struct wmediumd_set_lci*)malloc(size);
    memcpy(request_data_payload->mac, &mac, sizeof(mac));
    strcpy(request_data_payload->lci, request->lci().c_str());

    struct wmediumd_grpc_response_message response_message;
    SendAndReceiveGrpcMessage(REQUEST_SET_LCI, size, request_data_payload,
                              &response_message);
    free(request_data_payload);
    if (response_message.data_type != RESPONSE_ACK) {
      return Status(StatusCode::FAILED_PRECONDITION,
                    "Failed to execute SetLci");
    }
    return Status::OK;
  }

  Status SetPosition(ServerContext* context, const SetPositionRequest* request,
                     Empty* reply) override {
    // Validate parameters
    if (!IsValidMacAddr(request->mac_address())) {
      return Status(StatusCode::INVALID_ARGUMENT, "Got invalid mac address");
    }
    auto mac = ParseMacAddress(request->mac_address());

    // Construct request payload
    struct wmediumd_set_position request_data_payload;
    memcpy(request_data_payload.mac, &mac, sizeof(mac));
    request_data_payload.x = request->x_pos();
    request_data_payload.y = request->y_pos();

    struct wmediumd_grpc_response_message response_message;
    SendAndReceiveGrpcMessage(REQUEST_SET_POSITION,
                              sizeof(request_data_payload),
                              &request_data_payload, &response_message);
    if (response_message.data_type != RESPONSE_ACK) {
      return Status(StatusCode::FAILED_PRECONDITION,
                    "Failed to execute SetPosition");
    }
    return Status::OK;
  }

  Status SetSnr(ServerContext* context, const SetSnrRequest* request,
                Empty* reply) override {
    // Validate parameters
    if (!IsValidMacAddr(request->mac_address_1()) ||
        !IsValidMacAddr(request->mac_address_2())) {
      return Status(StatusCode::INVALID_ARGUMENT, "Got invalid mac address");
    }
    auto mac_1 = ParseMacAddress(request->mac_address_1());
    auto mac_2 = ParseMacAddress(request->mac_address_2());

    // Construct request payload
    struct wmediumd_set_snr request_data_payload;
    memcpy(request_data_payload.node1_mac, &mac_1, sizeof(mac_1));
    memcpy(request_data_payload.node2_mac, &mac_2, sizeof(mac_2));
    request_data_payload.snr = request->snr();

    struct wmediumd_grpc_response_message response_message;
    SendAndReceiveGrpcMessage(REQUEST_SET_SNR, sizeof(request_data_payload),
                              &request_data_payload, &response_message);
    if (response_message.data_type != RESPONSE_ACK) {
      return Status(StatusCode::FAILED_PRECONDITION,
                    "Failed to execute SetSnr");
    }
    return Status::OK;
  }

  Status SetTxpower(ServerContext* context, const SetTxpowerRequest* request,
                    Empty* reply) override {
    // Validate parameters
    if (!IsValidMacAddr(request->mac_address())) {
      return Status(StatusCode::INVALID_ARGUMENT, "Got invalid mac address");
    }
    auto mac = ParseMacAddress(request->mac_address());

    // Construct request payload
    struct wmediumd_set_tx_power request_data_payload;
    memcpy(request_data_payload.mac, &mac, sizeof(mac));
    request_data_payload.tx_power = request->tx_power();

    struct wmediumd_grpc_response_message response_message;
    SendAndReceiveGrpcMessage(REQUEST_SET_TX_POWER,
                              sizeof(request_data_payload),
                              &request_data_payload, &response_message);
    if (response_message.data_type != RESPONSE_ACK) {
      return Status(StatusCode::FAILED_PRECONDITION,
                    "Failed to execute SetTxpower");
    }
    return Status::OK;
  }

  Status StartPcap(ServerContext* context, const StartPcapRequest* request,
                   Empty* reply) override {
    // Construct request payload
    ssize_t size =
        sizeof(struct wmediumd_start_pcap) + (request->path().length() + 1);
    struct wmediumd_start_pcap* request_data_payload =
        (struct wmediumd_start_pcap*)malloc(size);
    strcpy(request_data_payload->pcap_path, request->path().c_str());

    struct wmediumd_grpc_response_message response_message;
    SendAndReceiveGrpcMessage(REQUEST_START_PCAP, size, request_data_payload,
                              &response_message);
    free(request_data_payload);
    if (response_message.data_type != RESPONSE_ACK) {
      return Status(StatusCode::FAILED_PRECONDITION,
                    "Failed to execute StartPcap");
    }
    return Status::OK;
  }

  Status StopPcap(ServerContext* context, const Empty* request,
                  Empty* reply) override {
    struct wmediumd_grpc_response_message response_message;
    SendAndReceiveGrpcMessage(REQUEST_STOP_PCAP, &response_message);
    if (response_message.data_type != RESPONSE_ACK) {
      return Status(StatusCode::FAILED_PRECONDITION,
                    "Failed to execute StopPcap");
    }
    return Status::OK;
  }

 private:
  void SendAndReceiveGrpcMessage(
      enum wmediumd_grpc_request_data_type data_type, ssize_t data_size,
      void* request_data_payload,
      struct wmediumd_grpc_response_message* response_message) {
    long msg_type_response = msg_type_response_increment.fetch_add(1);

    // Send Request Message
    struct wmediumd_grpc_request_message request_message;
    request_message.msg_type_request = MSG_TYPE_REQUEST;
    request_message.msg_type_response = msg_type_response;
    request_message.data_type = data_type;
    request_message.data_size = data_size;
    assert(data_size <= GRPC_MSG_BUF_MAX);
    if (data_size > 0) {
      memcpy(request_message.data_payload, request_data_payload, data_size);
    }
    msgsnd(msq_id_, &request_message, MSG_TYPE_REQUEST_SIZE, 0);

    // Trigger Event
    uint64_t evt = 1;
    write(event_fd_, &evt, sizeof(evt));

    msgrcv(msq_id_, response_message, MSG_TYPE_RESPONSE_SIZE, msg_type_response,
           0);
  }

  void SendAndReceiveGrpcMessage(
      enum wmediumd_grpc_request_data_type data_type,
      struct wmediumd_grpc_response_message* response_message) {
    SendAndReceiveGrpcMessage(data_type, 0, NULL, response_message);
  }

  int event_fd_;
  int msq_id_;
};

void RunWmediumdServer(std::string grpc_uds_path, int event_fd, int msq_id) {
  std::string server_address("unix:" + grpc_uds_path);
  WmediumdServiceImpl service(event_fd, msq_id);

  grpc::EnableDefaultHealthCheckService(true);
  grpc::reflection::InitProtoReflectionServerBuilderPlugin();
  ServerBuilder builder;
  // Listen on the given address without any authentication mechanism.
  builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
  // Register "service" as the instance through which we'll communicate with
  // clients. In this case it corresponds to an *synchronous* service.
  builder.RegisterService(&service);
  // Finally assemble the server.
  std::unique_ptr<Server> server(builder.BuildAndStart());
  std::cout << "Server listening on " << server_address << std::endl;

  // Wait for the server to shutdown. Note that some other thread must be
  // responsible for shutting down the server for this call to ever return.
  server->Wait();
}