#
# Copyright (C) 2008 The Android Open Source Project
#
# 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.

import os
import optparse
import platform
import re
import sys

from error import NoSuchProjectError
from error import InvalidProjectGroupsError


class Command(object):
 """Base class for any command line action in repo.
 """

 common = False
 manifest = None
 _optparse = None

 def WantPager(self, opt):
 return False

 def ReadEnvironmentOptions(self, opts):
 """ Set options from environment variables. """

 env_options = self._RegisteredEnvironmentOptions()

 for env_key, opt_key in env_options.items():
 # Get the user-set option value if any
 opt_value = getattr(opts, opt_key)

 # If the value is set, it means the user has passed it as a command
 # line option, and we should use that. Otherwise we can try to set it
 # with the value from the corresponding environment variable.
 if opt_value is not None:
 continue

 env_value = os.environ.get(env_key)
 if env_value is not None:
 setattr(opts, opt_key, env_value)

 return opts

 @property
 def OptionParser(self):
 if self._optparse is None:
 try:
 me = 'repo %s' % self.NAME
 usage = self.helpUsage.strip().replace('%prog', me)
 except AttributeError:
 usage = 'repo %s' % self.NAME
 self._optparse = optparse.OptionParser(usage = usage)
 self._Options(self._optparse)
 return self._optparse

 def _Options(self, p):
 """Initialize the option parser.
 """

 def _RegisteredEnvironmentOptions(self):
 """Get options that can be set from environment variables.

 Return a dictionary mapping environment variable name
 to option key name that it can override.

 Example: {'REPO_MY_OPTION': 'my_option'}

 Will allow the option with key value 'my_option' to be set
 from the value in the environment variable named 'REPO_MY_OPTION'.

 Note: This does not work properly for options that are explicitly
 set to None by the user, or options that are defined with a
 default value other than None.

 """
 return {}

 def Usage(self):
 """Display usage and terminate.
 """
 self.OptionParser.print_usage()
 sys.exit(1)

 def Execute(self, opt, args):
 """Perform the action, after option parsing is complete.
 """
 raise NotImplementedError

 def _ResetPathToProjectMap(self, projects):
 self._by_path = dict((p.worktree, p) for p in projects)

 def _UpdatePathToProjectMap(self, project):
 self._by_path[project.worktree] = project

 def _GetProjectByPath(self, path):
 project = None
 if os.path.exists(path):
 oldpath = None
 while path \
 and path != oldpath \
 and path != self.manifest.topdir:
 try:
 project = self._by_path[path]
 break
 except KeyError:
 oldpath = path
 path = os.path.dirname(path)
 else:
 try:
 project = self._by_path[path]
 except KeyError:
 pass
 return project

 def GetProjects(self, args, missing_ok=False, submodules_ok=False):
 """A list of projects that match the arguments.
 """
 all_projects_list = self.manifest.projects
 result = []

 mp = self.manifest.manifestProject

 groups = mp.config.GetString('manifest.groups')
 if not groups:
 groups = 'default,platform-' + platform.system().lower()
 groups = [x for x in re.split(r'[,\s]+', groups) if x]

 if not args:
 derived_projects = {}
 for project in all_projects_list:
 if submodules_ok or project.sync_s:
 derived_projects.update((p.name, p)
 for p in project.GetDerivedSubprojects())
 all_projects_list.extend(derived_projects.values())
 for project in all_projects_list:
 if ((missing_ok or project.Exists) and
 project.MatchesGroups(groups)):
 result.append(project)
 else:
 self._ResetPathToProjectMap(all_projects_list)

 for arg in args:
 projects = self.manifest.GetProjectsWithName(arg)

 if not projects:
 path = os.path.abspath(arg).replace('\\', '/')
 project = self._GetProjectByPath(path)

 # If it's not a derived project, update path->project mapping and
 # search again, as arg might actually point to a derived subproject.
 if (project and not project.Derived and
 (submodules_ok or project.sync_s)):
 search_again = False
 for subproject in project.GetDerivedSubprojects():
 self._UpdatePathToProjectMap(subproject)
 search_again = True
 if search_again:
 project = self._GetProjectByPath(path) or project

 if project:
 projects = [project]

 if not projects:
 raise NoSuchProjectError(arg)

 for project in projects:
 if not missing_ok and not project.Exists:
 raise NoSuchProjectError(arg)
 if not project.MatchesGroups(groups):
 raise InvalidProjectGroupsError(arg)

 result.extend(projects)

 def _getpath(x):
 return x.relpath
 result.sort(key=_getpath)
 return result

 def FindProjects(self, args):
 result = []
 patterns = [re.compile(r'%s' % a, re.IGNORECASE) for a in args]
 for project in self.GetProjects(''):
 for pattern in patterns:
 if pattern.search(project.name) or pattern.search(project.relpath):
 result.append(project)
 break
 result.sort(key=lambda project: project.relpath)
 return result

# pylint: disable=W0223
# Pylint warns that the `InteractiveCommand` and `PagedCommand` classes do not
# override method `Execute` which is abstract in `Command`. Since that method
# is always implemented in classes derived from `InteractiveCommand` and
# `PagedCommand`, this warning can be suppressed.
class InteractiveCommand(Command):
 """Command which requires user interaction on the tty and
 must not run within a pager, even if the user asks to.
 """
 def WantPager(self, opt):
 return False

class PagedCommand(Command):
 """Command which defaults to output in a pager, as its
 display tends to be larger than one screen full.
 """
 def WantPager(self, opt):
 return True

# pylint: enable=W0223

class MirrorSafeCommand(object):
 """Command permits itself to run within a mirror,
 and does not require a working directory.
 """