# -*- coding: utf-8 -*-
'''
Classes for working with Windows Update Agent
'''
# Import Python libs
from __future__ import absolute_import, print_function, unicode_literals
import logging
import subprocess

# Import Salt libs
import salt.utils.args
import salt.utils.data
import salt.utils.winapi
from salt.ext import six
from salt.ext.six.moves import range
from salt.exceptions import CommandExecutionError

# Import 3rd-party libs
try:
    import win32com.client
    import pywintypes
    HAS_PYWIN32 = True
except ImportError:
    HAS_PYWIN32 = False

log = logging.getLogger(__name__)

__virtualname__ = 'win_update'


def __virtual__():
    if not salt.utils.platform.is_windows():
        return False, 'win_update: Not available on Windows'
    if not HAS_PYWIN32:
        return False, 'win_update: Missing pywin32'
    return __virtualname__


class Updates(object):
    '''
    Wrapper around the 'Microsoft.Update.UpdateColl' instance
    Adds the list and summary functions. For use by the WindowUpdateAgent class.

    Usage:
    .. code-block:: python

        # Create an instance
        updates = Updates()

        # Bind to the collection object
        found = updates.updates

        # This exposes Collections properties and methods
        # https://msdn.microsoft.com/en-us/library/windows/desktop/aa386107(v=vs.85).aspx
        found.Count
        found.Add

        # To use custom functions, use the original instance
        # Return the number of updates inside the collection
        updates.count()

        # Return a list of updates in the collection and details in a dictionary
        updates.list()

        # Return a summary of the contents of the updates collection
        updates.summary()
    '''

    update_types = {1: 'Software',
                    2: 'Driver'}

    reboot_behavior = {0: 'Never Requires Reboot',
                       1: 'Always Requires Reboot',
                       2: 'Can Require Reboot'}

    def __init__(self):
        '''
        Initialize the updates collection. Can be accessed via
        ``Updates.updates``
        '''
        with salt.utils.winapi.Com():
            self.updates = win32com.client.Dispatch('Microsoft.Update.UpdateColl')

    def count(self):
        '''
        Return how many records are in the Microsoft Update Collection

        Returns:
            int: The number of updates in the collection

        Code Example:

        .. code-block:: python

            import salt.utils.win_update
            updates = salt.utils.win_update.Updates()
            updates.count()
        '''
        return self.updates.Count

    def list(self):
        '''
        Create a dictionary with the details for the updates in the collection.

        Returns:
            dict: Details about each update

        .. code-block:: cfg

            List of Updates:
            {'<GUID>': {'Title': <title>,
                        'KB': <KB>,
                        'GUID': <the globally unique identifier for the update>
                        'Description': <description>,
                        'Downloaded': <has the update been downloaded>,
                        'Installed': <has the update been installed>,
                        'Mandatory': <is the update mandatory>,
                        'UserInput': <is user input required>,
                        'EULAAccepted': <has the EULA been accepted>,
                        'Severity': <update severity>,
                        'NeedsReboot': <is the update installed and awaiting reboot>,
                        'RebootBehavior': <will the update require a reboot>,
                        'Categories': [ '<category 1>',
                                        '<category 2>',
                                        ...]
                        }
            }

        Code Example:

        .. code-block:: python

            import salt.utils.win_update
            updates = salt.utils.win_update.Updates()
            updates.list()
        '''
        # https://msdn.microsoft.com/en-us/library/windows/desktop/aa386099(v=vs.85).aspx
        if self.count() == 0:
            return 'Nothing to return'

        log.debug('Building a detailed report of the results.')

        # Build a dictionary containing details for each update
        results = {}
        for update in self.updates:

            results[update.Identity.UpdateID] = {
                'guid': update.Identity.UpdateID,
                'Title': six.text_type(update.Title),
                'Type': self.update_types[update.Type],
                'Description': update.Description,
                'Downloaded': bool(update.IsDownloaded),
                'Installed': bool(update.IsInstalled),
                'Mandatory': bool(update.IsMandatory),
                'EULAAccepted': bool(update.EulaAccepted),
                'NeedsReboot': bool(update.RebootRequired),
                'Severity': six.text_type(update.MsrcSeverity),
                'UserInput':
                    bool(update.InstallationBehavior.CanRequestUserInput),
                'RebootBehavior':
                    self.reboot_behavior[
                        update.InstallationBehavior.RebootBehavior],
                'KBs': ['KB' + item for item in update.KBArticleIDs],
                'Categories': [item.Name for item in update.Categories]
            }

        return results

    def summary(self):
        '''
        Create a dictionary with a summary of the updates in the collection.

        Returns:
            dict: Summary of the contents of the collection

        .. code-block:: cfg

            Summary of Updates:
            {'Total': <total number of updates returned>,
             'Available': <updates that are not downloaded or installed>,
             'Downloaded': <updates that are downloaded but not installed>,
             'Installed': <updates installed (usually 0 unless installed=True)>,
             'Categories': { <category 1>: <total for that category>,
                             <category 2>: <total for category 2>,
                             ... }
            }
        Code Example:

        .. code-block:: python

            import salt.utils.win_update
            updates = salt.utils.win_update.Updates()
            updates.summary()
        '''
        # https://msdn.microsoft.com/en-us/library/windows/desktop/aa386099(v=vs.85).aspx
        if self.count() == 0:
            return 'Nothing to return'

        # Build a dictionary containing a summary of updates available
        results = {'Total': 0,
                   'Available': 0,
                   'Downloaded': 0,
                   'Installed': 0,
                   'Categories': {},
                   'Severity': {}}

        for update in self.updates:

            # Count the total number of updates available
            results['Total'] += 1

            # Updates available for download
            if not salt.utils.data.is_true(update.IsDownloaded) \
                    and not salt.utils.data.is_true(update.IsInstalled):
                results['Available'] += 1

            # Updates downloaded awaiting install
            if salt.utils.data.is_true(update.IsDownloaded) \
                    and not salt.utils.data.is_true(update.IsInstalled):
                results['Downloaded'] += 1

            # Updates installed
            if salt.utils.data.is_true(update.IsInstalled):
                results['Installed'] += 1

            # Add Categories and increment total for each one
            # The sum will be more than the total because each update can have
            # multiple categories
            for category in update.Categories:
                if category.Name in results['Categories']:
                    results['Categories'][category.Name] += 1
                else:
                    results['Categories'][category.Name] = 1

            # Add Severity Summary
            if update.MsrcSeverity:
                if update.MsrcSeverity in results['Severity']:
                    results['Severity'][update.MsrcSeverity] += 1
                else:
                    results['Severity'][update.MsrcSeverity] = 1

        return results


class WindowsUpdateAgent(object):
    '''
    Class for working with the Windows update agent

    '''
    # Error codes found at the following site:
    # https://msdn.microsoft.com/en-us/library/windows/desktop/hh968413(v=vs.85).aspx
    # https://technet.microsoft.com/en-us/library/cc720442(v=ws.10).aspx
    fail_codes = {-2145107924: 'WinHTTP Send/Receive failed: 0x8024402C',
                  -2145124300: 'Download failed: 0x80240034',
                  -2145124302: 'Invalid search criteria: 0x80240032',
                  -2145124305: 'Cancelled by policy: 0x8024002F',
                  -2145124307: 'Missing source: 0x8024002D',
                  -2145124308: 'Missing source: 0x8024002C',
                  -2145124312: 'Uninstall not allowed: 0x80240028',
                  -2145124315: 'Prevented by policy: 0x80240025',
                  -2145124316: 'No Updates: 0x80240024',
                  -2145124322: 'Service being shutdown: 0x8024001E',
                  -2145124325: 'Self Update in Progress: 0x8024001B',
                  -2145124327: 'Exclusive Install Conflict: 0x80240019',
                  -2145124330: 'Install not allowed: 0x80240016',
                  -2145124333: 'Duplicate item: 0x80240013',
                  -2145124341: 'Operation cancelled: 0x8024000B',
                  -2145124343: 'Operation in progress: 0x80240009',
                  -2145124284: 'Access Denied: 0x8024044',
                  -2145124283: 'Unsupported search scope: 0x80240045',
                  -2147024891: 'Access is denied: 0x80070005',
                  -2149843018: 'Setup in progress: 0x8024004A',
                  -4292599787: 'Install still pending: 0x00242015',
                  -4292607992: 'Already downloaded: 0x00240008',
                  -4292607993: 'Already uninstalled: 0x00240007',
                  -4292607994: 'Already installed: 0x00240006',
                  -4292607995: 'Reboot required: 0x00240005'}

    def __init__(self):
        '''
        Initialize the session and load all updates into the ``_updates``
        collection. This collection is used by the other class functions instead
        of querying Windows update (expensive).

        Need to look at the possibility of loading this into ``__context__``
        '''
        # Initialize the PyCom system
        with salt.utils.winapi.Com():

            # Create a session with the Windows Update Agent
            self._session = win32com.client.Dispatch('Microsoft.Update.Session')

            # Create Collection for Updates
            self._updates = win32com.client.Dispatch('Microsoft.Update.UpdateColl')

        self.refresh()

    def updates(self):
        '''
        Get the contents of ``_updates`` (all updates) and puts them in an
        Updates class to expose the list and summary functions.

        Returns:
            Updates: An instance of the Updates class with all updates for the
            system.

        .. code-block:: python

            import salt.utils.win_update
            wua = salt.utils.win_update.WindowsUpdateAgent()
            updates = wua.updates()

            # To get a list
            updates.list()

            # To get a summary
            updates.summary()
        '''
        updates = Updates()
        found = updates.updates

        for update in self._updates:
            found.Add(update)

        return updates

    def refresh(self):
        '''
        Refresh the contents of the ``_updates`` collection. This gets all
        updates in the Windows Update system and loads them into the collection.
        This is the part that is slow.

        Code Example:

        .. code-block:: python

            import salt.utils.win_update
            wua = salt.utils.win_update.WindowsUpdateAgent()
            wua.refresh()
        '''
        # https://msdn.microsoft.com/en-us/library/windows/desktop/aa386526(v=vs.85).aspx
        search_string = 'Type=\'Software\' or ' \
                        'Type=\'Driver\''

        # Create searcher object
        searcher = self._session.CreateUpdateSearcher()
        self._session.ClientApplicationID = 'Salt: Load Updates'

        # Load all updates into the updates collection
        try:
            results = searcher.Search(search_string)
            if results.Updates.Count == 0:
                log.debug('No Updates found for:\n\t\t%s', search_string)
                return 'No Updates found: {0}'.format(search_string)
        except pywintypes.com_error as error:
            # Something happened, raise an error
            hr, msg, exc, arg = error.args  # pylint: disable=W0633
            try:
                failure_code = self.fail_codes[exc[5]]
            except KeyError:
                failure_code = 'Unknown Failure: {0}'.format(error)

            log.error('Search Failed: %s\n\t\t%s', failure_code, search_string)
            raise CommandExecutionError(failure_code)

        self._updates = results.Updates

    def available(self,
                  skip_hidden=True,
                  skip_installed=True,
                  skip_mandatory=False,
                  skip_reboot=False,
                  software=True,
                  drivers=True,
                  categories=None,
                  severities=None):
        '''
        Gets a list of all updates available on the system that match the passed
        criteria.

        Args:

            skip_hidden (bool): Skip hidden updates. Default is True

            skip_installed (bool): Skip installed updates. Default is True

            skip_mandatory (bool): Skip mandatory updates. Default is False

            skip_reboot (bool): Skip updates that can or do require reboot.
            Default is False

            software (bool): Include software updates. Default is True

            drivers (bool): Include driver updates. Default is True

            categories (list): Include updates that have these categories.
            Default is none (all categories).

                Categories include the following:

                * Critical Updates
                * Definition Updates
                * Drivers (make sure you set drivers=True)
                * Feature Packs
                * Security Updates
                * Update Rollups
                * Updates
                * Update Rollups
                * Windows 7
                * Windows 8.1
                * Windows 8.1 drivers
                * Windows 8.1 and later drivers
                * Windows Defender

            severities (list): Include updates that have these severities.
            Default is none (all severities).

                Severities include the following:

                * Critical
                * Important

        .. note:: All updates are either software or driver updates. If both
        ``software`` and ``drivers`` is False, nothing will be returned.

        Returns:

            Updates: An instance of Updates with the results of the search.

        Code Example:

        .. code-block:: python

            import salt.utils.win_update
            wua = salt.utils.win_update.WindowsUpdateAgent()

            # Gets all updates and shows a summary
            updates = wua.available
            updates.summary()

            # Get a list of Critical updates
            updates = wua.available(categories=['Critical Updates'])
            updates.list()
        '''
        # https://msdn.microsoft.com/en-us/library/windows/desktop/aa386099(v=vs.85).aspx
        updates = Updates()
        found = updates.updates

        for update in self._updates:

            if salt.utils.data.is_true(update.IsHidden) and skip_hidden:
                continue

            if salt.utils.data.is_true(update.IsInstalled) and skip_installed:
                continue

            if salt.utils.data.is_true(update.IsMandatory) and skip_mandatory:
                continue

            if salt.utils.data.is_true(
                    update.InstallationBehavior.RebootBehavior) and skip_reboot:
                continue

            if not software and update.Type == 1:
                continue

            if not drivers and update.Type == 2:
                continue

            if categories is not None:
                match = False
                for category in update.Categories:
                    if category.Name in categories:
                        match = True
                if not match:
                    continue

            if severities is not None:
                if update.MsrcSeverity not in severities:
                    continue

            found.Add(update)

        return updates

    def search(self, search_string):
        '''
        Search for either a single update or a specific list of updates. GUIDs
        are searched first, then KB numbers, and finally Titles.

        Args:

            search_string (str, list): The search string to use to find the
            update. This can be the GUID or KB of the update (preferred). It can
            also be the full Title of the update or any part of the Title. A
            partial Title search is less specific and can return multiple
            results.

        Returns:
            Updates: An instance of Updates with the results of the search

        Code Example:

        .. code-block:: python

            import salt.utils.win_update
            wua = salt.utils.win_update.WindowsUpdateAgent()

            # search for a single update and show its details
            updates = wua.search('KB3194343')
            updates.list()

            # search for a list of updates and show their details
            updates = wua.search(['KB3195432', '12345678-abcd-1234-abcd-1234567890ab'])
            updates.list()
        '''
        updates = Updates()
        found = updates.updates

        if isinstance(search_string, six.string_types):
            search_string = [search_string]

        if isinstance(search_string, six.integer_types):
            search_string = [six.text_type(search_string)]

        for update in self._updates:

            for find in search_string:

                # Search by GUID
                if find == update.Identity.UpdateID:
                    found.Add(update)
                    continue

                # Search by KB
                if find in ['KB' + item for item in update.KBArticleIDs]:
                    found.Add(update)
                    continue

                # Search by KB without the KB in front
                if find in [item for item in update.KBArticleIDs]:
                    found.Add(update)
                    continue

                # Search by Title
                if find in update.Title:
                    found.Add(update)
                    continue

        return updates

    def download(self, updates):
        '''
        Download the updates passed in the updates collection. Load the updates
        collection using ``search`` or ``available``

        Args:

            updates (Updates): An instance of the Updates class containing a
            the updates to be downloaded.

        Returns:
            dict: A dictionary containing the results of the download

        Code Example:

        .. code-block:: python

            import salt.utils.win_update
            wua = salt.utils.win_update.WindowsUpdateAgent()

            # Download KB3195454
            updates = wua.search('KB3195454')
            results = wua.download(updates)
        '''

        # Check for empty list
        if updates.count() == 0:
            ret = {'Success': False,
                   'Updates': 'Nothing to download'}
            return ret

        # Initialize the downloader object and list collection
        downloader = self._session.CreateUpdateDownloader()
        self._session.ClientApplicationID = 'Salt: Download Update'
        with salt.utils.winapi.Com():
            download_list = win32com.client.Dispatch('Microsoft.Update.UpdateColl')

        ret = {'Updates': {}}

        # Check for updates that aren't already downloaded
        for update in updates.updates:

            # Define uid to keep the lines shorter
            uid = update.Identity.UpdateID
            ret['Updates'][uid] = {}
            ret['Updates'][uid]['Title'] = update.Title
            ret['Updates'][uid]['AlreadyDownloaded'] = \
                bool(update.IsDownloaded)

            # Accept EULA
            if not salt.utils.data.is_true(update.EulaAccepted):
                log.debug('Accepting EULA: %s', update.Title)
                update.AcceptEula()  # pylint: disable=W0104

            # Update already downloaded
            if not salt.utils.data.is_true(update.IsDownloaded):
                log.debug('To Be Downloaded: %s', uid)
                log.debug('\tTitle: %s', update.Title)
                download_list.Add(update)

        # Check the download list
        if download_list.Count == 0:
            ret = {'Success': True,
                   'Updates': 'Nothing to download'}
            return ret

        # Send the list to the downloader
        downloader.Updates = download_list

        # Download the list
        try:
            log.debug('Downloading Updates')
            result = downloader.Download()
        except pywintypes.com_error as error:
            # Something happened, raise an error
            hr, msg, exc, arg = error.args  # pylint: disable=W0633
            try:
                failure_code = self.fail_codes[exc[5]]
            except KeyError:
                failure_code = 'Unknown Failure: {0}'.format(error)

            log.error('Download Failed: %s', failure_code)
            raise CommandExecutionError(failure_code)

        # Lookup dictionary
        result_code = {0: 'Download Not Started',
                       1: 'Download In Progress',
                       2: 'Download Succeeded',
                       3: 'Download Succeeded With Errors',
                       4: 'Download Failed',
                       5: 'Download Aborted'}

        log.debug('Download Complete')
        log.debug(result_code[result.ResultCode])
        ret['Message'] = result_code[result.ResultCode]

        # Was the download successful?
        if result.ResultCode in [2, 3]:
            log.debug('Downloaded Successfully')
            ret['Success'] = True
        else:
            log.debug('Download Failed')
            ret['Success'] = False

        # Report results for each update
        for i in range(download_list.Count):
            uid = download_list.Item(i).Identity.UpdateID
            ret['Updates'][uid]['Result'] = \
                result_code[result.GetUpdateResult(i).ResultCode]

        return ret

    def install(self, updates):
        '''
        Install the updates passed in the updates collection. Load the updates
        collection using the ``search`` or ``available`` functions. If the
        updates need to be downloaded, use the ``download`` function.

        Args:

            updates (Updates): An instance of the Updates class containing a
            the updates to be installed.

        Returns:
            dict: A dictionary containing the results of the installation

        Code Example:

        .. code-block:: python

            import salt.utils.win_update
            wua = salt.utils.win_update.WindowsUpdateAgent()

            # install KB3195454
            updates = wua.search('KB3195454')
            results = wua.download(updates)
            results = wua.install(updates)
        '''
        # Check for empty list
        if updates.count() == 0:
            ret = {'Success': False,
                   'Updates': 'Nothing to install'}
            return ret

        installer = self._session.CreateUpdateInstaller()
        self._session.ClientApplicationID = 'Salt: Install Update'
        with salt.utils.winapi.Com():
            install_list = win32com.client.Dispatch('Microsoft.Update.UpdateColl')

        ret = {'Updates': {}}

        # Check for updates that aren't already installed
        for update in updates.updates:

            # Define uid to keep the lines shorter
            uid = update.Identity.UpdateID
            ret['Updates'][uid] = {}
            ret['Updates'][uid]['Title'] = update.Title
            ret['Updates'][uid]['AlreadyInstalled'] = bool(update.IsInstalled)

            # Make sure the update has actually been installed
            if not salt.utils.data.is_true(update.IsInstalled):
                log.debug('To Be Installed: %s', uid)
                log.debug('\tTitle: %s', update.Title)
                install_list.Add(update)

        # Check the install list
        if install_list.Count == 0:
            ret = {'Success': True,
                   'Updates': 'Nothing to install'}
            return ret

        # Send the list to the installer
        installer.Updates = install_list

        # Install the list
        try:
            log.debug('Installing Updates')
            result = installer.Install()

        except pywintypes.com_error as error:
            # Something happened, raise an error
            hr, msg, exc, arg = error.args  # pylint: disable=W0633
            try:
                failure_code = self.fail_codes[exc[5]]
            except KeyError:
                failure_code = 'Unknown Failure: {0}'.format(error)

            log.error('Install Failed: %s', failure_code)
            raise CommandExecutionError(failure_code)

        # Lookup dictionary
        result_code = {0: 'Installation Not Started',
                       1: 'Installation In Progress',
                       2: 'Installation Succeeded',
                       3: 'Installation Succeeded With Errors',
                       4: 'Installation Failed',
                       5: 'Installation Aborted'}

        log.debug('Install Complete')
        log.debug(result_code[result.ResultCode])
        ret['Message'] = result_code[result.ResultCode]

        if result.ResultCode in [2, 3]:
            ret['Success'] = True
            ret['NeedsReboot'] = result.RebootRequired
            log.debug('NeedsReboot: %s', result.RebootRequired)
        else:
            log.debug('Install Failed')
            ret['Success'] = False

        reboot = {0: 'Never Reboot',
                  1: 'Always Reboot',
                  2: 'Poss Reboot'}
        for i in range(install_list.Count):
            uid = install_list.Item(i).Identity.UpdateID
            ret['Updates'][uid]['Result'] = \
                result_code[result.GetUpdateResult(i).ResultCode]
            ret['Updates'][uid]['RebootBehavior'] = \
                reboot[install_list.Item(i).InstallationBehavior.RebootBehavior]

        return ret

    def uninstall(self, updates):
        '''
        Uninstall the updates passed in the updates collection. Load the updates
        collection using the ``search`` or ``available`` functions.

        .. note:: Starting with Windows 10 the Windows Update Agent is unable to
        uninstall updates. An ``Uninstall Not Allowed`` error is returned. If
        this error is encountered this function will instead attempt to use
        ``dism.exe`` to perform the uninstallation. ``dism.exe`` may fail to
        to find the KB number for the package. In that case, removal will fail.

        Args:

            updates (Updates): An instance of the Updates class containing a
            the updates to be uninstalled.

        Returns:
            dict: A dictionary containing the results of the uninstallation

        Code Example:

        .. code-block:: python

            import salt.utils.win_update
            wua = salt.utils.win_update.WindowsUpdateAgent()

            # uninstall KB3195454
            updates = wua.search('KB3195454')
            results = wua.uninstall(updates)
        '''
        # This doesn't work with the WUA API since Windows 10. It always returns
        # "0x80240028 # Uninstall not allowed". The full message is: "The update
        # could not be uninstalled because the request did not originate from a
        # Windows Server Update Services (WSUS) server.

        # Check for empty list
        if updates.count() == 0:
            ret = {'Success': False,
                   'Updates': 'Nothing to uninstall'}
            return ret

        installer = self._session.CreateUpdateInstaller()
        self._session.ClientApplicationID = 'Salt: Install Update'
        with salt.utils.winapi.Com():
            uninstall_list = win32com.client.Dispatch('Microsoft.Update.UpdateColl')

        ret = {'Updates': {}}

        # Check for updates that aren't already installed
        for update in updates.updates:

            # Define uid to keep the lines shorter
            uid = update.Identity.UpdateID
            ret['Updates'][uid] = {}
            ret['Updates'][uid]['Title'] = update.Title
            ret['Updates'][uid]['AlreadyUninstalled'] = \
                not bool(update.IsInstalled)

            # Make sure the update has actually been Uninstalled
            if salt.utils.data.is_true(update.IsInstalled):
                log.debug('To Be Uninstalled: %s', uid)
                log.debug('\tTitle: %s', update.Title)
                uninstall_list.Add(update)

        # Check the install list
        if uninstall_list.Count == 0:
            ret = {'Success': False,
                   'Updates': 'Nothing to uninstall'}
            return ret

        # Send the list to the installer
        installer.Updates = uninstall_list

        # Uninstall the list
        try:
            log.debug('Uninstalling Updates')
            result = installer.Uninstall()

        except pywintypes.com_error as error:
            # Something happened, return error or try using DISM
            hr, msg, exc, arg = error.args  # pylint: disable=W0633
            try:
                failure_code = self.fail_codes[exc[5]]
            except KeyError:
                failure_code = 'Unknown Failure: {0}'.format(error)

            # If "Uninstall Not Allowed" error, try using DISM
            if exc[5] == -2145124312:
                log.debug('Uninstall Failed with WUA, attempting with DISM')
                try:

                    # Go through each update...
                    for item in uninstall_list:

                        # Look for the KB numbers
                        for kb in item.KBArticleIDs:

                            # Get the list of packages
                            cmd = ['dism', '/Online', '/Get-Packages']
                            pkg_list = self._run(cmd)[0].splitlines()

                            # Find the KB in the pkg_list
                            for item in pkg_list:

                                # Uninstall if found
                                if 'kb' + kb in item.lower():
                                    pkg = item.split(' : ')[1]

                                    ret['DismPackage'] = pkg

                                    cmd = ['dism',
                                           '/Online',
                                           '/Remove-Package',
                                           '/PackageName:{0}'.format(pkg),
                                           '/Quiet',
                                           '/NoRestart']

                                    self._run(cmd)

                except CommandExecutionError as exc:
                    log.debug('Uninstall using DISM failed')
                    log.debug('Command: %s', ' '.join(cmd))
                    log.debug('Error: %s', exc)
                    raise CommandExecutionError(
                        'Uninstall using DISM failed: {0}'.format(exc))

                # DISM Uninstall Completed Successfully
                log.debug('Uninstall Completed using DISM')

                # Populate the return dictionary
                ret['Success'] = True
                ret['Message'] = 'Uninstalled using DISM'
                ret['NeedsReboot'] = needs_reboot()
                log.debug('NeedsReboot: %s', ret['NeedsReboot'])

                # Refresh the Updates Table
                self.refresh()

                reboot = {0: 'Never Reboot',
                          1: 'Always Reboot',
                          2: 'Poss Reboot'}

                # Check the status of each update
                for update in self._updates:
                    uid = update.Identity.UpdateID
                    for item in uninstall_list:
                        if item.Identity.UpdateID == uid:
                            if not update.IsInstalled:
                                ret['Updates'][uid]['Result'] = \
                                    'Uninstallation Succeeded'
                            else:
                                ret['Updates'][uid]['Result'] = \
                                    'Uninstallation Failed'
                            ret['Updates'][uid]['RebootBehavior'] = \
                                reboot[update.InstallationBehavior.RebootBehavior]

                return ret

            # Found a differenct exception, Raise error
            log.error('Uninstall Failed: %s', failure_code)
            raise CommandExecutionError(failure_code)

        # Lookup dictionary
        result_code = {0: 'Uninstallation Not Started',
                       1: 'Uninstallation In Progress',
                       2: 'Uninstallation Succeeded',
                       3: 'Uninstallation Succeeded With Errors',
                       4: 'Uninstallation Failed',
                       5: 'Uninstallation Aborted'}

        log.debug('Uninstall Complete')
        log.debug(result_code[result.ResultCode])
        ret['Message'] = result_code[result.ResultCode]

        if result.ResultCode in [2, 3]:
            ret['Success'] = True
            ret['NeedsReboot'] = result.RebootRequired
            log.debug('NeedsReboot: %s', result.RebootRequired)
        else:
            log.debug('Uninstall Failed')
            ret['Success'] = False

        reboot = {0: 'Never Reboot',
                  1: 'Always Reboot',
                  2: 'Poss Reboot'}
        for i in range(uninstall_list.Count):
            uid = uninstall_list.Item(i).Identity.UpdateID
            ret['Updates'][uid]['Result'] = \
                result_code[result.GetUpdateResult(i).ResultCode]
            ret['Updates'][uid]['RebootBehavior'] = reboot[
                uninstall_list.Item(i).InstallationBehavior.RebootBehavior]

        return ret

    def _run(self, cmd):
        '''
        Internal function for running commands. Used by the uninstall function.

        Args:
            cmd (str, list): The command to run

        Returns:
            str: The stdout of the command
        '''

        if isinstance(cmd, six.string_types):
            cmd = salt.utils.args.shlex_split(cmd)

        try:
            log.debug(cmd)
            p = subprocess.Popen(
                cmd,
                shell=True,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE)
            return p.communicate()

        except (OSError, IOError) as exc:
            log.debug('Command Failed: %s', ' '.join(cmd))
            log.debug('Error: %s', exc)
            raise CommandExecutionError(exc)


def needs_reboot():
    '''
    Determines if the system needs to be rebooted.

    Returns:

        bool: True if the system requires a reboot, False if not

    CLI Examples:

    .. code-block:: bash

        import salt.utils.win_update

        salt.utils.win_update.needs_reboot()

    '''
    # Initialize the PyCom system
    with salt.utils.winapi.Com():
        # Create an AutoUpdate object
        obj_sys = win32com.client.Dispatch('Microsoft.Update.SystemInfo')
    return salt.utils.data.is_true(obj_sys.RebootRequired)
