/*
 * Copyright (C) 2018 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 <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>

#include "perfetto/base/build_config.h"
#include "perfetto/base/logging.h"
#include "perfetto/ext/base/file_utils.h"
#include "perfetto/ext/base/string_utils.h"
#include "perfetto/ext/base/version.h"
#include "src/protozero/text_to_proto/text_to_proto.h"
#include "src/traceconv/deobfuscate_profile.h"
#include "src/traceconv/symbolize_profile.h"
#include "src/traceconv/trace.descriptor.h"
#include "src/traceconv/trace_to_bundle.h"
#include "src/traceconv/trace_to_firefox.h"
#include "src/traceconv/trace_to_hprof.h"
#include "src/traceconv/trace_to_json.h"
#include "src/traceconv/trace_to_profile.h"
#include "src/traceconv/trace_to_systrace.h"
#include "src/traceconv/trace_to_text.h"
#include "src/traceconv/trace_unpack.h"

#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
#include <fcntl.h>
#include <io.h>
#else
#include <unistd.h>
#endif

namespace perfetto::trace_to_text {
namespace {

int Usage(const char* argv0) {
  fprintf(stderr, R"(
Trace format conversion tool.
Usage: %s MODE [OPTIONS] [input_file] [output_file]

CONVERSION MODES AND THEIR SUPPORTED OPTIONS:

 systrace                             Converts to systrace HTML format
   --truncate [start|end]             Truncates trace to keep start or end
   --full-sort                        Forces full trace sorting

 json                                 Converts to Chrome JSON format
   --truncate [start|end]             Truncates trace to keep start or end
   --full-sort                        Forces full trace sorting

 ctrace                               Converts to compressed systrace format
   --truncate [start|end]             Truncates trace to keep start or end
   --full-sort                        Forces full trace sorting

 text                                 Converts to human-readable text format
   (no additional options)

 profile                              Converts heap profiles to pprof format
                                      (profile.proto - default: heap profiles)
   --perf                             Extract perf/CPU profiles instead
   --no-annotations                   Don't add derived annotations to frames
   --timestamps T1,T2,...             Generate profiles for specific timestamps
   --pid PID                          Generate profiles for specific process

 java_heap_profile                    Converts Java heap profiles to pprof format
                                      (profile.proto)
   --no-annotations                   Don't add derived annotations to frames
   --timestamps T1,T2,...             Generate profiles for specific timestamps
   --pid PID                          Generate profiles for specific process

 hprof                                Converts heap profile to hprof format
   --timestamps T1,T2,...             Generate profiles for specific timestamps
   --pid PID                          Generate profiles for specific process

 symbolize                            Symbolizes addresses in profiles
   (no additional options)

 deobfuscate                          Deobfuscates obfuscated profiles
   (no additional options)

 firefox                              Converts to Firefox profiler format
   (no additional options)

 decompress_packets                   Decompresses compressed trace packets
   (no additional options)

 bundle                               Creates bundle with trace + debug data
                                      (outputs TAR with symbols/deobfuscation mappings)
                                      Requires input and output file paths (no stdin/stdout)
   --symbol-paths PATH1,PATH2,...     Additional paths to search for symbols
                                      (beyond automatic discovery)
   --no-auto-symbol-paths             Disable automatic symbol path discovery

 binary                               Converts text proto to binary format
   (no additional options)

NOTES:
 - If no input file is specified, reads from stdin
 - If no output file is specified, writes to stdout
 - Input/output files can be '-' to explicitly use stdin/stdout
)",
          argv0);
  return 1;
}

uint64_t StringToUint64OrDie(const char* str) {
  char* end;
  uint64_t number = static_cast<uint64_t>(strtoll(str, &end, 10));
  if (*end != '\0') {
    PERFETTO_ELOG("Invalid %s. Expected decimal integer.", str);
    exit(1);
  }
  return number;
}

int TextToTrace(std::istream* input, std::ostream* output) {
  std::string trace_text(std::istreambuf_iterator<char>{*input},
                         std::istreambuf_iterator<char>{});
  auto proto_status =
      protozero::TextToProto(kTraceDescriptor.data(), kTraceDescriptor.size(),
                             ".perfetto.protos.Trace", "trace", trace_text);
  if (!proto_status.ok()) {
    PERFETTO_ELOG("Failed to parse trace: %s",
                  proto_status.status().c_message());
    return 1;
  }
  const std::vector<uint8_t>& trace_proto = proto_status.value();
  output->write(reinterpret_cast<const char*>(trace_proto.data()),
                static_cast<int64_t>(trace_proto.size()));
  return 0;
}

int Main(int argc, char** argv) {
  std::vector<const char*> positional_args;
  Keep truncate_keep = Keep::kAll;
  uint64_t pid = 0;
  std::vector<uint64_t> timestamps;
  bool full_sort = false;
  bool perf_profile = false;
  bool profile_no_annotations = false;
  std::vector<std::string> symbol_paths;
  bool no_auto_symbol_paths = false;
  for (int i = 1; i < argc; i++) {
    if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--version") == 0) {
      printf("%s\n", base::GetVersionString());
      return 0;
    }
    if (strcmp(argv[i], "-t") == 0 || strcmp(argv[i], "--truncate") == 0) {
      i++;
      if (i <= argc && strcmp(argv[i], "start") == 0) {
        truncate_keep = Keep::kStart;
      } else if (i <= argc && strcmp(argv[i], "end") == 0) {
        truncate_keep = Keep::kEnd;
      } else {
        PERFETTO_ELOG(
            "--truncate must specify whether to keep the end or the "
            "start of the trace.");
        return Usage(argv[0]);
      }
    } else if (i <= argc && strcmp(argv[i], "--pid") == 0) {
      i++;
      pid = StringToUint64OrDie(argv[i]);
    } else if (i <= argc && strcmp(argv[i], "--timestamps") == 0) {
      i++;
      std::vector<std::string> ts_strings = base::SplitString(argv[i], ",");
      for (const std::string& ts : ts_strings) {
        timestamps.emplace_back(StringToUint64OrDie(ts.c_str()));
      }
    } else if (strcmp(argv[i], "--perf") == 0) {
      perf_profile = true;
    } else if (strcmp(argv[i], "--no-annotations") == 0) {
      profile_no_annotations = true;
    } else if (strcmp(argv[i], "--full-sort") == 0) {
      full_sort = true;
    } else if (i < argc && strcmp(argv[i], "--symbol-paths") == 0) {
      i++;
      symbol_paths = base::SplitString(argv[i], ",");
    } else if (strcmp(argv[i], "--no-auto-symbol-paths") == 0) {
      no_auto_symbol_paths = true;
    } else {
      positional_args.push_back(argv[i]);
    }
  }

  if (positional_args.empty())
    return Usage(argv[0]);

  std::istream* input_stream;
  std::ifstream file_istream;
  if (positional_args.size() > 1) {
    const char* file_path = positional_args[1];
    file_istream.open(file_path, std::ios_base::in | std::ios_base::binary);
    if (!file_istream.is_open())
      PERFETTO_FATAL("Could not open %s", file_path);
    input_stream = &file_istream;
  } else {
#if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
    if (isatty(STDIN_FILENO)) {
      PERFETTO_ELOG("Reading from stdin but it's connected to a TTY");
      PERFETTO_LOG("It is unlikely that you want to type in some binary.");
      PERFETTO_LOG("Either pass a file path to the cmdline or pipe stdin");
      return Usage(argv[0]);
    }
#endif
    input_stream = &std::cin;
  }

#if PERFETTO_BUILDFLAG(PERFETTO_OS_WIN)
  // We don't want the runtime to replace "\n" with "\r\n" on `std::cout`.
  _setmode(_fileno(stdout), _O_BINARY);
#endif

  std::ostream* output_stream;
  std::ofstream file_ostream;
  if (positional_args.size() > 2) {
    const char* file_path = positional_args[2];
    file_ostream.open(file_path, std::ios_base::out | std::ios_base::trunc |
                                     std::ios_base::binary);
    if (!file_ostream.is_open())
      PERFETTO_FATAL("Could not open %s", file_path);
    output_stream = &file_ostream;
  } else {
    output_stream = &std::cout;
  }

  std::string format(positional_args[0]);

  if ((format != "profile" && format != "hprof" &&
       format != "java_heap_profile") &&
      (pid != 0 || !timestamps.empty())) {
    PERFETTO_ELOG(
        "--pid and --timestamps are supported only for profile, hprof, "
        "and java_heap_profile formats.");
    return 1;
  }
  if (perf_profile && format != "profile") {
    PERFETTO_ELOG("--perf requires profile format.");
    return 1;
  }

  if (format == "binary") {
    return TextToTrace(input_stream, output_stream);
  }

  if (format == "json")
    return TraceToJson(input_stream, output_stream, /*compress=*/false,
                       truncate_keep, full_sort);

  if (format == "systrace")
    return TraceToSystrace(input_stream, output_stream, /*ctrace=*/false,
                           truncate_keep, full_sort);

  if (format == "ctrace")
    return TraceToSystrace(input_stream, output_stream, /*ctrace=*/true,
                           truncate_keep, full_sort);

  if (truncate_keep != Keep::kAll) {
    PERFETTO_ELOG(
        "--truncate is unsupported for "
        "text|profile|symbolize|decompress_packets format.");
    return 1;
  }

  if (full_sort) {
    PERFETTO_ELOG(
        "--full-sort is unsupported for "
        "text|profile|symbolize|decompress_packets format.");
    return 1;
  }

  if (format == "text") {
    return TraceToText(input_stream, output_stream) ? 0 : 1;
  }

  if (format == "profile") {
    return perf_profile
               ? TraceToPerfProfile(input_stream, output_stream, pid,
                                    timestamps, !profile_no_annotations)
               : TraceToHeapProfile(input_stream, output_stream, pid,
                                    timestamps, !profile_no_annotations);
  }

  if (format == "java_heap_profile") {
    return TraceToJavaHeapProfile(input_stream, output_stream, pid, timestamps,
                                  !profile_no_annotations);
  }

  if (format == "hprof")
    return TraceToHprof(input_stream, output_stream, pid, timestamps);

  if (format == "symbolize")
    return SymbolizeProfile(input_stream, output_stream);

  if (format == "deobfuscate")
    return DeobfuscateProfile(input_stream, output_stream);

  if (format == "firefox")
    return TraceToFirefoxProfile(input_stream, output_stream);

  if (format == "decompress_packets")
    return UnpackCompressedPackets(input_stream, output_stream);

  if (format == "bundle") {
    // Bundle mode requires both input and output file paths
    if (positional_args.size() < 3) {
      PERFETTO_ELOG("Bundle mode requires both input and output file paths");
      return Usage(argv[0]);
    }

    const char* input_file = positional_args[1];
    const char* output_file = positional_args[2];

    // Validate that stdin/stdout are not used for bundle mode
    if (strcmp(input_file, "-") == 0) {
      PERFETTO_ELOG(
          "Bundle mode does not support stdin input, provide file path");
      return 1;
    }
    if (strcmp(output_file, "-") == 0) {
      PERFETTO_ELOG(
          "Bundle mode does not support stdout output, provide file path");
      return 1;
    }

    // Validate input file exists and is readable
    if (!base::FileExists(input_file)) {
      PERFETTO_ELOG("Input file does not exist: %s", input_file);
      return 1;
    }

    BundleContext context;
    context.symbol_paths = symbol_paths;
    context.no_auto_symbol_paths = no_auto_symbol_paths;
    return TraceToBundle(input_file, output_file, context);
  }

  return Usage(argv[0]);
}

}  // namespace
}  // namespace perfetto::trace_to_text

int main(int argc, char** argv) {
  return perfetto::trace_to_text::Main(argc, argv);
}