# Copyright 2015 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.

import os


class DuplicateDependencyFoundException(Exception):
  """Two potentially matching files have been found that could satisfy this
  dependency, so the right one cannot be selected automatically."""
  pass


class DependencyNotFoundException(Exception):
  """The dependency hasn't been found on the local filesystem."""
  pass


class Dependency(object):
  """Dependency represents an import request from one mojom file to another.
  """
  def __init__(self, repository, importer, imported):
    self._repository = repository
    self._importer_filename = os.path.normpath(importer)
    self._imported_filename = os.path.normpath(imported)

  def __str__(self):
    return str(self.__dict__)

  def __eq__(self, other):
    return self.__dict__ == other.__dict__

  def get_importer(self):
    """Returns the name and full path of the file doing the import."""
    return self._importer_filename

  def get_imported(self):
    """Returns the imported file (filename and path)."""
    return self._imported_filename

  def is_sdk_dep(self):
    """Returns whether this dependency is from the mojo SDK."""
    return (self._imported_filename.startswith("mojo/public/") or
            self._imported_filename.startswith("//mojo/public/"))

  def _is_in_external(self):
    """Returns whether this dependency is under the external directory."""
    common = os.path.commonprefix((self._repository.get_external_directory(),
                                   self._importer_filename))
    return common == self._repository.get_external_directory()

  def maybe_is_a_url(self):
    """Returns whether this dependency may be pointing to a downloadable
    ressource."""
    if self._is_in_external() and not self.is_sdk_dep():
      # External dependencies may refer to other dependencies by relative path,
      # so they can always be URLs.
      return True

    base, _ = self._imported_filename.split(os.path.sep, 1)
    if not '.' in base:
      # There is no dot separator in the first part of the path; it cannot be a
      # URL.
      return False
    return True

  def generate_candidate_urls(self):
    """Generates possible paths where to download this dependency. It is
    expected that at most one of them should work."""
    candidates = []

    base, _ = self._imported_filename.split(os.path.sep, 1)
    if '.' in base and not base.startswith('.'):
      # This import may be an absolute URL path (without scheme).
      candidates.append(self._imported_filename)

    # External dependencies may refer to other dependencies by relative path.
    if self._is_in_external():
      directory = os.path.relpath(os.path.dirname(self._importer_filename),
                                  self._repository.get_external_directory())

      # This is to handle the case where external dependencies use
      # imports relative to a directory upper in the directory structure. As we
      # don't know which directory, we need to go through all of them.
      while len(directory) > 0:
        candidates.append(os.path.join(directory, self._imported_filename))
        directory = os.path.dirname(directory)
    return candidates

  def get_search_path_for_dependency(self):
    """Return all possible search paths for this dependency."""

    # Root directory and external directory are always included.
    search_paths = set([self._repository.get_repo_root_directory(),
                        self._repository.get_external_directory()])
    # Local import paths
    search_paths.add(os.path.dirname(self._importer_filename))

    if self._is_in_external():
      directory = os.path.dirname(self._importer_filename)

      # This is to handle the case where external dependencies use
      # imports relative to a directory upper in the directory structure. As we
      # don't know which directory, we need to go through all of them.
      while self._repository.get_external_directory() in directory:
        search_paths.add(directory)
        directory = os.path.dirname(directory)
    return search_paths

  def is_sdk_dep(self):
    """Returns whether this dependency is from the mojo SDK."""
    return self._imported_filename.startswith("mojo/public/")

  def _os_path_exists(self, path):
    return os.path.exists(path)

  def get_target_and_import(self, extra_import_dirs):
    """Returns a tuple (target, import_directory) for this dependency.
    import_directory may be Null. extra_import_dirs lists directories that
    should be searched for this dependency in addition to the ones directly
    above the importing file.
    """
    directory = os.path.dirname(self.get_importer())
    if self.is_sdk_dep():
      return (os.path.dirname(self.get_imported()), None)

    # We need to determine if it is a relative path or not
    if self._os_path_exists(os.path.join(directory, self.get_imported())):
      # This is a relative import path
      dependency_path = os.path.normpath(os.path.join(directory,
                                                      self.get_imported()))
      return (target_from_path(os.path.relpath(dependency_path, directory)),
              None)

    if self._os_path_exists(
        os.path.join(self._repository.get_external_directory(),
                     self.get_imported())):
      # This is an "absolute" external dependency, specified by full path
      # relative to the external directory.
      return (target_from_path(
          "//" + os.path.join(self._repository.get_external_suffix(),
                              self.get_imported())), None)

    # We assume that the dependency is specified relative to a directory
    # above this one, so we search all of them for a correspondence. If we
    # find one, we return an import directory.
    result = None
    for import_dir_candidate in (list(self.get_search_path_for_dependency())
                                  + extra_import_dirs):
      dep_mojom_path = os.path.join(
          import_dir_candidate, self.get_imported())
      if self._os_path_exists(dep_mojom_path):
        if result != None:
          raise DuplicateDependencyFoundException(self.get_imported())
        import_dir = os.path.relpath(import_dir_candidate, directory)
        result = (target_from_path(os.path.relpath(
            dep_mojom_path, directory)), import_dir)
    if result == None:
      raise DependencyNotFoundException(self.get_imported())
    return result


def group_target_name(directory):
  """Returns the name of the group target for a given directory."""
  return os.path.basename(directory)

def _target_dir_from_path(path):
  directory, filename = os.path.split(path)
  target, _ = os.path.splitext(filename)
  if target == group_target_name(directory):
    target = target + "_mojom"
  return directory, target

def target_name_from_path(path):
  return _target_dir_from_path(path)[1]


def target_from_path(path):
  return ':'.join(_target_dir_from_path(path))