// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "chrome/installer/util/auto_launch_util.h"

#include "base/command_line.h"
#include "base/files/file_path.h"
#include "base/logging.h"
#include "base/path_service.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/win/win_util.h"
#include "chrome/common/chrome_constants.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/chrome_version_info.h"
#include "chrome/installer/util/browser_distribution.h"
#include "chrome/installer/util/product.h"
#include "chrome/installer/util/util_constants.h"
#include "crypto/sha2.h"

namespace auto_launch_util {

// The prefix of the Chrome Auto-launch key under the Run key.
const wchar_t kAutolaunchKeyValue[] = L"GoogleChromeAutoLaunch";

// We use one Run key with flags specifying which feature we want to start up.
// When we change our Run key we need to specify what we want to do with each
// flag. This lists the possible actions we can take with the flags.
enum FlagSetting {
  FLAG_DISABLE,   // Disable the flag.
  FLAG_ENABLE,    // Enable the flag.
  FLAG_PRESERVE,  // Preserve the value that the flag has currently.
};

// A helper function that takes a |profile_path| and builds a registry key
// name to use when deciding where to read/write the auto-launch value
// to/from. It takes into account the name of the profile (so that different
// installations of Chrome don't conflict, and so the in the future different
// profiles can be auto-launched (or not) separately).
string16 ProfileToKeyName(const string16& profile_directory) {
  base::FilePath path;
  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
  if (command_line.HasSwitch(switches::kUserDataDir)) {
    path = command_line.GetSwitchValuePath(switches::kUserDataDir);
  } else {
    // Get the path from the same source as the installer, to make sure there
    // are no differences.
    BrowserDistribution* distribution =
        BrowserDistribution::GetSpecificDistribution(
            BrowserDistribution::CHROME_BROWSER);
    installer::Product product(distribution);
    std::vector<base::FilePath> data_dir_paths;
    product.GetUserDataPaths(&data_dir_paths);
    if (!data_dir_paths.empty())
      path = data_dir_paths[0];
  }
  path = path.Append(profile_directory);

  std::string input(path.AsUTF8Unsafe());
  uint8 hash[16];
  crypto::SHA256HashString(input, hash, sizeof(hash));
  std::string hash_string = base::HexEncode(hash, sizeof(hash));
  return string16(kAutolaunchKeyValue) +
      ASCIIToWide("_") + ASCIIToWide(hash_string);
}

// Returns whether the Chrome executable specified in |application_path| is set
// to auto-launch at computer startup with a given |command_line_switch|.
// NOTE: |application_path| is optional and should be blank in most cases (as
// it will default to the application path of the current executable).
// |profile_directory| is the name of the directory (leaf, not the full path)
// that contains the profile that should be opened at computer startup.
// |command_line_switch| is the switch we are optionally interested in and, if
// not blank, must be present for the function to return true. If blank, it acts
// like a wildcard.
bool WillLaunchAtLoginWithSwitch(const base::FilePath& application_path,
                                 const string16& profile_directory,
                                 const std::string& command_line_switch) {
  string16 key_name(ProfileToKeyName(profile_directory));
  string16 autolaunch;
  if (!base::win::ReadCommandFromAutoRun(
      HKEY_CURRENT_USER, key_name, &autolaunch)) {
    return false;
  }

  base::FilePath chrome_exe(application_path);
  if (chrome_exe.empty()) {
    if (!PathService::Get(base::DIR_EXE, &chrome_exe)) {
      NOTREACHED();
      return false;
    }
  }
  chrome_exe = chrome_exe.Append(installer::kChromeExe);

  if (autolaunch.find(chrome_exe.value()) == string16::npos)
    return false;

  return command_line_switch.empty() ||
         autolaunch.find(ASCIIToUTF16(command_line_switch)) != string16::npos;
}

bool AutoStartRequested(const string16& profile_directory,
                        bool window_requested,
                        const base::FilePath& application_path) {
  if (window_requested) {
    return WillLaunchAtLoginWithSwitch(application_path,
                                       profile_directory,
                                       switches::kAutoLaunchAtStartup);
  } else {
    // Background mode isn't profile specific, but is attached to the Run key
    // for the Default profile.
    return WillLaunchAtLoginWithSwitch(application_path,
                                       ASCIIToUTF16(chrome::kInitialProfile),
                                       switches::kNoStartupWindow);
  }
}

bool CheckAndRemoveDeprecatedBackgroundModeSwitch() {
  // For backwards compatibility we need to provide a migration path from the
  // previously used key "chromium" that the BackgroundMode used to set, as it
  // is incompatible with the new key (can't have two Run keys with
  // conflicting switches).
  string16 chromium = ASCIIToUTF16("chromium");
  string16 value;
  if (base::win::ReadCommandFromAutoRun(HKEY_CURRENT_USER, chromium, &value)) {
    if (value.find(ASCIIToUTF16(switches::kNoStartupWindow)) !=
        string16::npos) {
      base::win::RemoveCommandFromAutoRun(HKEY_CURRENT_USER, chromium);
      return true;
    }
  }

  return false;
}

void SetWillLaunchAtLogin(const base::FilePath& application_path,
                          const string16& profile_directory,
                          FlagSetting foreground_mode,
                          FlagSetting background_mode) {
  if (CheckAndRemoveDeprecatedBackgroundModeSwitch()) {
    // We've found the deprecated switch, we must migrate it (unless background
    // mode is being turned off).
    if (profile_directory == ASCIIToUTF16(chrome::kInitialProfile) &&
        background_mode == FLAG_PRESERVE) {
      // Preserve in this case also covers the deprecated value, so we must
      // explicitly turn the flag on and the rest will be taken care of below.
      background_mode = FLAG_ENABLE;
    } else {
      // When we add support for multiple profiles for foreground mode we need
      // to think about where to store the background mode switch. I think we
      // need to store it with the Default profile (call SetWillLaunchAtLogin
      // again specifying the Default profile), but concerns were raised in
      // review.
      NOTREACHED();
    }
  }
  string16 key_name(ProfileToKeyName(profile_directory));

  // Check which feature should be enabled.
  bool in_foreground =
      foreground_mode == FLAG_ENABLE ||
      (foreground_mode == FLAG_PRESERVE &&
          WillLaunchAtLoginWithSwitch(application_path,
                                      profile_directory,
                                      switches::kAutoLaunchAtStartup));
  bool in_background =
      background_mode == FLAG_ENABLE ||
      (background_mode == FLAG_PRESERVE &&
          WillLaunchAtLoginWithSwitch(application_path,
                                      profile_directory,
                                      switches::kNoStartupWindow));

  // TODO(finnur): Convert this into a shortcut, instead of using the Run key.
  if (in_foreground || in_background) {
    base::FilePath path(application_path);
    if (path.empty()) {
      if (!PathService::Get(base::DIR_EXE, &path)) {
        NOTREACHED();
        return;
      }
    }
    string16 cmd_line = ASCIIToUTF16("\"");
    cmd_line += path.value();
    cmd_line += ASCIIToUTF16("\\");
    cmd_line += installer::kChromeExe;
    cmd_line += ASCIIToUTF16("\"");

    if (in_background) {
      cmd_line += ASCIIToUTF16(" --");
      cmd_line += ASCIIToUTF16(switches::kNoStartupWindow);
    }
    if (in_foreground) {
      cmd_line += ASCIIToUTF16(" --");
      cmd_line += ASCIIToUTF16(switches::kAutoLaunchAtStartup);

      const CommandLine& command_line = *CommandLine::ForCurrentProcess();
      if (command_line.HasSwitch(switches::kUserDataDir)) {
        cmd_line += ASCIIToUTF16(" --");
        cmd_line += ASCIIToUTF16(switches::kUserDataDir);
        cmd_line += ASCIIToUTF16("=\"");
        cmd_line +=
            command_line.GetSwitchValuePath(switches::kUserDataDir).value();
        cmd_line += ASCIIToUTF16("\"");
      }

      cmd_line += ASCIIToUTF16(" --");
      cmd_line += ASCIIToUTF16(switches::kProfileDirectory);
      cmd_line += ASCIIToUTF16("=\"");
      cmd_line += profile_directory;
      cmd_line += ASCIIToUTF16("\"");
    }

    base::win::AddCommandToAutoRun(
        HKEY_CURRENT_USER, key_name, cmd_line);
  } else {
    base::win::RemoveCommandFromAutoRun(HKEY_CURRENT_USER, key_name);
  }
}

void DisableAllAutoStartFeatures(const string16& profile_directory) {
  DisableForegroundStartAtLogin(profile_directory);
  DisableBackgroundStartAtLogin();
}

void EnableForegroundStartAtLogin(const string16& profile_directory,
                                  const base::FilePath& application_path) {
  SetWillLaunchAtLogin(
      application_path, profile_directory, FLAG_ENABLE, FLAG_PRESERVE);
}

void DisableForegroundStartAtLogin(const string16& profile_directory) {
  SetWillLaunchAtLogin(
      base::FilePath(), profile_directory, FLAG_DISABLE, FLAG_PRESERVE);
}

void EnableBackgroundStartAtLogin() {
  // Background mode isn't profile specific, but we specify the Default profile
  // just to have a unique Run key to attach it to. FilePath is blank because
  // this function is not called from the installer (see comments for
  // EnableAutoStartAtLogin).
  SetWillLaunchAtLogin(base::FilePath(),
                       ASCIIToUTF16(chrome::kInitialProfile),
                       FLAG_PRESERVE,
                       FLAG_ENABLE);
}

void DisableBackgroundStartAtLogin() {
  SetWillLaunchAtLogin(base::FilePath(),
                       ASCIIToUTF16(chrome::kInitialProfile),
                       FLAG_PRESERVE,
                       FLAG_DISABLE);
}

}  // namespace auto_launch_util