// Copyright 2016 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

#include <algorithm>
#include <functional>
#include <memory>
#include <string>

#include "src/main/native/windows/util.h"

namespace bazel {
namespace windows {

using std::function;
using std::string;
using std::unique_ptr;
using std::wstring;

string GetLastErrorString(const string& cause) {
  DWORD last_error = GetLastError();
  if (last_error == 0) {
    return "";
  }

  LPSTR message;
  DWORD size = FormatMessageA(
      FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
          FORMAT_MESSAGE_IGNORE_INSERTS,
      NULL, last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
      (LPSTR)&message, 0, NULL);

  if (size == 0) {
    char buf[256];
    snprintf(buf, sizeof(buf),
             "%s: Error %d (cannot format message due to error %d)",
             cause.c_str(), last_error, GetLastError());
    buf[sizeof(buf) - 1] = 0;
  }

  string result = string(message);
  LocalFree(message);
  return cause + ": " + result;
}

static void QuotePath(const string& path, string* result) {
  *result = string("\"") + path + "\"";
}

static bool IsSeparator(char c) { return c == '/' || c == '\\'; }

static bool HasSeparator(const string& s) {
  return s.find_first_of('/') != string::npos ||
         s.find_first_of('\\') != string::npos;
}

static bool Contains(const string& s, const char* substr) {
  return s.find(substr) != string::npos;
}

string AsShortPath(string path, function<wstring()> path_as_wstring,
                   string* result) {
  if (path.empty()) {
    result->clear();
    return "";
  }
  if (path[0] == '"') {
    return string("path should not be quoted");
  }
  if (IsSeparator(path[0])) {
    return string("path='") + path + "' is absolute";
  }
  if (Contains(path, "/./") || Contains(path, "\\.\\") ||
      Contains(path, "/..") || Contains(path, "\\..")) {
    return string("path='") + path + "' is not normalized";
  }
  if (path.size() >= MAX_PATH && !HasSeparator(path)) {
    return string("path='") + path + "' is just a file name but too long";
  }
  if (HasSeparator(path) &&
      !(isalpha(path[0]) && path[1] == ':' && IsSeparator(path[2]))) {
    return string("path='") + path + "' is not an absolute path";
  }
  // At this point we know the path is either just a file name (shorter than
  // MAX_PATH), or an absolute, normalized, Windows-style path (of any length).

  std::replace(path.begin(), path.end(), '/', '\\');
  // Fast-track: the path is already short.
  if (path.size() < MAX_PATH) {
    *result = path;
    return "";
  }
  // At this point we know that the path is at least MAX_PATH long and that it's
  // absolute, normalized, and Windows-style.

  // Retrieve string as UTF-16 path, add "\\?\" prefix.
  wstring wlong = wstring(L"\\\\?\\") + path_as_wstring();

  // Experience shows that:
  // - GetShortPathNameW's result has a "\\?\" prefix if and only if the input
  //   did too (though this behavior is not documented on MSDN)
  // - CreateProcess{A,W} only accept an executable of MAX_PATH - 1 length
  // Therefore for our purposes the acceptable shortened length is
  // MAX_PATH + 4 (null-terminated). That is, MAX_PATH - 1 for the shortened
  // path, plus a potential "\\?\" prefix that's only there if `wlong` also had
  // it and which we'll omit from `result`, plus a null terminator.
  static const size_t kMaxShortPath = MAX_PATH + 4;

  WCHAR wshort[kMaxShortPath];
  DWORD wshort_size = ::GetShortPathNameW(wlong.c_str(), NULL, 0);
  if (wshort_size == 0) {
    return GetLastErrorString(string("GetShortPathName failed (path=") + path +
                              ")");
  }

  if (wshort_size >= kMaxShortPath) {
    return string("GetShortPathName would not shorten the path enough (path=") +
           path + ")";
  }
  GetShortPathNameW(wlong.c_str(), wshort, kMaxShortPath);

  // Convert the result to UTF-8.
  char mbs_short[MAX_PATH];
  size_t mbs_size = wcstombs(
      mbs_short,
      wshort + 4,  // we know it has a "\\?\" prefix, because `wlong` also did
      MAX_PATH);
  if (mbs_size < 0 || mbs_size >= MAX_PATH) {
    return string("wcstombs failed (path=") + path + ")";
  }
  mbs_short[mbs_size] = 0;

  *result = mbs_short;
  return "";
}

string AsExecutablePathForCreateProcess(const string& path,
                                        function<wstring()> path_as_wstring,
                                        string* result) {
  if (path.empty()) {
    return string("path should not be empty");
  }
  string error = AsShortPath(path, path_as_wstring, result);
  if (error.empty()) {
    // Quote the path in case it's something like "c:\foo\app name.exe".
    // Do this unconditionally, there's no harm in quoting. Quotes are not
    // allowed inside paths so we don't need to escape quotes.
    QuotePath(*result, result);
  }
  return error;
}

}  // namespace windows
}  // namespace bazel