from collections import defaultdict

# FIXME doesn't account for venv linked to global site-packages

if sys.platform == 'win32':

    lib_py = os.path.join(sys.prefix, 'Lib')

else:

    lib_py = os.path.join(sys.prefix, 'lib', 'python%s' % sys.version[:3])

class UninstallCommand(Command):

    name = 'uninstall'

    usage = '%prog [OPTIONS] PACKAGE_NAMES ...'

    summary = 'Uninstall packages'

    def __init__(self):

        super(UninstallCommand, self).__init__()

        self.parser.add_option(

            '-r', '--requirement',

            dest='requirements',

            action='append',

            default=[],

            metavar='FILENAME',

            help='Uninstall all the packages listed in the given requirements file.  '

            'This option can be used multiple times.')

        self.parser.add_option(

            '-y', '--yes',

            dest='yes',

            action='store_true',

            help="Don't ask for confirmation of uninstall deletions. "

            "If this breaks your system, you get to keep the pieces.")

    def run(self, options, args):

        requirement_set = RequirementSet(

            build_dir=None,

            src_dir=None)

        for name in args:

            requirement_set.add_requirement(

                InstallRequirement.from_line(name))

        for filename in options.requirements:

            for req in parse_requirements(filename):

                requirement_set.add_requirement(req)

        requirement_set.uninstall(auto_confirm=options.yes)

UninstallCommand()

    def uninstall(self, auto_confirm=False):

        """

        Uninstall the distribution currently satisfying this requirement.

        Prompts before removing or modifying files unless

        ``auto_confirm`` is True.

        Refuses to delete or modify files outside of ``sys.prefix`` -

        thus uninstallation within a virtual environment can only

        modify that virtual environment, even if the virtualenv is

        linked to global site-packages.

        """

        assert self.check_if_exists(), "Cannot uninstall requirement %s, not installed" % (self.name,)

        dist = self.satisfied_by

        paths_to_remove = set()

        entries_to_remove = defaultdict(set)

        logger.notify('Uninstalling %s' % self.name)

        logger.indent += 2

        try:

            pip_egg_info_path = os.path.join(dist.location,

                                             dist.egg_name()) + '.egg-info'

            easy_install_egg = dist.egg_name() + '.egg'

            # FIXME this won't find a globally-installed develop egg

            # if we're in a virtualenv (lib_py is based on

            # sys.prefix).  (There doesn't seem to be any metadata in

            # the Distribution object for a develop egg that points

            # back to its .egg-link and easy-install.pth files).

            # That's OK, because we restrict ourselves to making

            # changes within sys.prefix anyway.

            develop_egg_link = os.path.join(lib_py, 'site-packages',

                                            dist.project_name) + '.egg-link'

            if os.path.exists(pip_egg_info_path):

                # package installed by pip

                paths_to_remove.add(pip_egg_info_path)

                if dist.has_metadata('installed-files.txt'):

                    for installed_file in dist.get_metadata('installed-files.txt').splitlines():

                        path = os.path.normpath(os.path.join(pip_egg_info_path, installed_file))

                        if os.path.exists(path):

                            paths_to_remove.add(path)

                if dist.has_metadata('top_level.txt'):

                    for top_level_pkg in [p for p

                                          in dist.get_metadata('top_level.txt').splitlines()

                                          if p]:

                        path = os.path.join(dist.location, top_level_pkg)

                        if os.path.exists(path):

                            paths_to_remove.add(path)

                        elif os.path.exists(path + '.py'):

                            paths_to_remove.add(path + '.py')

                            if os.path.exists(path + '.pyc'):

                                paths_to_remove.add(path + '.pyc')

            elif dist.location.endswith(easy_install_egg):

                # package installed by easy_install

                paths_to_remove.add(dist.location)

                easy_install_pth = os.path.join(os.path.dirname(dist.location),

                                                'easy-install.pth')

                entries_to_remove[easy_install_pth].add('./' + easy_install_egg)

            elif os.path.isfile(develop_egg_link):

                # develop egg

                fh = open(develop_egg_link, 'r')

                link_pointer = fh.readline().strip()

                fh.close()

                assert (link_pointer == dist.location), 'Egg-link %s does not match installed location of %s (at %s)' % (link_pointer, self.name, dist.location)

                paths_to_remove.add(develop_egg_link)

                easy_install_pth = os.path.join(os.path.dirname(develop_egg_link),

                                                'easy-install.pth')

                entries_to_remove[easy_install_pth].add(dist.location)

            for filename, entries in entries_to_remove.items():

                if strip_sys_prefix(filename) is None:

                    logger.notify('Will not modify %s, outside local environment.' % filename)

                    continue

                remove_entries_from_file(filename, entries, auto_confirm)

            to_remove = set()

            for path in paths_to_remove:

                if strip_sys_prefix(path) is None:

                    logger.notify('Will not remove %s, outside of local environment.' % path)

                else:

                    to_remove.add(path)

            if to_remove:

                remove_paths(to_remove, auto_confirm)

        finally:

            logger.indent -= 2

    def uninstall(self, auto_confirm=False):

        for req in self.requirements.values():

            req.uninstall(auto_confirm=auto_confirm)

def parse_requirements(filename, finder=None, comes_from=None):

        elif finder and line.startswith('-f') or line.startswith('--find-links'):

def strip_sys_prefix(path):

    """ If ``path`` begins with sys.prefix, return ``path`` with

    sys.prefix stripped off.  Otherwise return None."""

    sys_prefix = os.path.realpath(sys.prefix)

    if path.startswith(sys_prefix):

        return path.replace(sys_prefix, '')

    return None

def remove_entries_from_file(filename, entries, auto_confirm=True):

    """Remove ``entries`` from text file ``filename``, with

    confirmation (unless ``auto_confirm`` is True)."""

    assert os.path.isfile(filename), "Cannot remove entries from nonexistent file %s" % filename

    logger.notify('Removing entries from %s:' % filename)

    logger.indent += 2

    try:

        if auto_confirm:

            response = 'y'

        else:

            for entry in entries:

                logger.notify(entry)

            response = ask('Proceed with removal (y/n)? ', ('y', 'n'))

        if response == 'y':

            fh = open(filename, 'r')

            lines = fh.readlines()

            fh.close()

            try:

                for entry in entries:

                    logger.notify('Removing entry: %s' % entry)

                try:

                    lines.remove(entry + '\n')

                except ValueError:

                    pass

            finally:

                pass

            fh = open(filename, 'w')

            fh.writelines(lines)

            fh.close()

    finally:

        logger.indent -= 2        

def remove_paths(paths, auto_confirm=False):

    """Remove paths in iterable ``paths`` with confirmation

    (unless ``auto_confirm`` is True)."""

    logger.notify('Within environment %s, removing:' % os.path.realpath(sys.prefix))

    logger.indent += 2

    try:

        if auto_confirm:

            response = 'y'

        else:

            for path in sorted(paths):

                logger.notify(strip_sys_prefix(path))

            response = ask('Proceed with removal (y/n)? ', ('y', 'n'))

        if response == 'y':

            for path in sorted(paths):

                if os.path.isdir(path):

                    logger.notify('Removing directory %s' % strip_sys_prefix(path))

                    shutil.rmtree(path)

                elif os.path.isfile(path):

                    logger.notify('Removing file %s' % strip_sys_prefix(path))

                    os.remove(path)

    finally:

        logger.indent -= 2