// Copyright 2016 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 "tools/gn/visual_studio_writer.h"

#include <algorithm>
#include <map>
#include <set>
#include <string>

#include "base/files/file_util.h"
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "tools/gn/builder.h"
#include "tools/gn/config.h"
#include "tools/gn/config_values_extractors.h"
#include "tools/gn/filesystem_utils.h"
#include "tools/gn/parse_tree.h"
#include "tools/gn/path_output.h"
#include "tools/gn/source_file_type.h"
#include "tools/gn/standard_out.h"
#include "tools/gn/target.h"
#include "tools/gn/variables.h"
#include "tools/gn/visual_studio_utils.h"
#include "tools/gn/xml_element_writer.h"

#if defined(OS_WIN)
#include "base/win/registry.h"
#endif

namespace {

struct SemicolonSeparatedWriter {
  void operator()(const std::string& value, std::ostream& out) const {
    out << value + ';';
  }
};

struct IncludeDirWriter {
  explicit IncludeDirWriter(PathOutput& path_output)
      : path_output_(path_output) {}
  ~IncludeDirWriter() = default;

  void operator()(const SourceDir& dir, std::ostream& out) const {
    path_output_.WriteDir(out, dir, PathOutput::DIR_NO_LAST_SLASH);
    out << ";";
  }

  PathOutput& path_output_;
};

struct SourceFileWriter {
  SourceFileWriter(PathOutput& path_output, const SourceFile& source_file)
      : path_output_(path_output), source_file_(source_file) {}
  ~SourceFileWriter() = default;

  void operator()(std::ostream& out) const {
    path_output_.WriteFile(out, source_file_);
  }

  PathOutput& path_output_;
  const SourceFile& source_file_;
};

const char kToolsetVersion[] = "v140";                     // Visual Studio 2015
const char kVisualStudioVersion[] = "14.0";                // Visual Studio 2015
const char kWindowsKitsVersion[] = "10";                   // Windows 10 SDK
const char kWindowsKitsIncludeVersion[] = "10.0.10240.0";  // Windows 10 SDK

const char kGuidTypeProject[] = "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}";
const char kGuidTypeFolder[] = "{2150E333-8FDC-42A3-9474-1A3956D46DE8}";
const char kGuidSeedProject[] = "project";
const char kGuidSeedFolder[] = "folder";
const char kGuidSeedFilter[] = "filter";

std::string GetWindowsKitsIncludeDirs() {
  std::string kits_path;

#if defined(OS_WIN)
  const base::char16* const subkeys[] = {
      L"SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots",
      L"SOFTWARE\\Wow6432Node\\Microsoft\\Windows Kits\\Installed Roots"};

  base::string16 value_name =
      base::ASCIIToUTF16("KitsRoot") + base::ASCIIToUTF16(kWindowsKitsVersion);

  for (const base::char16* subkey : subkeys) {
    base::win::RegKey key(HKEY_LOCAL_MACHINE, subkey, KEY_READ);
    base::string16 value;
    if (key.ReadValue(value_name.c_str(), &value) == ERROR_SUCCESS) {
      kits_path = base::UTF16ToUTF8(value);
      break;
    }
  }
#endif  // OS_WIN

  if (kits_path.empty()) {
    kits_path = std::string("C:\\Program Files (x86)\\Windows Kits\\") +
                kWindowsKitsVersion + "\\";
  }

  return kits_path + "Include\\" + kWindowsKitsIncludeVersion + "\\shared;" +
         kits_path + "Include\\" + kWindowsKitsIncludeVersion + "\\um;" +
         kits_path + "Include\\" + kWindowsKitsIncludeVersion + "\\winrt;";
}

std::string GetConfigurationType(const Target* target, Err* err) {
  switch (target->output_type()) {
    case Target::EXECUTABLE:
      return "Application";
    case Target::SHARED_LIBRARY:
    case Target::LOADABLE_MODULE:
      return "DynamicLibrary";
    case Target::STATIC_LIBRARY:
    case Target::SOURCE_SET:
      return "StaticLibrary";

    default:
      *err = Err(Location(),
                 "Visual Studio doesn't support '" + target->label().name() +
                     "' target output type: " +
                     Target::GetStringForOutputType(target->output_type()));
      return std::string();
  }
}

void ParseCompilerOptions(const std::vector<std::string>& cflags,
                          CompilerOptions* options) {
  for (const std::string& flag : cflags)
    ParseCompilerOption(flag, options);
}

void ParseCompilerOptions(const Target* target, CompilerOptions* options) {
  for (ConfigValuesIterator iter(target); !iter.done(); iter.Next()) {
    ParseCompilerOptions(iter.cur().cflags(), options);
    ParseCompilerOptions(iter.cur().cflags_c(), options);
    ParseCompilerOptions(iter.cur().cflags_cc(), options);
  }
}

// Returns a string piece pointing into the input string identifying the parent
// directory path, excluding the last slash. Note that the input pointer must
// outlive the output.
base::StringPiece FindParentDir(const std::string* path) {
  DCHECK(path && !path->empty());
  for (int i = static_cast<int>(path->size()) - 2; i >= 0; --i) {
    if (IsSlash((*path)[i]))
      return base::StringPiece(path->data(), i);
  }
  return base::StringPiece();
}

bool HasSameContent(std::stringstream& data_1, const base::FilePath& data_2) {
  // Compare file sizes first. Quick and will save us some time if they are
  // different sizes.
  int64_t data_1_len = data_1.tellp();

  int64_t data_2_len;
  if (!base::GetFileSize(data_2, &data_2_len) || data_1_len != data_2_len)
    return false;

  std::string data_2_data;
  data_2_data.resize(data_2_len);
  if (!base::ReadFileToString(data_2, &data_2_data))
    return false;

  std::string data_1_data;
  data_1_data = data_1.str();

  return data_1_data == data_2_data;
}

}  // namespace

VisualStudioWriter::SolutionEntry::SolutionEntry(const std::string& _name,
                                                 const std::string& _path,
                                                 const std::string& _guid)
    : name(_name), path(_path), guid(_guid), parent_folder(nullptr) {}

VisualStudioWriter::SolutionEntry::~SolutionEntry() = default;

VisualStudioWriter::VisualStudioWriter(const BuildSettings* build_settings)
    : build_settings_(build_settings) {
  const Value* value = build_settings->build_args().GetArgOverride("is_debug");
  is_debug_config_ = value == nullptr || value->boolean_value();
  config_platform_ = "Win32";
  value = build_settings->build_args().GetArgOverride(variables::kTargetCpu);
  if (value != nullptr && value->string_value() == "x64")
    config_platform_ = "x64";

  windows_kits_include_dirs_ = GetWindowsKitsIncludeDirs();
}

VisualStudioWriter::~VisualStudioWriter() {
  STLDeleteContainerPointers(projects_.begin(), projects_.end());
  STLDeleteContainerPointers(folders_.begin(), folders_.end());
}

// static
bool VisualStudioWriter::RunAndWriteFiles(const BuildSettings* build_settings,
                                          Builder* builder,
                                          Err* err) {
  std::vector<const Target*> targets = builder->GetAllResolvedTargets();

  VisualStudioWriter writer(build_settings);
  writer.projects_.reserve(targets.size());
  writer.folders_.reserve(targets.size());

  std::set<std::string> processed_targets;
  for (const Target* target : targets) {
    // Skip targets which are duplicated in vector.
    std::string target_path =
        target->label().dir().value() + target->label().name();
    if (processed_targets.find(target_path) != processed_targets.end())
      continue;

    // Skip actions and groups.
    if (target->output_type() == Target::GROUP ||
        target->output_type() == Target::COPY_FILES ||
        target->output_type() == Target::ACTION ||
        target->output_type() == Target::ACTION_FOREACH) {
      continue;
    }

    if (!writer.WriteProjectFiles(target, err))
      return false;

    processed_targets.insert(target_path);
  }

  if (writer.projects_.empty()) {
    *err = Err(Location(), "No Visual Studio projects generated.");
    return false;
  }

  writer.ResolveSolutionFolders();
  return writer.WriteSolutionFile(err);
}

bool VisualStudioWriter::WriteProjectFiles(const Target* target, Err* err) {
  SourceFile target_file = GetTargetOutputDir(target).ResolveRelativeFile(
      Value(nullptr, target->label().name() + ".vcxproj"), err);
  if (target_file.is_null())
    return false;

  base::FilePath vcxproj_path = build_settings_->GetFullPath(target_file);
  std::string vcxproj_path_str = FilePathToUTF8(vcxproj_path);

  projects_.push_back(
      new SolutionEntry(target->label().name(), vcxproj_path_str,
                        MakeGuid(vcxproj_path_str, kGuidSeedProject)));
  projects_.back()->label_dir_path =
      FilePathToUTF8(build_settings_->GetFullPath(target->label().dir()));

  std::stringstream vcxproj_string_out;
  if (!WriteProjectFileContents(vcxproj_string_out, *projects_.back(), target,
                                err)) {
    projects_.pop_back();
    return false;
  }

  // Only write the content to the file if it's different. That is
  // both a performance optimization and more importantly, prevents
  // Visual Studio from reloading the projects.
  if (!HasSameContent(vcxproj_string_out, vcxproj_path)) {
    std::string content = vcxproj_string_out.str();
    int size = static_cast<int>(content.size());
    if (base::WriteFile(vcxproj_path, content.c_str(), size) != size) {
      *err = Err(Location(), "Couldn't open " + target->label().name() +
                                 ".vcxproj for writing");
      return false;
    }
  }

  base::FilePath filters_path = UTF8ToFilePath(vcxproj_path_str + ".filters");

  std::stringstream filters_string_out;
  WriteFiltersFileContents(filters_string_out, target);

  if (!HasSameContent(filters_string_out, filters_path)) {
    std::string content = filters_string_out.str();
    int size = static_cast<int>(content.size());
    if (base::WriteFile(filters_path, content.c_str(), size) != size) {
      *err = Err(Location(), "Couldn't open " + target->label().name() +
                                 ".vcxproj.filters for writing");
      return false;
    }
  }

  return true;
}

bool VisualStudioWriter::WriteProjectFileContents(
    std::ostream& out,
    const SolutionEntry& solution_project,
    const Target* target,
    Err* err) {
  PathOutput path_output(GetTargetOutputDir(target),
                         build_settings_->root_path_utf8(),
                         EscapingMode::ESCAPE_NONE);

  out << "<?xml version=\"1.0\" encoding=\"utf-8\"?>" << std::endl;
  XmlElementWriter project(
      out, "Project",
      XmlAttributes("DefaultTargets", "Build")
          .add("ToolsVersion", kVisualStudioVersion)
          .add("xmlns", "http://schemas.microsoft.com/developer/msbuild/2003"));

  {
    scoped_ptr<XmlElementWriter> configurations = project.SubElement(
        "ItemGroup", XmlAttributes("Label", "ProjectConfigurations"));
    std::string config_name = is_debug_config_ ? "Debug" : "Release";
    scoped_ptr<XmlElementWriter> project_config = configurations->SubElement(
        "ProjectConfiguration",
        XmlAttributes("Include", config_name + '|' + config_platform_));
    project_config->SubElement("Configuration")->Text(config_name);
    project_config->SubElement("Platform")->Text(config_platform_);
  }

  {
    scoped_ptr<XmlElementWriter> globals =
        project.SubElement("PropertyGroup", XmlAttributes("Label", "Globals"));
    globals->SubElement("ProjectGuid")->Text(solution_project.guid);
    globals->SubElement("Keyword")->Text("Win32Proj");
    globals->SubElement("RootNamespace")->Text(target->label().name());
    globals->SubElement("IgnoreWarnCompileDuplicatedFilename")->Text("true");
    globals->SubElement("PreferredToolArchitecture")->Text("x64");
  }

  project.SubElement(
      "Import", XmlAttributes("Project",
                              "$(VCTargetsPath)\\Microsoft.Cpp.Default.props"));

  {
    scoped_ptr<XmlElementWriter> configuration = project.SubElement(
        "PropertyGroup", XmlAttributes("Label", "Configuration"));
    configuration->SubElement("CharacterSet")->Text("Unicode");
    std::string configuration_type = GetConfigurationType(target, err);
    if (configuration_type.empty())
      return false;
    configuration->SubElement("ConfigurationType")->Text(configuration_type);
  }

  {
    scoped_ptr<XmlElementWriter> locals =
        project.SubElement("PropertyGroup", XmlAttributes("Label", "Locals"));
    locals->SubElement("PlatformToolset")->Text(kToolsetVersion);
  }

  project.SubElement(
      "Import",
      XmlAttributes("Project", "$(VCTargetsPath)\\Microsoft.Cpp.props"));
  project.SubElement(
      "Import",
      XmlAttributes("Project",
                    "$(VCTargetsPath)\\BuildCustomizations\\masm.props"));
  project.SubElement("ImportGroup",
                     XmlAttributes("Label", "ExtensionSettings"));

  {
    scoped_ptr<XmlElementWriter> property_sheets = project.SubElement(
        "ImportGroup", XmlAttributes("Label", "PropertySheets"));
    property_sheets->SubElement(
        "Import",
        XmlAttributes(
            "Condition",
            "exists('$(UserRootDir)\\Microsoft.Cpp.$(Platform).user.props')")
            .add("Label", "LocalAppDataPlatform")
            .add("Project",
                 "$(UserRootDir)\\Microsoft.Cpp.$(Platform).user.props"));
  }

  project.SubElement("PropertyGroup", XmlAttributes("Label", "UserMacros"));

  {
    scoped_ptr<XmlElementWriter> properties =
        project.SubElement("PropertyGroup");
    {
      scoped_ptr<XmlElementWriter> out_dir = properties->SubElement("OutDir");
      path_output.WriteDir(out_dir->StartContent(false),
                           build_settings_->build_dir(),
                           PathOutput::DIR_INCLUDE_LAST_SLASH);
    }
    properties->SubElement("TargetName")->Text("$(ProjectName)");
    properties->SubElement("TargetPath")
        ->Text("$(OutDir)\\$(ProjectName)$(TargetExt)");
  }

  {
    scoped_ptr<XmlElementWriter> item_definitions =
        project.SubElement("ItemDefinitionGroup");
    {
      scoped_ptr<XmlElementWriter> cl_compile =
          item_definitions->SubElement("ClCompile");
      {
        scoped_ptr<XmlElementWriter> include_dirs =
            cl_compile->SubElement("AdditionalIncludeDirectories");
        RecursiveTargetConfigToStream<SourceDir>(
            target, &ConfigValues::include_dirs, IncludeDirWriter(path_output),
            include_dirs->StartContent(false));
        include_dirs->Text(windows_kits_include_dirs_ +
                           "$(VSInstallDir)\\VC\\atlmfc\\include;" +
                           "%(AdditionalIncludeDirectories)");
      }
      CompilerOptions options;
      ParseCompilerOptions(target, &options);
      if (!options.additional_options.empty()) {
        cl_compile->SubElement("AdditionalOptions")
            ->Text(options.additional_options + "%(AdditionalOptions)");
      }
      if (!options.buffer_security_check.empty()) {
        cl_compile->SubElement("BufferSecurityCheck")
            ->Text(options.buffer_security_check);
      }
      cl_compile->SubElement("CompileAsWinRT")->Text("false");
      cl_compile->SubElement("DebugInformationFormat")->Text("ProgramDatabase");
      if (!options.disable_specific_warnings.empty()) {
        cl_compile->SubElement("DisableSpecificWarnings")
            ->Text(options.disable_specific_warnings +
                   "%(DisableSpecificWarnings)");
      }
      cl_compile->SubElement("ExceptionHandling")->Text("false");
      if (!options.forced_include_files.empty()) {
        cl_compile->SubElement("ForcedIncludeFiles")
            ->Text(options.forced_include_files);
      }
      cl_compile->SubElement("MinimalRebuild")->Text("false");
      if (!options.optimization.empty())
        cl_compile->SubElement("Optimization")->Text(options.optimization);
      if (target->config_values().has_precompiled_headers()) {
        cl_compile->SubElement("PrecompiledHeader")->Text("Use");
        cl_compile->SubElement("PrecompiledHeaderFile")
            ->Text(target->config_values().precompiled_header());
      } else {
        cl_compile->SubElement("PrecompiledHeader")->Text("NotUsing");
      }
      {
        scoped_ptr<XmlElementWriter> preprocessor_definitions =
            cl_compile->SubElement("PreprocessorDefinitions");
        RecursiveTargetConfigToStream<std::string>(
            target, &ConfigValues::defines, SemicolonSeparatedWriter(),
            preprocessor_definitions->StartContent(false));
        preprocessor_definitions->Text("%(PreprocessorDefinitions)");
      }
      if (!options.runtime_library.empty())
        cl_compile->SubElement("RuntimeLibrary")->Text(options.runtime_library);
      if (!options.treat_warning_as_error.empty()) {
        cl_compile->SubElement("TreatWarningAsError")
            ->Text(options.treat_warning_as_error);
      }
      if (!options.warning_level.empty())
        cl_compile->SubElement("WarningLevel")->Text(options.warning_level);
    }

    // We don't include resource compilation and link options as ninja files
    // are used to generate real build.
  }

  {
    scoped_ptr<XmlElementWriter> group = project.SubElement("ItemGroup");
    if (!target->config_values().precompiled_source().is_null()) {
      group
          ->SubElement(
              "ClCompile", "Include",
              SourceFileWriter(path_output,
                               target->config_values().precompiled_source()))
          ->SubElement("PrecompiledHeader")
          ->Text("Create");
    }

    for (const SourceFile& file : target->sources()) {
      SourceFileType type = GetSourceFileType(file);
      if (type == SOURCE_H || type == SOURCE_CPP || type == SOURCE_C) {
        group->SubElement(type == SOURCE_H ? "ClInclude" : "ClCompile",
                          "Include", SourceFileWriter(path_output, file));
      }
    }
  }

  project.SubElement(
      "Import",
      XmlAttributes("Project", "$(VCTargetsPath)\\Microsoft.Cpp.targets"));
  project.SubElement(
      "Import",
      XmlAttributes("Project",
                    "$(VCTargetsPath)\\BuildCustomizations\\masm.targets"));
  project.SubElement("ImportGroup", XmlAttributes("Label", "ExtensionTargets"));

  {
    scoped_ptr<XmlElementWriter> build =
        project.SubElement("Target", XmlAttributes("Name", "Build"));
    build->SubElement(
        "Exec",
        XmlAttributes("Command", "call ninja.exe -C $(OutDir) $(ProjectName)"));
  }

  {
    scoped_ptr<XmlElementWriter> clean =
        project.SubElement("Target", XmlAttributes("Name", "Clean"));
    clean->SubElement(
        "Exec",
        XmlAttributes("Command",
                      "call ninja.exe -C $(OutDir) -tclean $(ProjectName)"));
  }

  return true;
}

void VisualStudioWriter::WriteFiltersFileContents(std::ostream& out,
                                                  const Target* target) {
  out << "<?xml version=\"1.0\" encoding=\"utf-8\"?>" << std::endl;
  XmlElementWriter project(
      out, "Project",
      XmlAttributes("ToolsVersion", "4.0")
          .add("xmlns", "http://schemas.microsoft.com/developer/msbuild/2003"));

  std::ostringstream files_out;

  {
    scoped_ptr<XmlElementWriter> filters_group =
        project.SubElement("ItemGroup");
    XmlElementWriter files_group(files_out, "ItemGroup", XmlAttributes(), 2);

    // File paths are relative to vcxproj files which are generated to out dirs.
    // Filters tree structure need to reflect source directories and be relative
    // to target file. We need two path outputs then.
    PathOutput file_path_output(GetTargetOutputDir(target),
                                build_settings_->root_path_utf8(),
                                EscapingMode::ESCAPE_NONE);
    PathOutput filter_path_output(target->label().dir(),
                                  build_settings_->root_path_utf8(),
                                  EscapingMode::ESCAPE_NONE);

    std::set<std::string> processed_filters;

    for (const SourceFile& file : target->sources()) {
      SourceFileType type = GetSourceFileType(file);
      if (type == SOURCE_H || type == SOURCE_CPP || type == SOURCE_C) {
        scoped_ptr<XmlElementWriter> cl_item = files_group.SubElement(
            type == SOURCE_H ? "ClInclude" : "ClCompile", "Include",
            SourceFileWriter(file_path_output, file));

        std::ostringstream target_relative_out;
        filter_path_output.WriteFile(target_relative_out, file);
        std::string target_relative_path = target_relative_out.str();
        ConvertPathToSystem(&target_relative_path);
        base::StringPiece filter_path = FindParentDir(&target_relative_path);

        if (!filter_path.empty()) {
          std::string filter_path_str = filter_path.as_string();
          while (processed_filters.find(filter_path_str) ==
                 processed_filters.end()) {
            auto it = processed_filters.insert(filter_path_str).first;
            filters_group
                ->SubElement("Filter",
                             XmlAttributes("Include", filter_path_str))
                ->SubElement("UniqueIdentifier")
                ->Text(MakeGuid(filter_path_str, kGuidSeedFilter));
            filter_path_str = FindParentDir(&(*it)).as_string();
            if (filter_path_str.empty())
              break;
          }
          cl_item->SubElement("Filter")->Text(filter_path);
        }
      }
    }
  }

  project.Text(files_out.str());
}

bool VisualStudioWriter::WriteSolutionFile(Err* err) {
  SourceFile sln_file = build_settings_->build_dir().ResolveRelativeFile(
      Value(nullptr, "all.sln"), err);
  if (sln_file.is_null())
    return false;

  base::FilePath sln_path = build_settings_->GetFullPath(sln_file);

  std::stringstream string_out;
  WriteSolutionFileContents(string_out, sln_path.DirName());

  // Only write the content to the file if it's different. That is
  // both a performance optimization and more importantly, prevents
  // Visual Studio from reloading the projects.
  if (HasSameContent(string_out, sln_path))
    return true;

  std::string content = string_out.str();
  int size = static_cast<int>(content.size());
  if (base::WriteFile(sln_path, content.c_str(), size) != size) {
    *err = Err(Location(), "Couldn't open all.sln for writing");
    return false;
  }

  return true;
}

void VisualStudioWriter::WriteSolutionFileContents(
    std::ostream& out,
    const base::FilePath& solution_dir_path) {
  out << "Microsoft Visual Studio Solution File, Format Version 12.00"
      << std::endl;
  out << "# Visual Studio 2015" << std::endl;

  SourceDir solution_dir(FilePathToUTF8(solution_dir_path));
  for (const SolutionEntry* folder : folders_) {
    out << "Project(\"" << kGuidTypeFolder << "\") = \"(" << folder->name
        << ")\", \"" << RebasePath(folder->path, solution_dir, "/") << "\", \""
        << folder->guid << "\"" << std::endl;
    out << "EndProject" << std::endl;
  }

  for (const SolutionEntry* project : projects_) {
    out << "Project(\"" << kGuidTypeProject << "\") = \"" << project->name
        << "\", \"" << RebasePath(project->path, solution_dir, "/") << "\", \""
        << project->guid << "\"" << std::endl;
    out << "EndProject" << std::endl;
  }

  out << "Global" << std::endl;

  out << "\tGlobalSection(SolutionConfigurationPlatforms) = preSolution"
      << std::endl;
  const std::string config_mode =
      std::string(is_debug_config_ ? "Debug" : "Release") + '|' +
      config_platform_;
  out << "\t\t" << config_mode << " = " << config_mode << std::endl;
  out << "\tEndGlobalSection" << std::endl;

  out << "\tGlobalSection(ProjectConfigurationPlatforms) = postSolution"
      << std::endl;
  for (const SolutionEntry* project : projects_) {
    out << "\t\t" << project->guid << '.' << config_mode
        << ".ActiveCfg = " << config_mode << std::endl;
    out << "\t\t" << project->guid << '.' << config_mode
        << ".Build.0 = " << config_mode << std::endl;
  }
  out << "\tEndGlobalSection" << std::endl;

  out << "\tGlobalSection(SolutionProperties) = preSolution" << std::endl;
  out << "\t\tHideSolutionNode = FALSE" << std::endl;
  out << "\tEndGlobalSection" << std::endl;

  out << "\tGlobalSection(NestedProjects) = preSolution" << std::endl;
  for (const SolutionEntry* folder : folders_) {
    if (folder->parent_folder) {
      out << "\t\t" << folder->guid << " = " << folder->parent_folder->guid
          << std::endl;
    }
  }
  for (const SolutionEntry* project : projects_) {
    out << "\t\t" << project->guid << " = " << project->parent_folder->guid
        << std::endl;
  }
  out << "\tEndGlobalSection" << std::endl;

  out << "EndGlobal" << std::endl;
}

void VisualStudioWriter::ResolveSolutionFolders() {
  root_folder_path_.clear();

  // Get all project directories. Create solution folder for each directory.
  std::map<base::StringPiece, SolutionEntry*> processed_paths;
  for (SolutionEntry* project : projects_) {
    base::StringPiece folder_path = project->label_dir_path;
    if (IsSlash(folder_path[folder_path.size() - 1]))
      folder_path = folder_path.substr(0, folder_path.size() - 1);
    auto it = processed_paths.find(folder_path);
    if (it != processed_paths.end()) {
      project->parent_folder = it->second;
    } else {
      std::string folder_path_str = folder_path.as_string();
      SolutionEntry* folder = new SolutionEntry(
          FindLastDirComponent(SourceDir(folder_path)).as_string(),
          folder_path_str, MakeGuid(folder_path_str, kGuidSeedFolder));
      folders_.push_back(folder);
      project->parent_folder = folder;
      processed_paths[folder_path] = folder;

      if (root_folder_path_.empty()) {
        root_folder_path_ = folder_path_str;
      } else {
        size_t common_prefix_len = 0;
        size_t max_common_length =
            std::min(root_folder_path_.size(), folder_path.size());
        size_t i;
        for (i = common_prefix_len; i < max_common_length; ++i) {
          if (IsSlash(root_folder_path_[i]) && IsSlash(folder_path[i]))
            common_prefix_len = i + 1;
          else if (root_folder_path_[i] != folder_path[i])
            break;
        }
        if (i == max_common_length)
          common_prefix_len = max_common_length;
        if (common_prefix_len < root_folder_path_.size()) {
          if (IsSlash(root_folder_path_[common_prefix_len - 1]))
            --common_prefix_len;
          root_folder_path_ = root_folder_path_.substr(0, common_prefix_len);
        }
      }
    }
  }

  // Create also all parent folders up to |root_folder_path_|.
  SolutionEntries additional_folders;
  for (SolutionEntry* folder : folders_) {
    if (folder->path == root_folder_path_)
      continue;

    base::StringPiece parent_path;
    while ((parent_path = FindParentDir(&folder->path)) != root_folder_path_) {
      auto it = processed_paths.find(parent_path);
      if (it != processed_paths.end()) {
        folder = it->second;
      } else {
        folder = new SolutionEntry(
            FindLastDirComponent(SourceDir(parent_path)).as_string(),
            parent_path.as_string(),
            MakeGuid(parent_path.as_string(), kGuidSeedFolder));
        additional_folders.push_back(folder);
        processed_paths[parent_path] = folder;
      }
    }
  }
  folders_.insert(folders_.end(), additional_folders.begin(),
                  additional_folders.end());

  // Sort folders by path.
  std::sort(folders_.begin(), folders_.end(),
            [](const SolutionEntry* a, const SolutionEntry* b) {
              return a->path < b->path;
            });

  // Match subfolders with their parents. Since |folders_| are sorted by path we
  // know that parent folder always precedes its children in vector.
  SolutionEntries parents;
  for (SolutionEntry* folder : folders_) {
    while (!parents.empty()) {
      if (base::StartsWith(folder->path, parents.back()->path,
                           base::CompareCase::SENSITIVE)) {
        folder->parent_folder = parents.back();
        break;
      } else {
        parents.pop_back();
      }
    }
    parents.push_back(folder);
  }
}