// Copyright (c) 2013 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/source_dir.h"

#include "base/logging.h"
#include "build/build_config.h"
#include "tools/gn/filesystem_utils.h"
#include "tools/gn/source_file.h"

namespace {

void AssertValueSourceDirString(const std::string& s) {
  if (!s.empty()) {
#if defined(OS_WIN)
    DCHECK(s[0] == '/' ||
           (s.size() > 2 && s[0] != '/' && s[1] == ':' && IsSlash(s[2])));
#else
    DCHECK(s[0] == '/');
#endif
    DCHECK(EndsWithSlash(s)) << s;
  }
}

}  // namespace

SourceDir::SourceDir() {
}

SourceDir::SourceDir(const base::StringPiece& p)
    : value_(p.data(), p.size()) {
  if (!EndsWithSlash(value_))
    value_.push_back('/');
  AssertValueSourceDirString(value_);
}

SourceDir::SourceDir(SwapIn, std::string* s) {
  value_.swap(*s);
  if (!EndsWithSlash(value_))
    value_.push_back('/');
  AssertValueSourceDirString(value_);
}

SourceDir::~SourceDir() {
}

SourceFile SourceDir::ResolveRelativeFile(
    const Value& p,
    Err* err,
    const base::StringPiece& source_root) const {
  SourceFile ret;
  if (!p.VerifyTypeIs(Value::STRING, err))
    return ret;

  // It's an error to resolve an empty string or one that is a directory
  // (indicated by a trailing slash) because this is the function that expects
  // to return a file.
  const std::string& str = p.string_value();
  if (str.empty()) {
    *err = Err(p, "Empty file path.",
               "You can't use empty strings as file paths. That's just wrong.");
    return ret;
  } else if (str[str.size() - 1] == '/') {
    *err = Err(p, "File path ends in a slash.",
               "You specified the path\n  " + str + "\n"
               "and it ends in a slash, indicating you think it's a directory."
               "\nBut here you're supposed to be listing a file.");
    return ret;
  }

  if (str.size() >= 2 && str[0] == '/' && str[1] == '/') {
    // Source-relative.
    ret.value_.assign(str.data(), str.size());
    NormalizePath(&ret.value_, source_root);
    return ret;
  } else if (IsPathAbsolute(str)) {
    if (source_root.empty() ||
        !MakeAbsolutePathRelativeIfPossible(source_root, str, &ret.value_)) {
#if defined(OS_WIN)
      // On Windows we'll accept "C:\foo" as an absolute path, which we want
      // to convert to "/C:..." here.
      if (str[0] != '/')
        ret.value_ = "/";
#endif
      ret.value_.append(str.data(), str.size());
    }
    NormalizePath(&ret.value_);
    return ret;
  }

  if (!source_root.empty()) {
    std::string absolute =
        FilePathToUTF8(Resolve(UTF8ToFilePath(source_root)).AppendASCII(
            str).value());
    NormalizePath(&absolute);
    if (!MakeAbsolutePathRelativeIfPossible(source_root, absolute,
                                            &ret.value_)) {
#if defined(OS_WIN)
      // On Windows we'll accept "C:\foo" as an absolute path, which we want
      // to convert to "/C:..." here.
      if (absolute[0] != '/')
        ret.value_ = "/";
#endif
      ret.value_.append(absolute.data(), absolute.size());
    }
    return ret;
  }

  // With no source_root_, there's nothing we can do about
  // e.g. p=../../../path/to/file and value_=//source and we'll
  // errornously return //file.
  ret.value_.reserve(value_.size() + str.size());
  ret.value_.assign(value_);
  ret.value_.append(str.data(), str.size());

  NormalizePath(&ret.value_);
  return ret;
}

SourceDir SourceDir::ResolveRelativeDir(
    const Value& p,
    Err* err,
    const base::StringPiece& source_root) const {
  if (!p.VerifyTypeIs(Value::STRING, err))
    return SourceDir();
  return ResolveRelativeDir(p, p.string_value(), err, source_root);
}

SourceDir SourceDir::ResolveRelativeDir(
    const Value& blame_but_dont_use,
    const base::StringPiece& str,
    Err* err,
    const base::StringPiece& source_root) const {
  SourceDir ret;

  if (str.empty()) {
    *err = Err(blame_but_dont_use, "Empty directory path.",
               "You can't use empty strings as directories. "
               "That's just wrong.");
    return ret;
  }

  if (str.size() >= 2 && str[0] == '/' && str[1] == '/') {
    // Source-relative.
    ret.value_.assign(str.data(), str.size());
    if (!EndsWithSlash(ret.value_))
      ret.value_.push_back('/');
    NormalizePath(&ret.value_, source_root);
    return ret;
  } else if (IsPathAbsolute(str)) {
    if (source_root.empty() ||
        !MakeAbsolutePathRelativeIfPossible(source_root, str, &ret.value_)) {
#if defined(OS_WIN)
      if (str[0] != '/')  // See the file case for why we do this check.
        ret.value_ = "/";
#endif
      ret.value_.append(str.data(), str.size());
    }
    NormalizePath(&ret.value_);
    if (!EndsWithSlash(ret.value_))
      ret.value_.push_back('/');
    return ret;
  }

  if (!source_root.empty()) {
    std::string absolute =
        FilePathToUTF8(Resolve(UTF8ToFilePath(source_root)).AppendASCII(
            str.as_string()).value());
    NormalizePath(&absolute);
    if (!MakeAbsolutePathRelativeIfPossible(source_root, absolute,
                                            &ret.value_)) {
#if defined(OS_WIN)
      if (absolute[0] != '/')  // See the file case for why we do this check.
        ret.value_ = "/";
#endif
      ret.value_.append(absolute.data(), absolute.size());
    }
    if (!EndsWithSlash(ret.value_))
      ret.value_.push_back('/');
    return ret;
  }

  ret.value_.reserve(value_.size() + str.size());
  ret.value_.assign(value_);
  ret.value_.append(str.data(), str.size());

  NormalizePath(&ret.value_);
  if (!EndsWithSlash(ret.value_))
    ret.value_.push_back('/');
  AssertValueSourceDirString(ret.value_);

  return ret;
}

base::FilePath SourceDir::Resolve(const base::FilePath& source_root) const {
  if (is_null())
    return base::FilePath();

  std::string converted;
  if (is_system_absolute()) {
    if (value_.size() > 2 && value_[2] == ':') {
      // Windows path, strip the leading slash.
      converted.assign(&value_[1], value_.size() - 1);
    } else {
      converted.assign(value_);
    }
    return base::FilePath(UTF8ToFilePath(converted));
  }

  // String the double-leading slash for source-relative paths.
  converted.assign(&value_[2], value_.size() - 2);
  return source_root.Append(UTF8ToFilePath(converted))
      .NormalizePathSeparatorsTo('/');
}

void SourceDir::SwapValue(std::string* v) {
  value_.swap(*v);
  AssertValueSourceDirString(value_);
}