// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/browser/sessions/session_service_log.h"

#include <string>
#include <utility>

#include "base/strings/string_number_conversions.h"
#include "base/values.h"
#include "chrome/browser/profiles/profile.h"
#include "components/pref_registry/pref_registry_syncable.h"
#include "components/prefs/pref_service.h"

namespace {

// The value is a list.
constexpr char kEventPrefKey[] = "sessions.event_log";
constexpr char kEventTypeKey[] = "type";
constexpr char kEventTimeKey[] = "time";
constexpr char kStartEventDidLastSessionCrashKey[] = "crashed";
constexpr char kRestoreEventWindowCountKey[] = "window_count";
constexpr char kRestoreEventTabCountKey[] = "tab_count";
constexpr char kRestoreEventErroredReadingKey[] = "errored_reading";
constexpr char kRestoreInitiatedEventRestoreBrowserKey[] = "restore_browser";
constexpr char kRestoreInitiatedEventSynchronousKey[] = "synchronous";
constexpr char kExitEventWindowCountKey[] = "window_count";
constexpr char kExitEventTabCountKey[] = "tab_count";
constexpr char kExitEventIsFirstSessionServiceKey[] = "first_session_service";
constexpr char kExitEventDidScheduleCommandKey[] = "did_schedule_command";
constexpr char kWriteErrorEventErrorCountKey[] = "error_count";
constexpr char kWriteErrorEventUnrecoverableErrorCountKey[] =
    "unrecoverable_error_count";

// This value is a balance between keeping too much in prefs, and the
// ability to see the last few restarts.
constexpr size_t kMaxEventCount = 20;

base::Value::Dict SerializeEvent(const SessionServiceEvent& event) {
  base::Value::Dict serialized_event;
  serialized_event.Set(kEventTypeKey, static_cast<int>(event.type));
  serialized_event.Set(
      kEventTimeKey,
      base::NumberToString(event.time.since_origin().InMicroseconds()));
  switch (event.type) {
    case SessionServiceEventLogType::kStart:
      serialized_event.Set(kStartEventDidLastSessionCrashKey,
                           event.data.start.did_last_session_crash);
      break;
    case SessionServiceEventLogType::kRestore:
      serialized_event.Set(kRestoreEventWindowCountKey,
                           event.data.restore.window_count);
      serialized_event.Set(kRestoreEventTabCountKey,
                           event.data.restore.tab_count);
      serialized_event.Set(kRestoreEventErroredReadingKey,
                           event.data.restore.encountered_error_reading);
      break;
    case SessionServiceEventLogType::kExit:
      serialized_event.Set(kExitEventWindowCountKey,
                           event.data.exit.window_count);
      serialized_event.Set(kExitEventTabCountKey, event.data.exit.tab_count);
      serialized_event.Set(kExitEventIsFirstSessionServiceKey,
                           event.data.exit.is_first_session_service);
      serialized_event.Set(kExitEventDidScheduleCommandKey,
                           event.data.exit.did_schedule_command);
      break;
    case SessionServiceEventLogType::kWriteError:
      serialized_event.Set(kWriteErrorEventErrorCountKey,
                           event.data.write_error.error_count);
      serialized_event.Set(kWriteErrorEventUnrecoverableErrorCountKey,
                           event.data.write_error.unrecoverable_error_count);
      break;
    case SessionServiceEventLogType::kRestoreCanceled:
      break;
    case SessionServiceEventLogType::kRestoreInitiated:
      serialized_event.Set(kRestoreInitiatedEventRestoreBrowserKey,
                           event.data.restore_initiated.restore_browser);
      serialized_event.Set(kRestoreInitiatedEventSynchronousKey,
                           event.data.restore_initiated.synchronous);
      break;
  }
  return serialized_event;
}

bool DeserializeEvent(const base::Value::Dict& serialized_event,
                      SessionServiceEvent& event) {
  auto type = serialized_event.FindInt(kEventTypeKey);
  if (!type)
    return false;
  if (*type < static_cast<int>(SessionServiceEventLogType::kMinValue) ||
      *type > static_cast<int>(SessionServiceEventLogType::kMaxValue)) {
    return false;
  }
  event.type = static_cast<SessionServiceEventLogType>(*type);

  const std::string* time_value = serialized_event.FindString(kEventTimeKey);
  if (!time_value)
    return false;
  int64_t time_int;
  if (!base::StringToInt64(*time_value, &time_int))
    return false;
  event.time = base::Time() + base::Microseconds(time_int);

  switch (event.type) {
    case SessionServiceEventLogType::kStart: {
      auto crash_value =
          serialized_event.FindBool(kStartEventDidLastSessionCrashKey);
      if (!crash_value)
        return false;
      event.data.start.did_last_session_crash = *crash_value;
      break;
    }
    case SessionServiceEventLogType::kRestore: {
      auto window_count = serialized_event.FindInt(kRestoreEventWindowCountKey);
      if (!window_count)
        return false;
      event.data.restore.window_count = *window_count;

      auto tab_count = serialized_event.FindInt(kRestoreEventTabCountKey);
      if (!tab_count)
        return false;
      event.data.restore.tab_count = *tab_count;

      auto error_reading =
          serialized_event.FindBool(kRestoreEventErroredReadingKey);
      if (!error_reading)
        return false;
      event.data.restore.encountered_error_reading = *error_reading;
      break;
    }
    case SessionServiceEventLogType::kExit: {
      auto window_count = serialized_event.FindInt(kExitEventWindowCountKey);
      if (!window_count)
        return false;
      event.data.exit.window_count = *window_count;

      auto tab_count = serialized_event.FindInt(kExitEventTabCountKey);
      if (!tab_count)
        return false;
      event.data.exit.tab_count = *tab_count;

      // The remaining values were added later on. Don't error if not found.
      auto is_first_session_service =
          serialized_event.FindBool(kExitEventIsFirstSessionServiceKey);
      event.data.exit.is_first_session_service =
          !is_first_session_service || *is_first_session_service;

      auto did_schedule_command =
          serialized_event.FindBool(kExitEventDidScheduleCommandKey);
      event.data.exit.did_schedule_command =
          !did_schedule_command || *did_schedule_command;
      break;
    }
    case SessionServiceEventLogType::kWriteError: {
      auto error_count =
          serialized_event.FindInt(kWriteErrorEventErrorCountKey);
      if (!error_count)
        return false;
      event.data.write_error.error_count = *error_count;
      event.data.write_error.unrecoverable_error_count = 0;
      // `kWriteErrorEventErrorCountKey` was added after initial code landed,
      // so don't fail if it isn't present.
      auto unrecoverable_error_count =
          serialized_event.FindInt(kWriteErrorEventUnrecoverableErrorCountKey);
      if (unrecoverable_error_count) {
        event.data.write_error.unrecoverable_error_count =
            *unrecoverable_error_count;
      }
      break;
    }
    case SessionServiceEventLogType::kRestoreCanceled:
      break;
    case SessionServiceEventLogType::kRestoreInitiated: {
      auto synchronous =
          serialized_event.FindBool(kRestoreInitiatedEventSynchronousKey);
      event.data.restore_initiated.synchronous = synchronous && *synchronous;
      auto restore_browser =
          serialized_event.FindBool(kRestoreInitiatedEventRestoreBrowserKey);
      event.data.restore_initiated.restore_browser =
          restore_browser && *restore_browser;
      break;
    }
  }
  return true;
}

void SaveEventsToPrefs(Profile* profile,
                       const std::list<SessionServiceEvent>& events) {
  base::Value serialized_events(base::Value::Type::LIST);
  for (const SessionServiceEvent& event : events)
    serialized_events.GetList().Append(SerializeEvent(event));
  profile->GetPrefs()->Set(kEventPrefKey, serialized_events);
}

}  // namespace

std::list<SessionServiceEvent> GetSessionServiceEvents(Profile* profile) {
  const base::Value::List& serialized_events =
      profile->GetPrefs()->GetList(kEventPrefKey);
  std::list<SessionServiceEvent> events;
  for (const auto& serialized_event : serialized_events) {
    SessionServiceEvent event;
    if (!serialized_event.is_dict())
      continue;
    if (DeserializeEvent(serialized_event.GetDict(), event))
      events.push_back(std::move(event));
  }
  return events;
}

void LogSessionServiceStartEvent(Profile* profile, bool after_crash) {
  SessionServiceEvent event;
  event.type = SessionServiceEventLogType::kStart;
  event.time = base::Time::Now();
  event.data.start.did_last_session_crash = after_crash;
  LogSessionServiceEvent(profile, event);
}

void LogSessionServiceExitEvent(Profile* profile,
                                int window_count,
                                int tab_count,
                                bool is_first_session_service,
                                bool did_schedule_command) {
  SessionServiceEvent event;
  event.type = SessionServiceEventLogType::kExit;
  event.time = base::Time::Now();
  event.data.exit.window_count = window_count;
  event.data.exit.tab_count = tab_count;
  event.data.exit.is_first_session_service = is_first_session_service;
  event.data.exit.did_schedule_command = did_schedule_command;
  LogSessionServiceEvent(profile, event);
}

void LogSessionServiceRestoreInitiatedEvent(Profile* profile,
                                            bool synchronous,
                                            bool restore_browser) {
  SessionServiceEvent event;
  event.type = SessionServiceEventLogType::kRestoreInitiated;
  event.time = base::Time::Now();
  event.data.restore_initiated.synchronous = synchronous;
  event.data.restore_initiated.restore_browser = restore_browser;
  LogSessionServiceEvent(profile, event);
}

void LogSessionServiceRestoreEvent(Profile* profile,
                                   int window_count,
                                   int tab_count,
                                   bool encountered_error_reading) {
  SessionServiceEvent event;
  event.type = SessionServiceEventLogType::kRestore;
  event.time = base::Time::Now();
  event.data.restore.window_count = window_count;
  event.data.restore.tab_count = tab_count;
  event.data.restore.encountered_error_reading = encountered_error_reading;
  LogSessionServiceEvent(profile, event);
}

void LogSessionServiceRestoreCanceledEvent(Profile* profile) {
  SessionServiceEvent event;
  event.type = SessionServiceEventLogType::kRestoreCanceled;
  event.time = base::Time::Now();
  LogSessionServiceEvent(profile, event);
}

void LogSessionServiceWriteErrorEvent(Profile* profile,
                                      bool unrecoverable_write_error) {
  SessionServiceEvent event;
  event.type = SessionServiceEventLogType::kWriteError;
  event.time = base::Time::Now();
  event.data.write_error.error_count = 1;
  event.data.write_error.unrecoverable_error_count =
      unrecoverable_write_error ? 1 : 0;
  LogSessionServiceEvent(profile, event);
}

void RemoveLastSessionServiceEventOfType(Profile* profile,
                                         SessionServiceEventLogType type) {
  std::list<SessionServiceEvent> events = GetSessionServiceEvents(profile);
  for (auto iter = events.rbegin(); iter != events.rend(); ++iter) {
    if (iter->type == type) {
      events.erase(std::next(iter).base());
      SaveEventsToPrefs(profile, events);
      return;
    }
  }
}

void RegisterSessionServiceLogProfilePrefs(
    user_prefs::PrefRegistrySyncable* registry) {
  registry->RegisterListPref(kEventPrefKey);
}

void LogSessionServiceEvent(Profile* profile,
                            const SessionServiceEvent& event) {
  std::list<SessionServiceEvent> events = GetSessionServiceEvents(profile);
  if (event.type == SessionServiceEventLogType::kWriteError &&
      !events.empty() &&
      events.back().type == SessionServiceEventLogType::kWriteError) {
    events.back().data.write_error.error_count += 1;
    events.back().data.write_error.unrecoverable_error_count +=
        event.data.write_error.unrecoverable_error_count;
  } else {
    events.push_back(event);
    if (events.size() >= kMaxEventCount)
      events.erase(events.begin());
  }
  SaveEventsToPrefs(profile, events);
}