// Aseprite
// Copyright (C) 2020  Igara Studio S.A.
// Copyright (C) 2001-2018  David Capello
//
// This program is distributed under the terms of
// the End-User License Agreement for Aseprite.

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "app/send_crash.h"

#include "app/app.h"
#include "app/console.h"
#include "app/i18n/strings.h"
#include "app/resource_finder.h"
#include "app/task.h"
#include "base/fs.h"
#include "base/launcher.h"
#include "fmt/format.h"
#include "ui/alert.h"
#include "ui/system.h"
#include "ver/info.h"

#include "send_crash.xml.h"

namespace app {

// static
std::string SendCrash::DefaultMemoryDumpFilename()
{
#ifdef _WIN32
  std::string kDefaultCrashName = fmt::format("{}-crash-{}.dmp",
                                              get_app_name(),
                                              get_app_version());
  ResourceFinder rf;
  rf.includeUserDir(kDefaultCrashName.c_str());
  return rf.getFirstOrCreateDefault();
#else
  return std::string();
#endif
}

SendCrash::~SendCrash()
{
  if (m_task.running()) {
    m_task.cancel();
    m_task.wait();
  }
}

void SendCrash::search()
{
#ifdef _WIN32
  // On Windows we use one mini-dump to report bugs, then we can open
  // this .dmp file locally along with the .exe + .pdb to check the
  // stack trace and detect the cause of the bug.

  m_dumpFilename = SendCrash::DefaultMemoryDumpFilename();
  if (!m_dumpFilename.empty() &&
      base::is_file(m_dumpFilename)) {
    auto app = App::instance();
    app->memoryDumpFilename(m_dumpFilename);
    app->showNotification(this);
  }

#elif defined(__APPLE__)
  // On macOS we can show the possibility to send the latest crash
  // report from ~/Library/Logs/DiagnosticReports which is the
  // location where crash reports (.crash files) are located.

  m_task.run(
    [this](base::task_token&){
      ResourceFinder rf;
      rf.includeHomeDir("Library/Logs/DiagnosticReports");
      std::string dir = rf.defaultFilename();
      if (base::is_directory(dir)) {
        std::vector<std::string> candidates;
        int n = std::strlen(get_app_name());
        for (const auto& fn : base::list_files(dir)) {
          // Cancel everything
          if (m_task.canceled())
            return;

          if (base::utf8_icmp(get_app_name(), fn, n) == 0) {
            candidates.push_back(fn);
          }
        }
        std::sort(candidates.begin(), candidates.end());
        if (!candidates.empty()) {
          std::string fn = base::join_path(dir, candidates.back());
          if (base::is_file(fn)) {
            ui::execute_from_ui_thread(
              [this, fn]{
                m_dumpFilename = fn;
                if (auto app = App::instance()) {
                  app->memoryDumpFilename(fn);
                  app->showNotification(this);
                }
              });
          }
        }
      }
    });

#endif
}

std::string SendCrash::notificationText()
{
  return "Report last crash";
}

void SendCrash::notificationClick()
{
  if (m_dumpFilename.empty()) {
    ui::Alert::show(Strings::alerts_nothing_to_report());
    return;
  }

  app::gen::SendCrash dlg;

#if _WIN32
  // Only on Windows, if the current version is a development version
  // (i.e. the get_app_version() contains "-dev"), the .dmp
  // file is useless for us. This is because we need the .exe + .pdb +
  // source code used in the compilation process to make some sense of
  // the .dmp file.

  bool isDev = (std::string(get_app_version()).find("-dev") != std::string::npos);
  if (isDev) {
    dlg.official()->setVisible(false);
    dlg.devFilename()->setText(m_dumpFilename);
    dlg.devFilename()->Click.connect([this]{ onClickDevFilename(); });
  }
  else
#endif  // On other platforms the crash file might be useful even in
        // the "-dev" version (e.g. on macOS it's a text file with
        // stack traces).
  {
    dlg.dev()->setVisible(false);
    dlg.filename()->setText(m_dumpFilename);
    dlg.filename()->Click.connect([this]{ onClickFilename(); });
  }

  dlg.openWindowInForeground();
  if (dlg.closer() == dlg.deleteFile()) {
    try {
      base::delete_file(m_dumpFilename);
      m_dumpFilename = "";
    }
    catch (const std::exception& ex) {
      Console::showException(ex);
    }
  }
}

void SendCrash::onClickFilename()
{
  base::launcher::open_folder(m_dumpFilename);
}

void SendCrash::onClickDevFilename()
{
  base::launcher::open_file(m_dumpFilename);
}

} // namespace app
