/*
 * Copyright (C) 2020 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 <cstdlib>
#include <fstream>

#include "chre_host/daemon_base.h"
#include "chre_host/log.h"
#include "chre_host/napp_header.h"

#include <json/json.h>

#ifdef CHRE_DAEMON_METRIC_ENABLED
#include <aidl/android/frameworks/stats/IStats.h>
#include <android/binder_manager.h>
#include <hardware/google/pixel/pixelstats/pixelatoms.pb.h>

using ::aidl::android::frameworks::stats::IStats;
using ::aidl::android::frameworks::stats::VendorAtom;
using ::aidl::android::frameworks::stats::VendorAtomValue;
namespace PixelAtoms = ::android::hardware::google::pixel::PixelAtoms;
#endif  // CHRE_DAEMON_METRIC_ENABLED

// Aliased for consistency with the way these symbols are referenced in
// CHRE-side code
namespace fbs = ::chre::fbs;

namespace android {
namespace chre {

ChreDaemonBase::ChreDaemonBase() : mChreShutdownRequested(false) {
  mLogger.init();
}

void ChreDaemonBase::loadPreloadedNanoapps() {
  constexpr char kPreloadedNanoappsConfigPath[] =
      "/vendor/etc/chre/preloaded_nanoapps.json";
  std::ifstream configFileStream(kPreloadedNanoappsConfigPath);

  Json::CharReaderBuilder builder;
  Json::Value config;
  if (!configFileStream) {
    LOGE("Failed to open config file '%s': %d (%s)",
         kPreloadedNanoappsConfigPath, errno, strerror(errno));
  } else if (!Json::parseFromStream(builder, configFileStream, &config,
                                    /* errorMessage = */ nullptr)) {
    LOGE("Failed to parse nanoapp config file");
  } else if (!config.isMember("nanoapps") || !config.isMember("source_dir")) {
    LOGE("Malformed preloaded nanoapps config");
  } else {
    const Json::Value &directory = config["source_dir"];
    for (Json::ArrayIndex i = 0; i < config["nanoapps"].size(); i++) {
      const Json::Value &nanoapp = config["nanoapps"][i];
      loadPreloadedNanoapp(directory.asString(), nanoapp.asString(),
                           static_cast<uint32_t>(i));
    }
  }
}

void ChreDaemonBase::loadPreloadedNanoapp(const std::string &directory,
                                          const std::string &name,
                                          uint32_t transactionId) {
  std::vector<uint8_t> headerBuffer;

  std::string headerFile = directory + "/" + name + ".napp_header";

  // Only create the nanoapp filename as the CHRE framework will load from
  // within the directory its own binary resides in.
  std::string nanoappFilename = name + ".so";

  if (readFileContents(headerFile.c_str(), &headerBuffer) &&
      !loadNanoapp(headerBuffer, nanoappFilename, transactionId)) {
    LOGE("Failed to load nanoapp: '%s'", name.c_str());
  }
}

bool ChreDaemonBase::loadNanoapp(const std::vector<uint8_t> &header,
                                 const std::string &nanoappName,
                                 uint32_t transactionId) {
  bool success = false;
  if (header.size() != sizeof(NanoAppBinaryHeader)) {
    LOGE("Header size mismatch");
  } else {
    // The header blob contains the struct above.
    const auto *appHeader =
        reinterpret_cast<const NanoAppBinaryHeader *>(header.data());

    // Build the target API version from major and minor.
    uint32_t targetApiVersion = (appHeader->targetChreApiMajorVersion << 24) |
                                (appHeader->targetChreApiMinorVersion << 16);

    success = sendNanoappLoad(appHeader->appId, appHeader->appVersion,
                              targetApiVersion, nanoappName, transactionId);
  }

  return success;
}

bool ChreDaemonBase::sendNanoappLoad(uint64_t appId, uint32_t appVersion,
                                     uint32_t appTargetApiVersion,
                                     const std::string &appBinaryName,
                                     uint32_t transactionId) {
  flatbuffers::FlatBufferBuilder builder;
  HostProtocolHost::encodeLoadNanoappRequestForFile(
      builder, transactionId, appId, appVersion, appTargetApiVersion,
      appBinaryName.c_str());

  bool success = sendMessageToChre(
      kHostClientIdDaemon, builder.GetBufferPointer(), builder.GetSize());

  if (!success) {
    LOGE("Failed to send nanoapp filename.");
  } else {
    Transaction transaction = {
        .transactionId = transactionId,
        .nanoappId = appId,
    };
    mPreloadedNanoappPendingTransactions.push(transaction);
  }

  return success;
}

bool ChreDaemonBase::sendTimeSync(bool logOnError) {
  bool success = false;
  int64_t timeOffset = getTimeOffset(&success);

  if (success) {
    flatbuffers::FlatBufferBuilder builder(64);
    HostProtocolHost::encodeTimeSyncMessage(builder, timeOffset);
    success = sendMessageToChre(kHostClientIdDaemon, builder.GetBufferPointer(),
                                builder.GetSize());

    if (!success && logOnError) {
      LOGE("Failed to deliver time sync message from host to CHRE");
    }
  }

  return success;
}

bool ChreDaemonBase::sendTimeSyncWithRetry(size_t numRetries,
                                           useconds_t retryDelayUs,
                                           bool logOnError) {
  bool success = false;
  while (!success && (numRetries-- != 0)) {
    success = sendTimeSync(logOnError);
    if (!success) {
      usleep(retryDelayUs);
    }
  }
  return success;
}

bool ChreDaemonBase::sendNanConfigurationUpdate(bool nanEnabled) {
  flatbuffers::FlatBufferBuilder builder(32);
  HostProtocolHost::encodeNanconfigurationUpdate(builder, nanEnabled);
  return sendMessageToChre(kHostClientIdDaemon, builder.GetBufferPointer(),
                           builder.GetSize());
}

bool ChreDaemonBase::sendMessageToChre(uint16_t clientId, void *data,
                                       size_t length) {
  bool success = false;
  if (!HostProtocolHost::mutateHostClientId(data, length, clientId)) {
    LOGE("Couldn't set host client ID in message container!");
  } else {
    LOGV("Delivering message from host (size %zu)", length);
    getLogger().dump(static_cast<const uint8_t *>(data), length);
    success = doSendMessage(data, length);
  }

  return success;
}

void ChreDaemonBase::onMessageReceived(const unsigned char *messageBuffer,
                                       size_t messageLen) {
  getLogger().dump(messageBuffer, messageLen);

  uint16_t hostClientId;
  fbs::ChreMessage messageType;
  if (!HostProtocolHost::extractHostClientIdAndType(
          messageBuffer, messageLen, &hostClientId, &messageType)) {
    LOGW("Failed to extract host client ID from message - sending broadcast");
    hostClientId = ::chre::kHostClientIdUnspecified;
  }

  if (messageType == fbs::ChreMessage::LogMessage) {
    std::unique_ptr<fbs::MessageContainerT> container =
        fbs::UnPackMessageContainer(messageBuffer);
    const auto *logMessage = container->message.AsLogMessage();
    const std::vector<int8_t> &logData = logMessage->buffer;

    getLogger().log(reinterpret_cast<const uint8_t *>(logData.data()),
                    logData.size());
  } else if (messageType == fbs::ChreMessage::LogMessageV2) {
    std::unique_ptr<fbs::MessageContainerT> container =
        fbs::UnPackMessageContainer(messageBuffer);
    const auto *logMessage = container->message.AsLogMessageV2();
    const std::vector<int8_t> &logDataBuffer = logMessage->buffer;
    const auto *logData =
        reinterpret_cast<const uint8_t *>(logDataBuffer.data());
    uint32_t numLogsDropped = logMessage->num_logs_dropped;

    getLogger().logV2(logData, logDataBuffer.size(), numLogsDropped);
  } else if (messageType == fbs::ChreMessage::TimeSyncRequest) {
    sendTimeSync(true /* logOnError */);
  } else if (messageType == fbs::ChreMessage::LowPowerMicAccessRequest) {
    configureLpma(true /* enabled */);
  } else if (messageType == fbs::ChreMessage::LowPowerMicAccessRelease) {
    configureLpma(false /* enabled */);
  } else if (messageType == fbs::ChreMessage::MetricLog) {
#ifdef CHRE_DAEMON_METRIC_ENABLED
    std::unique_ptr<fbs::MessageContainerT> container =
        fbs::UnPackMessageContainer(messageBuffer);
    const auto *metricMsg = container->message.AsMetricLog();
    handleMetricLog(metricMsg);
#endif  // CHRE_DAEMON_METRIC_ENABLED
  } else if (messageType == fbs::ChreMessage::NanConfigurationRequest) {
    std::unique_ptr<fbs::MessageContainerT> container =
        fbs::UnPackMessageContainer(messageBuffer);
    configureNan(container->message.AsNanConfigurationRequest()->enable);
  } else if (hostClientId == kHostClientIdDaemon) {
    handleDaemonMessage(messageBuffer);
  } else if (hostClientId == ::chre::kHostClientIdUnspecified) {
    mServer.sendToAllClients(messageBuffer, static_cast<size_t>(messageLen));
  } else {
    mServer.sendToClientById(messageBuffer, static_cast<size_t>(messageLen),
                             hostClientId);
  }
}

bool ChreDaemonBase::readFileContents(const char *filename,
                                      std::vector<uint8_t> *buffer) {
  bool success = false;
  std::ifstream file(filename, std::ios::binary | std::ios::ate);
  if (!file) {
    LOGE("Couldn't open file '%s': %d (%s)", filename, errno, strerror(errno));
  } else {
    ssize_t size = file.tellg();
    file.seekg(0, std::ios::beg);

    buffer->resize(size);
    if (!file.read(reinterpret_cast<char *>(buffer->data()), size)) {
      LOGE("Couldn't read from file '%s': %d (%s)", filename, errno,
           strerror(errno));
    } else {
      success = true;
    }
  }

  return success;
}

void ChreDaemonBase::handleDaemonMessage(const uint8_t *message) {
  std::unique_ptr<fbs::MessageContainerT> container =
      fbs::UnPackMessageContainer(message);
  if (container->message.type != fbs::ChreMessage::LoadNanoappResponse) {
    LOGE("Invalid message from CHRE directed to daemon");
  } else {
    const auto *response = container->message.AsLoadNanoappResponse();
    if (mPreloadedNanoappPendingTransactions.empty()) {
      LOGE("Received nanoapp load response with no pending load");
    } else if (mPreloadedNanoappPendingTransactions.front().transactionId !=
               response->transaction_id) {
      LOGE("Received nanoapp load response with ID %" PRIu32
           " expected transaction id %" PRIu32,
           response->transaction_id,
           mPreloadedNanoappPendingTransactions.front().transactionId);
    } else {
      if (!response->success) {
        LOGE("Received unsuccessful nanoapp load response with ID %" PRIu32,
             mPreloadedNanoappPendingTransactions.front().transactionId);

#ifdef CHRE_DAEMON_METRIC_ENABLED
        std::vector<VendorAtomValue> values(3);
        values[0].set<VendorAtomValue::longValue>(
            mPreloadedNanoappPendingTransactions.front().nanoappId);
        values[1].set<VendorAtomValue::intValue>(
            PixelAtoms::ChreHalNanoappLoadFailed::TYPE_PRELOADED);
        values[2].set<VendorAtomValue::intValue>(
            PixelAtoms::ChreHalNanoappLoadFailed::REASON_ERROR_GENERIC);
        const VendorAtom atom{
            .reverseDomainName = "",
            .atomId = PixelAtoms::Atom::kChreHalNanoappLoadFailed,
            .values{std::move(values)},
        };
        reportMetric(atom);
#endif  // CHRE_DAEMON_METRIC_ENABLED
      }
      mPreloadedNanoappPendingTransactions.pop();
    }
  }
}

#ifdef CHRE_DAEMON_METRIC_ENABLED
void ChreDaemonBase::handleMetricLog(const ::chre::fbs::MetricLogT *metricMsg) {
  const std::vector<int8_t> &encodedMetric = metricMsg->encoded_metric;

  switch (metricMsg->id) {
    case PixelAtoms::Atom::kChrePalOpenFailed: {
      PixelAtoms::ChrePalOpenFailed metric;
      if (!metric.ParseFromArray(encodedMetric.data(), encodedMetric.size())) {
        LOGE("Failed to parse metric data");
      } else {
        std::vector<VendorAtomValue> values(2);
        values[0].set<VendorAtomValue::intValue>(metric.pal());
        values[1].set<VendorAtomValue::intValue>(metric.type());
        const VendorAtom atom{
            .reverseDomainName = "",
            .atomId = PixelAtoms::Atom::kChrePalOpenFailed,
            .values{std::move(values)},
        };
        reportMetric(atom);
      }
      break;
    }
    case PixelAtoms::Atom::kChreEventQueueSnapshotReported: {
      PixelAtoms::ChreEventQueueSnapshotReported metric;
      if (!metric.ParseFromArray(encodedMetric.data(), encodedMetric.size())) {
        LOGE("Failed to parse metric data");
      } else {
        std::vector<VendorAtomValue> values(6);
        values[0].set<VendorAtomValue::intValue>(
            metric.snapshot_chre_get_time_ms());
        values[1].set<VendorAtomValue::intValue>(metric.max_event_queue_size());
        values[2].set<VendorAtomValue::intValue>(
            metric.mean_event_queue_size());
        values[3].set<VendorAtomValue::intValue>(metric.num_dropped_events());
        // Last two values are not currently populated and will be implemented
        // later. To avoid confusion of the interpretation, we use UINT32_MAX
        // as a placeholder value.
        values[4].set<VendorAtomValue::intValue>(
            UINT32_MAX);  // max_queue_delay_us
        values[5].set<VendorAtomValue::intValue>(
            UINT32_MAX);  // mean_queue_delay_us
        const VendorAtom atom{
            .reverseDomainName = "",
            .atomId = PixelAtoms::Atom::kChreEventQueueSnapshotReported,
            .values{std::move(values)},
        };
        reportMetric(atom);
      }
      break;
    }
    default: {
#ifdef CHRE_LOG_ATOM_EXTENSION_ENABLED
      handleVendorMetricLog(metricMsg);
#else
      LOGW("Unknown metric ID %" PRIu32, metricMsg->id);
#endif  // CHRE_LOG_ATOM_EXTENSION_ENABLED
    }
  }
}

void ChreDaemonBase::reportMetric(const VendorAtom &atom) {
  const std::string statsServiceName =
      std::string(IStats::descriptor).append("/default");
  if (!AServiceManager_isDeclared(statsServiceName.c_str())) {
    LOGE("Stats service is not declared.");
    return;
  }

  std::shared_ptr<IStats> stats_client = IStats::fromBinder(ndk::SpAIBinder(
      AServiceManager_waitForService(statsServiceName.c_str())));
  if (stats_client == nullptr) {
    LOGE("Failed to get IStats service");
    return;
  }

  const ndk::ScopedAStatus ret = stats_client->reportVendorAtom(atom);
  if (!ret.isOk()) {
    LOGE("Failed to report vendor atom");
  }
}
#endif  // CHRE_DAEMON_METRIC_ENABLED

void ChreDaemonBase::configureNan(bool /*enabled*/) {
  LOGE("NAN not supported");
}

}  // namespace chre
}  // namespace android