/*
 *
 * Copyright 2015, 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 "perfprofd_cmdline.h"

#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>

#include <set>
#include <string>

#include <android-base/logging.h>
#include <android-base/macros.h>
#include <android-base/stringprintf.h>

#include "perfprofd_record.pb.h"

#include "configreader.h"
#include "dropbox.h"
#include "perfprofdcore.h"
#include "perfprofd_io.h"

//
// Perf profiling daemon -- collects system-wide profiles using
//
//       simpleperf record -a
//
// and encodes them so that they can be uploaded by a separate service.
//

//

//
// Output file from 'perf record'.
//
#define PERF_OUTPUT "perf.data"

//
// Path to the perf file to convert and exit? Empty value is the default, daemon mode.
//
static std::string perf_file_to_convert = "";

//
// SIGHUP handler. Sending SIGHUP to the daemon can be used to break it
// out of a sleep() call so as to trigger a new collection (debugging)
//
static void sig_hup(int /* signum */)
{
  LOG(WARNING) << "SIGHUP received";
}

//
// Parse command line args. Currently supported flags:
// *  "-c PATH" sets the path of the config file to PATH.
// *  "-x PATH" reads PATH as a perf data file and saves it as a file in
//    perf_profile.proto format. ".encoded" suffix is appended to PATH to form
//    the output file path.
//
static void parse_args(int argc, char** argv)
{
  int ac;

  for (ac = 1; ac < argc; ++ac) {
    if (!strcmp(argv[ac], "-c")) {
      if (ac >= argc-1) {
        LOG(ERROR) << "malformed command line: -c option requires argument)";
        continue;
      }
      ConfigReader::setConfigFilePath(argv[ac+1]);
      ++ac;
    } else if (!strcmp(argv[ac], "-x")) {
      if (ac >= argc-1) {
        LOG(ERROR) << "malformed command line: -x option requires argument)";
        continue;
      }
      perf_file_to_convert = argv[ac+1];
      ++ac;
    } else {
      LOG(ERROR) << "malformed command line: unknown option or arg " <<  argv[ac] << ")";
      continue;
    }
  }
}

//
// Post-processes after profile is collected and converted to protobuf.
// * GMS core stores processed file sequence numbers in
//   /data/data/com.google.android.gms/files/perfprofd_processed.txt
// * Update /data/misc/perfprofd/perfprofd_produced.txt to remove the sequence
//   numbers that have been processed and append the current seq number
// Returns true if the current_seq should increment.
//
static bool post_process(const Config& config, int current_seq)
{
  const std::string& dest_dir = config.destination_directory;
  std::string processed_file_path =
      config.config_directory + "/" + PROCESSED_FILENAME;
  std::string produced_file_path = dest_dir + "/" + PRODUCED_FILENAME;


  std::set<int> processed;
  FILE *fp = fopen(processed_file_path.c_str(), "r");
  if (fp != NULL) {
    int seq;
    while(fscanf(fp, "%d\n", &seq) > 0) {
      if (remove(android::base::StringPrintf(
          "%s/perf.data.encoded.%d", dest_dir.c_str(),seq).c_str()) == 0) {
        processed.insert(seq);
      }
    }
    fclose(fp);
  }

  std::set<int> produced;
  fp = fopen(produced_file_path.c_str(), "r");
  if (fp != NULL) {
    int seq;
    while(fscanf(fp, "%d\n", &seq) > 0) {
      if (processed.find(seq) == processed.end()) {
        produced.insert(seq);
      }
    }
    fclose(fp);
  }

  uint32_t maxLive = config.max_unprocessed_profiles;
  if (produced.size() >= maxLive) {
    return false;
  }

  produced.insert(current_seq);
  fp = fopen(produced_file_path.c_str(), "w");
  if (fp == NULL) {
    PLOG(WARNING) << "Cannot write " <<  produced_file_path;
    return false;
  }
  for (std::set<int>::const_iterator iter = produced.begin();
       iter != produced.end(); ++iter) {
    fprintf(fp, "%d\n", *iter);
  }
  fclose(fp);
  chmod(produced_file_path.c_str(),
        S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
  return true;
}

//
// Initialization
//

static void init(ConfigReader &config)
{
  if (!config.readFile()) {
    LOG(ERROR) << "unable to open configuration file " << config.getConfigFilePath();
  }

  CommonInit(static_cast<uint32_t>(config.getUnsignedValue("use_fixed_seed")),
             config.getStringValue("destination_directory").c_str());

  signal(SIGHUP, sig_hup);
}

//
// Main routine:
// 1. parse cmd line args
// 2. read config file
// 3. loop: {
//       sleep for a while
//       perform a profile collection
//    }
//
int perfprofd_main(int argc, char** argv, Config* config)
{
  LOG(INFO) << "starting Android Wide Profiling daemon";

  parse_args(argc, argv);
  {
    ConfigReader config_reader;
    init(config_reader);
    config_reader.FillConfig(config);
  }
  GlobalInit(config->perf_path);

  if (!perf_file_to_convert.empty()) {
    std::string encoded_path = perf_file_to_convert + ".encoded";
    encode_to_proto(perf_file_to_convert, encoded_path.c_str(), *config, 0, nullptr);
    return 0;
  }

  // Early exit if we're not supposed to run on this build flavor
  if (!IsDebugBuild() && config->only_debug_build) {
    LOG(INFO) << "early exit due to inappropriate build type";
    return 0;
  }

  auto config_fn = [config]() {
    return config;
  };
  auto reread_config = [config]() {
    // Reread config file -- the uploader may have rewritten it.
    ConfigReader config_reader;
    if (config_reader.readFile()) {
      config_reader.FillConfig(config);
    }
  };
  int seq = 0;
  auto handler = [&seq](android::perfprofd::PerfprofdRecord* proto, Config* handler_config) {
    if (proto == nullptr) {
      return false;
    }
    if (handler_config->send_to_dropbox) {
      std::string error_msg;
      if (!android::perfprofd::dropbox::SendToDropbox(proto,
                                                      handler_config->destination_directory,
                                                      &error_msg)) {
        LOG(ERROR) << "Failed dropbox submission: " << error_msg;
        return false;
      }
    } else {
      std::string data_file_path(handler_config->destination_directory);
      data_file_path += "/";
      data_file_path += PERF_OUTPUT;
      std::string path = android::base::StringPrintf("%s.encoded.%d", data_file_path.c_str(), seq);
      if (!android::perfprofd::SerializeProtobuf(proto, path.c_str(), handler_config->compress)) {
        return false;
      }
      if (!post_process(*handler_config, seq)) {
        return false;
      }
    }
    seq++;
    return true;
  };
  ProfilingLoop(config_fn, reread_config, handler);

  LOG(INFO) << "finishing Android Wide Profiling daemon";
  return 0;
}