# -*- coding: utf-8 -*-
# Copyright 2017 Damon Atkins
#
# 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.
r'''
Collect information about software installed on Windows OS
================

:maintainer: Salt Stack <https://github.com/saltstack>
:codeauthor: Damon Atkins <https://github.com/damon-atkins>
:maturity: new
:depends: pywin32, six
:platform: windows

Known Issue: install_date may not match Control Panel\Programs\Programs and Features
'''


# Note although this code will work with Python 2.7, win32api does not
# support Unicode. i.e non ASCII characters may be returned with unexpected
# results e.g. a '?' instead of the correct character
# Python 3.6 or newer is recommended.

# Import _future_ python libs first & before any other code
# pylint: disable=incompatible-py3-code
from __future__ import absolute_import, print_function, unicode_literals
__version__ = '0.1'
# Import Standard libs
import sys
import re
import platform
import locale
import logging
import os.path
import datetime
import time
import collections
from functools import cmp_to_key
# Import third party libs
try:
    from salt.ext import six
except ImportError:
    import six  # pylint: disable=blacklisted-external-import

try:
    import win32api
    import win32con
    import win32process
    import win32security
    import pywintypes
    import winerror

except ImportError:
    if __name__ == '__main__':
        raise ImportError('Please install pywin32/pypiwin32')
    else:
        raise


if __name__ == '__main__':
    LOG_CONSOLE = logging.StreamHandler()
    LOG_CONSOLE.setFormatter(logging.Formatter('[%(levelname)s]: %(message)s'))
    log = logging.getLogger(__name__)
    log.addHandler(LOG_CONSOLE)
    log.setLevel(logging.DEBUG)
else:
    log = logging.getLogger(__name__)


try:
    from salt.utils.odict import OrderedDict
except ImportError:
    from collections import OrderedDict

try:
    from salt.utils.versions import LooseVersion
except ImportError:
    from distutils.version import LooseVersion  # pylint: disable=blacklisted-module


# pylint: disable=too-many-instance-attributes

class RegSoftwareInfo(object):
    '''
    Retrieve Registry data on a single installed software item or component.

    Attribute:
        None

    :codeauthor: Damon Atkins <https://github.com/damon-atkins>
    '''

    # Variables shared by all instances
    __guid_pattern = re.compile(r'^\{(\w{8})-(\w{4})-(\w{4})-(\w\w)(\w\w)-(\w\w)(\w\w)(\w\w)(\w\w)(\w\w)(\w\w)\}$')
    __squid_pattern = re.compile(r'^(\w{8})(\w{4})(\w{4})(\w\w)(\w\w)(\w\w)(\w\w)(\w\w)(\w\w)(\w\w)(\w\w)$')
    __version_pattern = re.compile(r'\d+\.\d+\.\d+[\w.-]*|\d+\.\d+[\w.-]*')
    __upgrade_codes = {}
    __upgrade_code_have_scan = {}

    __reg_types = {
        'str': (win32con.REG_EXPAND_SZ, win32con.REG_SZ),
        'list': (win32con.REG_MULTI_SZ),
        'int': (win32con.REG_DWORD, win32con.REG_DWORD_BIG_ENDIAN, win32con.REG_QWORD),
        'bytes': (win32con.REG_BINARY)
    }

    # Search 64bit, on 64bit platform, on 32bit its ignored
    if platform.architecture()[0] == '32bit':
        # Handle Python 32bit on 64&32 bit platform and Python 64bit
        if win32process.IsWow64Process():  # pylint: disable=no-member
            # 32bit python on a 64bit platform
            __use_32bit_lookup = {True: 0, False: win32con.KEY_WOW64_64KEY}
        else:
            # 32bit python on a 32bit platform
            __use_32bit_lookup = {True: 0, False: None}
    else:
        __use_32bit_lookup = {True: win32con.KEY_WOW64_32KEY, False: 0}

    def __init__(self, key_guid, sid=None, use_32bit=False):
        '''
        Initialise against a software item or component.

        All software has a unique "Identifer" within the registry. This can be free
        form text/numbers e.g. "MySoftware" or
        GUID e.g. "{0EAF0D8F-C9CF-4350-BD9A-07EC66929E04}"

        Args:
            key_guid (str): Identifer.
            sid (str): Security IDentifier of the User or None for Computer/Machine.
            use_32bit (bool):
                Regisrty location of the Identifer. ``True`` 32 bit registry only
                meaning fully on 64 bit OS.
        '''
        self.__reg_key_guid = key_guid  # also called IdentifyingNumber(wmic)
        self.__squid = ''
        self.__reg_products_path = ''
        self.__reg_upgradecode_path = ''
        self.__patch_list = None

        # If a valid GUID create the SQUID also.
        guid_match = self.__guid_pattern.match(key_guid)
        if guid_match is not None:
            for index in range(1, 12):
                # __guid_pattern breaks up the GUID
                self.__squid += guid_match.group(index)[::-1]

        if sid:
            # User data seems to be more spreadout within the registry.
            self.__reg_hive = 'HKEY_USERS'
            self.__reg_32bit = False  # Force to False
            self.__reg_32bit_access = 0  # HKEY_USERS does not have a 32bit and 64bit view
            self.__reg_uninstall_path = ('{0}\\Software\\Microsoft\\Windows\\'
                                         'CurrentVersion\\Uninstall\\{1}').format(sid, key_guid)
            if self.__squid:
                self.__reg_products_path = \
                    '{0}\\Software\\Classes\\Installer\\Products\\{1}'.format(sid, self.__squid)
                self.__reg_upgradecode_path = \
                    '{0}\\Software\\Microsoft\\Installer\\UpgradeCodes'.format(sid)
                self.__reg_patches_path = \
                    ('Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\'
                     '{0}\\Products\\{1}\\Patches').format(sid, self.__squid)
        else:
            self.__reg_hive = 'HKEY_LOCAL_MACHINE'
            self.__reg_32bit = use_32bit
            self.__reg_32bit_access = self.__use_32bit_lookup[use_32bit]
            self.__reg_uninstall_path = \
                'Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\{0}'.format(key_guid)
            if self.__squid:
                self.__reg_products_path = \
                    'Software\\Classes\\Installer\\Products\\{0}'.format(self.__squid)
                self.__reg_upgradecode_path = 'Software\\Classes\\Installer\\UpgradeCodes'
                self.__reg_patches_path = \
                    ('Software\\Microsoft\\Windows\\CurrentVersion\\Installer\\UserData\\'
                     'S-1-5-18\\Products\\{0}\\Patches').format(self.__squid)

        # OpenKey is expensive, open in advance and keep it open.
        # This must exist
        try:
            # pylint: disable=no-member
            self.__reg_uninstall_handle = \
                win32api.RegOpenKeyEx(getattr(win32con, self.__reg_hive),
                                      self.__reg_uninstall_path,
                                      0,
                                      win32con.KEY_READ | self.__reg_32bit_access)
        except pywintypes.error as exc:  # pylint: disable=no-member
            if exc.winerror == winerror.ERROR_FILE_NOT_FOUND:
                log.error(
                    'Software/Component Not Found  key_guid: \'%s\', '
                    'sid: \'%s\' , use_32bit: \'%s\'',
                    key_guid, sid, use_32bit
                )
            raise  # This must exist or have no errors

        self.__reg_products_handle = None
        if self.__squid:
            try:
                # pylint: disable=no-member
                self.__reg_products_handle = \
                    win32api.RegOpenKeyEx(getattr(win32con, self.__reg_hive),
                                          self.__reg_products_path,
                                          0,
                                          win32con.KEY_READ | self.__reg_32bit_access)
            except pywintypes.error as exc:  # pylint: disable=no-member
                if exc.winerror == winerror.ERROR_FILE_NOT_FOUND:
                    log.debug(
                        'Software/Component Not Found in Products section of registry '
                        'key_guid: \'%s\', sid: \'%s\', use_32bit: \'%s\'',
                        key_guid, sid, use_32bit
                    )
                    self.__squid = None  # mark it as not a SQUID
                else:
                    raise

        self.__mod_time1970 = 0
        # pylint: disable=no-member
        mod_win_time = win32api.RegQueryInfoKeyW(self.__reg_uninstall_handle).get('LastWriteTime', None)
        # pylint: enable=no-member
        if mod_win_time:
            # at some stage __int__() was removed from pywintypes.datetime to return secs since 1970
            if hasattr(mod_win_time, 'utctimetuple'):
                self.__mod_time1970 = time.mktime(mod_win_time.utctimetuple())
            elif hasattr(mod_win_time, '__int__'):
                self.__mod_time1970 = int(mod_win_time)

    def __squid_to_guid(self, squid):
        '''
        Squished GUID (SQUID) to GUID.

        A SQUID is a Squished/Compressed version of a GUID to use up less space
        in the registry.

        Args:
            squid (str): Squished GUID.

        Returns:
            str: the GUID if a valid SQUID provided.
        '''
        if not squid:
            return ''
        squid_match = self.__squid_pattern.match(squid)
        guid = ''
        if squid_match is not None:
            guid = '{' +\
                squid_match.group(1)[::-1]+'-' +\
                squid_match.group(2)[::-1]+'-' +\
                squid_match.group(3)[::-1]+'-' +\
                squid_match.group(4)[::-1]+squid_match.group(5)[::-1] + '-'
            for index in range(6, 12):
                guid += squid_match.group(index)[::-1]
            guid += '}'
        return guid

    @staticmethod
    def __one_equals_true(value):
        '''
        Test for ``1`` as a number or a string and return ``True`` if it is.

        Args:
            value: string or number or None.

        Returns:
            bool: ``True`` if 1 otherwise ``False``.
        '''
        if isinstance(value, six.integer_types) and value == 1:
            return True
        elif (isinstance(value, six.string_types) and
              re.match(r'\d+', value, flags=re.IGNORECASE + re.UNICODE) is not None and
              six.text_type(value) == '1'):
            return True
        return False

    @staticmethod
    def __reg_query_value(handle, value_name):
        '''
        Calls RegQueryValueEx

        If PY2 ensure unicode string and expand REG_EXPAND_SZ before returning
        Remember to catch not found exceptions when calling.

        Args:
            handle (object): open registry handle.
            value_name (str): Name of the value you wished returned

        Returns:
            tuple: type, value
        '''
        # item_value, item_type = win32api.RegQueryValueEx(self.__reg_uninstall_handle, value_name)
        item_value, item_type = win32api.RegQueryValueEx(handle, value_name)  # pylint: disable=no-member
        if six.PY2 and isinstance(item_value, six.string_types) and not isinstance(item_value, six.text_type):
            try:
                item_value = six.text_type(item_value, encoding='mbcs')
            except UnicodeError:
                pass
        if item_type == win32con.REG_EXPAND_SZ:
            # expects Unicode input
            win32api.ExpandEnvironmentStrings(item_value)  # pylint: disable=no-member
            item_type = win32con.REG_SZ
        return item_value, item_type

    @property
    def install_time(self):
        '''
        Return the install time, or provide an estimate of install time.

        Installers or even self upgrading software must/should update the date
        held within InstallDate field when they change versions. Some installers
        do not set ``InstallDate`` at all so we use the last modified time on the
        registry key.

        Returns:
            int: Seconds since 1970 UTC.
        '''
        time1970 = self.__mod_time1970  # time of last resort
        try:
            # pylint: disable=no-member
            date_string, item_type = \
                win32api.RegQueryValueEx(self.__reg_uninstall_handle, 'InstallDate')
        except pywintypes.error as exc:  # pylint: disable=no-member
            if exc.winerror == winerror.ERROR_FILE_NOT_FOUND:
                return time1970  # i.e. use time of last resort
            else:
                raise

        if item_type == win32con.REG_SZ:
            try:
                date_object = datetime.datetime.strptime(date_string, "%Y%m%d")
                time1970 = time.mktime(date_object.timetuple())
            except ValueError:  # date format is not correct
                pass

        return time1970

    def get_install_value(self, value_name, wanted_type=None):
        '''
        For the uninstall section of the registry return the name value.

        Args:
            value_name (str): Registry value name.
            wanted_type (str):
                The type of value wanted if the type does not match
                None is return. wanted_type support values are
                ``str`` ``int`` ``list`` ``bytes``.

        Returns:
            value: Value requested or None if not found.
        '''
        try:
            item_value, item_type = self.__reg_query_value(self.__reg_uninstall_handle, value_name)
        except pywintypes.error as exc:  # pylint: disable=no-member
            if exc.winerror == winerror.ERROR_FILE_NOT_FOUND:
                # Not Found
                return None
            raise

        if wanted_type and item_type not in self.__reg_types[wanted_type]:
            item_value = None

        return item_value

    def is_install_true(self, key):
        '''
        For the uninstall section check if name value is ``1``.

        Args:
            value_name (str): Registry value name.

        Returns:
            bool: ``True`` if ``1`` otherwise ``False``.
        '''
        return self.__one_equals_true(self.get_install_value(key))

    def get_product_value(self, value_name, wanted_type=None):
        '''
        For the product section of the registry return the name value.

        Args:
            value_name (str): Registry value name.
            wanted_type (str):
                The type of value wanted if the type does not match
                None is return. wanted_type support values are
                ``str`` ``int`` ``list`` ``bytes``.

        Returns:
            value: Value requested or ``None`` if not found.
        '''
        if not self.__reg_products_handle:
            return None
        subkey, search_value_name = os.path.split(value_name)
        try:
            if subkey:

                handle = win32api.RegOpenKeyEx(  # pylint: disable=no-member
                            self.__reg_products_handle,
                            subkey,
                            0,
                            win32con.KEY_READ | self.__reg_32bit_access)
                item_value, item_type = self.__reg_query_value(handle, search_value_name)
                win32api.RegCloseKey(handle)  # pylint: disable=no-member
            else:
                item_value, item_type = \
                    win32api.RegQueryValueEx(self.__reg_products_handle, value_name)  # pylint: disable=no-member
        except pywintypes.error as exc:  # pylint: disable=no-member
            if exc.winerror == winerror.ERROR_FILE_NOT_FOUND:
                # Not Found
                return None
            raise

        if wanted_type and item_type not in self.__reg_types[wanted_type]:
            item_value = None
        return item_value

    @property
    def upgrade_code(self):
        '''
        For installers which follow the Microsoft Installer standard, returns
        the ``Upgrade code``.

        Returns:
            value (str): ``Upgrade code`` GUID for installed software.
        '''
        if not self.__squid:
            # Must have a valid squid for an upgrade code to exist
            return ''

        # GUID/SQUID are unique, so it does not matter if they are 32bit or
        # 64bit or user install so all items are cached into a single dict
        have_scan_key = '{0}\\{1}\\{2}'.format(self.__reg_hive, self.__reg_upgradecode_path, self.__reg_32bit)
        if not self.__upgrade_codes or self.__reg_key_guid not in self.__upgrade_codes:
            # Read in the upgrade codes in this section of the registry.
            try:
                uc_handle = win32api.RegOpenKeyEx(getattr(win32con, self.__reg_hive),  # pylint: disable=no-member
                                                  self.__reg_upgradecode_path,
                                                  0,
                                                  win32con.KEY_READ | self.__reg_32bit_access)
            except pywintypes.error as exc:  # pylint: disable=no-member
                if exc.winerror == winerror.ERROR_FILE_NOT_FOUND:
                    # Not Found
                    log.warning(
                        'Not Found %s\\%s 32bit %s',
                        self.__reg_hive,
                        self.__reg_upgradecode_path,
                        self.__reg_32bit
                    )
                    return ''
                raise
            squid_upgrade_code_all, _, _, suc_pytime = zip(*win32api.RegEnumKeyEx(uc_handle))  # pylint: disable=no-member

            # Check if we have already scanned these upgrade codes before, and also
            # check if they have been updated in the registry since last time we scanned.
            if (have_scan_key in self.__upgrade_code_have_scan and
                    self.__upgrade_code_have_scan[have_scan_key] == (squid_upgrade_code_all, suc_pytime)):
                log.debug('Scan skipped for upgrade codes, no changes (%s)', have_scan_key)
                return ''  # we have scanned this before and no new changes.

            # Go into each squid upgrade code and find all the related product codes.
            log.debug('Scan for upgrade codes (%s) for product codes', have_scan_key)
            for upgrade_code_squid in squid_upgrade_code_all:
                upgrade_code_guid = self.__squid_to_guid(upgrade_code_squid)
                pc_handle = win32api.RegOpenKeyEx(uc_handle,  # pylint: disable=no-member
                                                  upgrade_code_squid,
                                                  0,
                                                  win32con.KEY_READ | self.__reg_32bit_access)
                _, pc_val_count, _ = win32api.RegQueryInfoKey(pc_handle)  # pylint: disable=no-member
                for item_index in range(pc_val_count):
                    product_code_guid = \
                        self.__squid_to_guid(win32api.RegEnumValue(pc_handle, item_index)[0])  # pylint: disable=no-member
                    if product_code_guid:
                        self.__upgrade_codes[product_code_guid] = upgrade_code_guid
                win32api.RegCloseKey(pc_handle)  # pylint: disable=no-member

            win32api.RegCloseKey(uc_handle)  # pylint: disable=no-member
            self.__upgrade_code_have_scan[have_scan_key] = (squid_upgrade_code_all, suc_pytime)

        return self.__upgrade_codes.get(self.__reg_key_guid, '')

    @property
    def list_patches(self):
        '''
        For installers which follow the Microsoft Installer standard, returns
        a list of patches applied.

        Returns:
            value (list): Long name of the patch.
        '''
        if not self.__squid:
            # Must have a valid squid for an upgrade code to exist
            return []

        if self.__patch_list is None:
            # Read in the upgrade codes in this section of the reg.
            try:
                pat_all_handle = win32api.RegOpenKeyEx(getattr(win32con, self.__reg_hive),  # pylint: disable=no-member
                                                       self.__reg_patches_path,
                                                       0,
                                                       win32con.KEY_READ | self.__reg_32bit_access)
            except pywintypes.error as exc:  # pylint: disable=no-member
                if exc.winerror == winerror.ERROR_FILE_NOT_FOUND:
                    # Not Found
                    log.warning(
                        'Not Found %s\\%s 32bit %s',
                        self.__reg_hive,
                        self.__reg_patches_path,
                        self.__reg_32bit
                    )
                    return []
                raise

            pc_sub_key_cnt, _, _ = win32api.RegQueryInfoKey(pat_all_handle)  # pylint: disable=no-member
            if not pc_sub_key_cnt:
                return []
            squid_patch_all, _, _, _ = zip(*win32api.RegEnumKeyEx(pat_all_handle))  # pylint: disable=no-member

            ret = []
            # Scan the patches for the DisplayName of active patches.
            for patch_squid in squid_patch_all:
                try:
                    patch_squid_handle = win32api.RegOpenKeyEx(  # pylint: disable=no-member
                            pat_all_handle,
                            patch_squid,
                            0,
                            win32con.KEY_READ | self.__reg_32bit_access)
                    patch_display_name, patch_display_name_type = \
                        self.__reg_query_value(patch_squid_handle, 'DisplayName')
                    patch_state, patch_state_type = self.__reg_query_value(patch_squid_handle, 'State')
                    if (patch_state_type != win32con.REG_DWORD or
                            not isinstance(patch_state_type, six.integer_types) or
                            patch_state != 1 or   # 1 is Active, 2 is Superseded/Obsolute
                            patch_display_name_type != win32con.REG_SZ):
                        continue
                    win32api.RegCloseKey(patch_squid_handle)  # pylint: disable=no-member
                    ret.append(patch_display_name)
                except pywintypes.error as exc:  # pylint: disable=no-member
                    if exc.winerror == winerror.ERROR_FILE_NOT_FOUND:
                        log.debug('skipped patch, not found %s', patch_squid)
                        continue
                    raise

        return ret

    @property
    def registry_path_text(self):
        '''
        Returns the uninstall path this object is associated with.

        Returns:
            str: <hive>\\<uninstall registry entry>
        '''
        return '{0}\\{1}'.format(self.__reg_hive, self.__reg_uninstall_path)

    @property
    def registry_path(self):
        '''
        Returns the uninstall path this object is associated with.

        Returns:
            tuple: hive, uninstall registry entry path.
        '''
        return (self.__reg_hive, self.__reg_uninstall_path)

    @property
    def guid(self):
        '''
        Return GUID or Key.

        Returns:
            str: GUID or Key
        '''
        return self.__reg_key_guid

    @property
    def squid(self):
        '''
        Return SQUID of the GUID if a valid GUID.

        Returns:
            str: GUID
        '''
        return self.__squid

    @property
    def package_code(self):
        '''
        Return package code of the software.

        Returns:
            str: GUID
        '''
        return self.__squid_to_guid(self.get_product_value('PackageCode'))

    @property
    def version_binary(self):
        '''
        Return version number which is stored in binary format.

        Returns:
            str: <major 0-255>.<minior 0-255>.<build 0-65535> or None if not found
        '''
        # Under MSI 'Version' is a 'REG_DWORD' which then sets other registry
        # values like DisplayVersion to x.x.x to the same value.
        # However not everyone plays by the rules, so we need to check first.
        # version_binary_data will be None if the reg value does not exist.
        # Some installs set 'Version' to REG_SZ (string) which is not
        # the MSI standard
        try:
            item_value, item_type = self.__reg_query_value(self.__reg_uninstall_handle, 'version')
        except pywintypes.error as exc:  # pylint: disable=no-member
            if exc.winerror == winerror.ERROR_FILE_NOT_FOUND:
                # Not Found
                return '', ''

        version_binary_text = ''
        version_src = ''
        if item_value:
            if item_type == win32con.REG_DWORD:
                if isinstance(item_value, six.integer_types):
                    version_binary_raw = item_value
                if version_binary_raw:
                    # Major.Minor.Build
                    version_binary_text = '{0}.{1}.{2}'.format(
                        version_binary_raw >> 24 & 0xff,
                        version_binary_raw >> 16 & 0xff,
                        version_binary_raw & 0xffff)
                    version_src = 'binary-version'

            elif (item_type == win32con.REG_SZ and
                    isinstance(item_value, six.string_types) and
                    self.__version_pattern.match(item_value) is not None):
                # Hey, version should be a int/REG_DWORD, an installer has set
                # it to a string
                version_binary_text = item_value.strip(' ')
                version_src = 'binary-version (string)'

        return (version_binary_text, version_src)


class WinSoftware(object):
    '''
    Point in time snapshot of the software and components installed on
    a system.

    Attributes:
        None

    :codeauthor: Damon Atkins <https://github.com/damon-atkins>
    '''
    __sid_pattern = re.compile(r'^S-\d-\d-\d+$|^S-\d-\d-\d+-\d+-\d+-\d+-\d+$')
    __whitespace_pattern = re.compile(r'^\s*$', flags=re.UNICODE)
    # items we copy out of the uninstall section of the registry without further processing
    __uninstall_search_list = [
      ('url', 'str', ['URLInfoAbout', 'HelpLink', 'MoreInfoUrl', 'UrlUpdateInfo']),
      ('size', 'int', ['Size', 'EstimatedSize']),
      ('win_comments', 'str', ['Comments']),
      ('win_release_type', 'str', ['ReleaseType']),
      ('win_product_id', 'str', ['ProductID']),
      ('win_product_codes', 'str', ['ProductCodes']),
      ('win_package_refs', 'str', ['PackageRefs']),
      ('win_install_location', 'str', ['InstallLocation']),
      ('win_install_src_dir', 'str', ['InstallSource']),
      ('win_parent_pkg_uid', 'str', ['ParentKeyName']),
      ('win_parent_name', 'str', ['ParentDisplayName'])
      ]
    # items we copy out of the products section of the registry without further processing
    __products_search_list = [
      ('win_advertise_flags', 'int', ['AdvertiseFlags']),
      ('win_redeployment_flags', 'int', ['DeploymentFlags']),
      ('win_instance_type', 'int', ['InstanceType']),
      ('win_package_name', 'str', ['SourceList\\PackageName'])
      ]

    def __init__(self, version_only=False, user_pkgs=False, pkg_obj=None):
        '''
        Point in time snapshot of the software and components installed on
        a system.

        Args:
            version_only (bool): Provide list of versions installed instead of detail.
            user_pkgs (bool): Include software/components installed with user space.
            pkg_obj (object):
                If None (default) return default package naming standard and use
                default version capture methods (``DisplayVersion`` then
                ``Version``, otherwise ``0.0.0.0``)
        '''
        self.__pkg_obj = pkg_obj  # must be set before calling get_software_details
        self.__version_only = version_only
        self.__reg_software = {}
        self.__get_software_details(user_pkgs=user_pkgs)
        self.__pkg_cnt = len(self.__reg_software)
        self.__iter_list = None

    @property
    def data(self):
        '''
        Returns the raw data

        Returns:
            dict: contents of the dict are dependant on the parameters passed
                when the class was initiated.
        '''
        return self.__reg_software

    @property
    def version_only(self):
        '''
        Returns True if class initiated with ``version_only=True``

        Returns:
            bool: The value of ``version_only``
        '''
        return self.__version_only

    def __len__(self):
        '''
        Returns total number of software/components installed.

        Returns:
            int: total number of software/components installed.
        '''
        return self.__pkg_cnt

    def __getitem__(self, pkg_id):
        '''
        Returns information on a package.

        Args:
            pkg_id (str): Package Id of the software/component

        Returns:
            dict or list: List if ``version_only`` is ``True`` otherwise dict
        '''
        if pkg_id in self.__reg_software:
            return self.__reg_software[pkg_id]
        else:
            raise KeyError(pkg_id)

    def __iter__(self):
        '''
        Standard interation class initialisation over package information.
        '''
        if self.__iter_list is not None:
            raise RuntimeError('Can only perform one iter at a time')
        self.__iter_list = collections.deque(sorted(self.__reg_software.keys()))
        return self

    def __next__(self):
        '''
        Returns next Package Id.

        Returns:
            str: Package Id
        '''
        try:
            return self.__iter_list.popleft()
        except IndexError:
            self.__iter_list = None
            raise StopIteration

    def next(self):
        '''
        Returns next Package Id.

        Returns:
            str: Package Id
        '''
        return self.__next__()

    def get(self, pkg_id, default_value=None):
        '''
        Returns information on a package.

        Args:
            pkg_id (str): Package Id of the software/component.
            default_value: Value to return when the Package Id is not found.

        Returns:
            dict or list: List if ``version_only`` is ``True`` otherwise dict
        '''
        return self.__reg_software.get(pkg_id, default_value)

    @staticmethod
    def __oldest_to_latest_version(ver1, ver2):
        '''
        Used for sorting version numbers oldest to latest
        '''
        return 1 if LooseVersion(ver1) > LooseVersion(ver2) else -1

    @staticmethod
    def __latest_to_oldest_version(ver1, ver2):
        '''
        Used for sorting version numbers, latest to oldest
        '''
        return 1 if LooseVersion(ver1) < LooseVersion(ver2) else -1

    def pkg_version_list(self, pkg_id):
        '''
        Returns information on a package.

        Args:
            pkg_id (str): Package Id of the software/component.

        Returns:
            list: List of version numbers installed.
        '''
        pkg_data = self.__reg_software.get(pkg_id, None)
        if not pkg_data:
            return []

        if isinstance(pkg_data, list):
            # raw data is 'pkgid': [sorted version list]
            return pkg_data  # already sorted oldest to newest

        # Must be a dict or OrderDict, and contain full details
        installed_versions = list(pkg_data.get('version').keys())
        return sorted(installed_versions, key=cmp_to_key(self.__oldest_to_latest_version))

    def pkg_version_latest(self, pkg_id):
        '''
        Returns a package latest version installed out of all the versions
        currently installed.

        Args:
            pkg_id (str): Package Id of the software/component.

        Returns:
            str: Latest/Newest version number installed.
        '''
        return self.pkg_version_list(pkg_id)[-1]

    def pkg_version_oldest(self, pkg_id):
        '''
        Returns a package oldest version installed out of all the versions
        currently installed.

        Args:
            pkg_id (str): Package Id of the software/component.

        Returns:
            str: Oldest version number installed.
        '''
        return self.pkg_version_list(pkg_id)[0]

    @staticmethod
    def __sid_to_username(sid):
        '''
        Provided with a valid Windows Security Identifier (SID) and returns a Username

        Args:
            sid (str): Security Identifier (SID).

        Returns:
            str: Username in the format of username@realm or username@computer.
        '''
        if sid is None or sid == '':
            return ''
        try:
            sid_bin = win32security.GetBinarySid(sid)  # pylint: disable=no-member
        except pywintypes.error as exc:  # pylint: disable=no-member
            raise ValueError(
                    'pkg: Software owned by {0} is not valid: [{1}] {2}'.format(sid, exc.winerror, exc.strerror)
                )
        try:
            name, domain, _account_type = win32security.LookupAccountSid(None, sid_bin)  # pylint: disable=no-member
            user_name = '{0}\\{1}'.format(domain, name)
        except pywintypes.error as exc:  # pylint: disable=no-member
            # if user does not exist...
            # winerror.ERROR_NONE_MAPPED = No mapping between account names and
            # security IDs was carried out.
            if exc.winerror == winerror.ERROR_NONE_MAPPED:  # 1332
                # As the sid is from the registry it should be valid
                # even if it cannot be lookedup, so the sid is returned
                return sid
            else:
                raise ValueError(
                          'Failed looking up sid \'{0}\' username: [{1}] {2}'.format(sid, exc.winerror, exc.strerror)
                        )
        try:
            user_principal = win32security.TranslateName(  # pylint: disable=no-member
                            user_name,
                            win32api.NameSamCompatible,  # pylint: disable=no-member
                            win32api.NameUserPrincipal)  # pylint: disable=no-member
        except pywintypes.error as exc:  # pylint: disable=no-member
            # winerror.ERROR_NO_SUCH_DOMAIN The specified domain either does not exist
            # or could not be contacted, computer may not be part of a domain also
            # winerror.ERROR_INVALID_DOMAINNAME The format of the specified domain name is
            # invalid. e.g. S-1-5-19 which is a local account
            # winerror.ERROR_NONE_MAPPED No mapping between account names and security IDs was done.
            if exc.winerror in (winerror.ERROR_NO_SUCH_DOMAIN,
                                winerror.ERROR_INVALID_DOMAINNAME,
                                winerror.ERROR_NONE_MAPPED):
                return '{0}@{1}'.format(name.lower(), domain.lower())
            else:
                raise
        return user_principal

    def __software_to_pkg_id(self, publisher, name, is_component, is_32bit):
        '''
        Determine the Package ID of a software/component using the
        software/component ``publisher``, ``name``, whether its a software or a
        component, and if its 32bit or 64bit archiecture.

        Args:
            publisher (str): Publisher of the software/component.
            name (str): Name of the software.
            is_component (bool): True if package is a component.
            is_32bit (bool): True if the software/component is 32bit architecture.

        Returns:
            str: Package Id
        '''
        if publisher:
            # remove , and lowercase as , are used as list separators
            pub_lc = publisher.replace(',', '').lower()

        else:
            # remove , and lowercase
            pub_lc = 'NoValue'  # Capitals/Special Value

        if name:
            name_lc = name.replace(',', '').lower()
            # remove ,   OR we do the URL Encode on chars we do not want e.g. \\ and ,
        else:
            name_lc = 'NoValue'  # Capitals/Special Value

        if is_component:
            soft_type = 'comp'
        else:
            soft_type = 'soft'

        if is_32bit:
            soft_type += '32'  # Tag only the 32bit only

        default_pkg_id = pub_lc+'\\\\'+name_lc+'\\\\'+soft_type

        # Check to see if class was initialise with pkg_obj with a method called
        # to_pkg_id, and if so use it for the naming standard instead of the default
        if self.__pkg_obj and hasattr(self.__pkg_obj, 'to_pkg_id'):
            pkg_id = self.__pkg_obj.to_pkg_id(publisher, name, is_component, is_32bit)
            if pkg_id:
                return pkg_id

        return default_pkg_id

    def __version_capture_slp(self, pkg_id, version_binary, version_display, display_name):
        '''
        This returns the version and where the version string came from, based on instructions
        under ``version_capture``, if ``version_capture`` is missing, it defaults to
        value of display-version.

        Args:
            pkg_id (str): Publisher of the software/component.
            version_binary (str): Name of the software.
            version_display (str): True if package is a component.
            display_name (str): True if the software/component is 32bit architecture.

        Returns:
            str: Package Id
        '''
        if self.__pkg_obj and hasattr(self.__pkg_obj, 'version_capture'):
            version_str, src, version_user_str = \
                self.__pkg_obj.version_capture(pkg_id, version_binary, version_display, display_name)
            if src != 'use-default' and version_str and src:
                return version_str, src, version_user_str
            elif src != 'use-default':
                raise ValueError(
                    'version capture within object \'{0}\' failed '
                    'for pkg id: \'{1}\' it returned \'{2}\' \'{3}\' '
                    '\'{4}\''.format(six.text_type(self.__pkg_obj), pkg_id, version_str, src, version_user_str)
                    )

        # If self.__pkg_obj.version_capture() not defined defaults to using
        # version_display and if not valid then use version_binary, and as a last
        # result provide the version 0.0.0.0.0 to indicate version string was not determined.
        if version_display and re.match(r'\d+', version_display, flags=re.IGNORECASE + re.UNICODE) is not None:
            version_str = version_display
            src = 'display-version'
        elif version_binary and re.match(r'\d+', version_binary, flags=re.IGNORECASE + re.UNICODE) is not None:
            version_str = version_binary
            src = 'version-binary'
        else:
            src = 'none'
            version_str = '0.0.0.0.0'
        # return version str, src of the version, "user" interpretation of the version
        # which by default is version_str
        return version_str, src, version_str

    def __collect_software_info(self, sid, key_software, use_32bit):
        '''
        Update data with the next software found
        '''

        reg_soft_info = RegSoftwareInfo(key_software, sid, use_32bit)

        # Check if the registry entry is a valid.
        # a) Cannot manage software without at least a display name
        display_name = reg_soft_info.get_install_value('DisplayName', wanted_type='str')
        if display_name is None or self.__whitespace_pattern.match(display_name):
            return

        # b) make sure its not an 'Hotfix', 'Update Rollup', 'Security Update', 'ServicePack'
        # General this is software which pre dates Windows 10
        default_value = reg_soft_info.get_install_value('', wanted_type='str')
        release_type = reg_soft_info.get_install_value('ReleaseType', wanted_type='str')

        if (re.match(r'^{.*\}\.KB\d{6,}$', key_software, flags=re.IGNORECASE + re.UNICODE) is not None or
                (default_value and default_value.startswith(('KB', 'kb', 'Kb'))) or
                (release_type and release_type in ('Hotfix', 'Update Rollup', 'Security Update', 'ServicePack'))):
            log.debug('skipping hotfix/update/service pack %s', key_software)
            return

        # if NoRemove exists we would expect their to be no UninstallString
        uninstall_no_remove = reg_soft_info.is_install_true('NoRemove')
        uninstall_string = reg_soft_info.get_install_value('UninstallString')
        uninstall_quiet_string = reg_soft_info.get_install_value('QuietUninstallString')
        uninstall_modify_path = reg_soft_info.get_install_value('ModifyPath')
        windows_installer = reg_soft_info.is_install_true('WindowsInstaller')
        system_component = reg_soft_info.is_install_true('SystemComponent')
        publisher = reg_soft_info.get_install_value('Publisher', wanted_type='str')

        # UninstallString is optional if the installer is "windows installer"/MSI
        # However for it to appear in Control-Panel -> Program and Features -> Uninstall or change a program
        # the UninstallString needs to be set or ModifyPath set
        if (uninstall_string is None and
                uninstall_quiet_string is None and
                uninstall_modify_path is None and
                (not windows_installer)):
            return

        # Question: If uninstall string is not set and windows_installer should we set it
        # Question: if uninstall_quiet is not set .......

        if sid:
            username = self.__sid_to_username(sid)
        else:
            username = None

        # We now have a valid software install or a system component
        pkg_id = self.__software_to_pkg_id(publisher, display_name, system_component, use_32bit)
        version_binary, version_src = reg_soft_info.version_binary
        version_display = reg_soft_info.get_install_value('DisplayVersion', wanted_type='str')
        # version_capture is what the slp defines, the result overrides. Question: maybe it should error if it fails?
        (version_text, version_src, user_version) = \
            self.__version_capture_slp(pkg_id, version_binary, version_display, display_name)
        if not user_version:
            user_version = version_text

        # log.trace('%s\\%s ver:%s src:%s', username or 'SYSTEM', pkg_id, version_text, version_src)

        if username:
            dict_key = '{};{}'.format(username, pkg_id)  # Use ; as its not a valid hostnmae char
        else:
            dict_key = pkg_id

        # Guessing the architecture http://helpnet.flexerasoftware.com/isxhelp21/helplibrary/IHelp64BitSupport.htm
        # A 32 bit installed.exe can install a 64 bit app, but for it to write to 64bit reg it will
        # need to use WOW. So the following is a bit of a guess

        if self.__version_only:
            # package name and package version list, are the only info being return
            if dict_key in self.__reg_software:
                if version_text not in self.__reg_software[dict_key]:
                    # Not expecting the list to be big, simple search and insert
                    insert_point = 0
                    for ver_item in self.__reg_software[dict_key]:
                        if LooseVersion(version_text) <= LooseVersion(ver_item):
                            break
                        insert_point += 1
                    self.__reg_software[dict_key].insert(insert_point, version_text)
                else:
                    # This code is here as it can happen, especially if the
                    # package id provided by pkg_obj is simple.
                    log.debug(
                        'Found extra entries for \'%s\' with same version '
                        '\'%s\', skipping entry \'%s\'',
                        dict_key, version_text, key_software
                    )
            else:
                self.__reg_software[dict_key] = [version_text]

            return

        if dict_key in self.__reg_software:
            data = self.__reg_software[dict_key]
        else:
            data = self.__reg_software[dict_key] = OrderedDict()

        if sid:
            # HKEY_USERS has no 32bit and 64bit view like HKEY_LOCAL_MACHINE
            data.update({'arch': 'unknown'})
        else:
            arch_str = 'x86' if use_32bit else 'x64'
            if 'arch' in data:
                if data['arch'] != arch_str:
                    data['arch'] = 'many'
            else:
                data.update({'arch': arch_str})

        if publisher:
            if 'vendor' in data:
                if data['vendor'].lower() != publisher.lower():
                    data['vendor'] = 'many'
            else:
                data['vendor'] = publisher

        if 'win_system_component' in data:
            if data['win_system_component'] != system_component:
                data['win_system_component'] = None
        else:
            data['win_system_component'] = system_component

        data.update({'win_version_src': version_src})

        data.setdefault('version', {})
        if version_text in data['version']:
            if 'win_install_count' in data['version'][version_text]:
                data['version'][version_text]['win_install_count'] += 1
            else:
                # This is only defined when we have the same item already
                data['version'][version_text]['win_install_count'] = 2
        else:
            data['version'][version_text] = OrderedDict()

        version_data = data['version'][version_text]
        version_data.update({'win_display_name': display_name})
        if uninstall_string:
            version_data.update({'win_uninstall_cmd': uninstall_string})
        if uninstall_quiet_string:
            version_data.update({'win_uninstall_quiet_cmd': uninstall_quiet_string})
        if uninstall_no_remove:
            version_data.update({'win_uninstall_no_remove': uninstall_no_remove})

        version_data.update({'win_product_code': key_software})
        if version_display:
            version_data.update({'win_version_display': version_display})
        if version_binary:
            version_data.update({'win_version_binary': version_binary})
        if user_version:
            version_data.update({'win_version_user': user_version})

        # Determine Installer Product
        #   'NSIS:Language'
        #   'Inno Setup: Setup Version'
        if (windows_installer or
                (uninstall_string and
                    re.search(r'MsiExec.exe\s|MsiExec\s', uninstall_string, flags=re.IGNORECASE + re.UNICODE))):
            version_data.update({'win_installer_type': 'winmsi'})
        elif (re.match(r'InstallShield_', key_software, re.IGNORECASE) is not None or
                (uninstall_string and (
                 re.search(r'InstallShield', uninstall_string, flags=re.IGNORECASE + re.UNICODE) is not None or
                 re.search(r'isuninst\.exe.*\.isu', uninstall_string, flags=re.IGNORECASE + re.UNICODE) is not None)
                 )
              ):
            version_data.update({'win_installer_type': 'installshield'})
        elif (key_software.endswith('_is1') and
              reg_soft_info.get_install_value('Inno Setup: Setup Version', wanted_type='str')):
            version_data.update({'win_installer_type': 'inno'})
        elif (uninstall_string and
              re.search(r'.*\\uninstall.exe|.*\\uninst.exe', uninstall_string, flags=re.IGNORECASE + re.UNICODE)):
            version_data.update({'win_installer_type': 'nsis'})
        else:
            version_data.update({'win_installer_type': 'unknown'})

        # Update dict with information retrieved so far for detail results to be return
        # Do not add fields which are blank.
        language_number = reg_soft_info.get_install_value('Language')
        if isinstance(language_number, six.integer_types) and language_number in locale.windows_locale:
            version_data.update({'win_language': locale.windows_locale[language_number]})

        package_code = reg_soft_info.package_code
        if package_code:
            version_data.update({'win_package_code': package_code})

        upgrade_code = reg_soft_info.upgrade_code
        if upgrade_code:
            version_data.update({'win_upgrade_code': upgrade_code})

        is_minor_upgrade = reg_soft_info.is_install_true('IsMinorUpgrade')
        if is_minor_upgrade:
            version_data.update({'win_is_minor_upgrade': is_minor_upgrade})

        install_time = reg_soft_info.install_time
        if install_time:
            version_data.update({'install_date': datetime.datetime.fromtimestamp(install_time).isoformat()})
            version_data.update({'install_date_time_t': int(install_time)})

        for infokey, infotype, regfield_list in self.__uninstall_search_list:
            for regfield in regfield_list:
                strvalue = reg_soft_info.get_install_value(regfield, wanted_type=infotype)
                if strvalue:
                    version_data.update({infokey: strvalue})
                    break

        for infokey, infotype, regfield_list in self.__products_search_list:
            for regfield in regfield_list:
                data = reg_soft_info.get_product_value(regfield, wanted_type=infotype)
                if data is not None:
                    version_data.update({infokey: data})
                    break
        patch_list = reg_soft_info.list_patches
        if patch_list:
            version_data.update({'win_patches': patch_list})

    def __get_software_details(self, user_pkgs):
        '''
        This searches the uninstall keys in the registry to find
        a match in the sub keys, it will return a dict with the
        display name as the key and the version as the value
        .. sectionauthor:: Damon Atkins <https://github.com/damon-atkins>
        .. versionadded:: Carbon
        '''

        # FUNCTION MAIN CODE #
        # Search 64bit, on 64bit platform, on 32bit its ignored.
        if platform.architecture()[0] == '32bit':
            # Handle Python 32bit on 64&32 bit platform and Python 64bit
            if win32process.IsWow64Process():  # pylint: disable=no-member
                # 32bit python on a 64bit platform
                use_32bit_lookup = {True: 0, False: win32con.KEY_WOW64_64KEY}
                arch_list = [True, False]
            else:
                # 32bit python on a 32bit platform
                use_32bit_lookup = {True: 0, False: None}
                arch_list = [True]

        else:
            # Python is 64bit therefore most be on 64bit System.
            use_32bit_lookup = {True: win32con.KEY_WOW64_32KEY, False: 0}
            arch_list = [True, False]

        # Process software installed for the machine i.e. all users.
        for arch_flag in arch_list:
            key_search = 'Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall'
            log.debug('SYSTEM processing 32bit:%s', arch_flag)
            handle = win32api.RegOpenKeyEx(  # pylint: disable=no-member
                        win32con.HKEY_LOCAL_MACHINE,
                        key_search,
                        0,
                        win32con.KEY_READ | use_32bit_lookup[arch_flag])
            reg_key_all, _, _, _ = zip(*win32api.RegEnumKeyEx(handle))  # pylint: disable=no-member
            win32api.RegCloseKey(handle)  # pylint: disable=no-member
            for reg_key in reg_key_all:
                self.__collect_software_info(None, reg_key, arch_flag)

        if not user_pkgs:
            return

        # Process software installed under all USERs, this adds significate processing time.
        # There is not 32/64 bit registry redirection under user tree.
        log.debug('Processing user software... please wait')
        handle_sid = win32api.RegOpenKeyEx(  # pylint: disable=no-member
                        win32con.HKEY_USERS,
                        '',
                        0,
                        win32con.KEY_READ)
        sid_all = []
        for index in range(win32api.RegQueryInfoKey(handle_sid)[0]):  # pylint: disable=no-member
            sid_all.append(win32api.RegEnumKey(handle_sid, index))  # pylint: disable=no-member

        for sid in sid_all:
            if self.__sid_pattern.match(sid) is not None:  # S-1-5-18 needs to be ignored?
                user_uninstall_path = '{0}\\Software\\Microsoft\\Windows\\CurrentVersion\\Uninstall'.format(sid)
                try:
                    handle = win32api.RegOpenKeyEx(  # pylint: disable=no-member
                                handle_sid,
                                user_uninstall_path,
                                0,
                                win32con.KEY_READ)
                except pywintypes.error as exc:  # pylint: disable=no-member
                    if exc.winerror == winerror.ERROR_FILE_NOT_FOUND:
                        # Not Found Uninstall under SID
                        log.debug('Not Found %s', user_uninstall_path)
                        continue
                    else:
                        raise
                try:
                    reg_key_all, _, _, _ = zip(*win32api.RegEnumKeyEx(handle))  # pylint: disable=no-member
                except ValueError:
                    log.debug('No Entries Found %s', user_uninstall_path)
                    reg_key_all = []
                win32api.RegCloseKey(handle)  # pylint: disable=no-member
                for reg_key in reg_key_all:
                    self.__collect_software_info(sid, reg_key, False)
        win32api.RegCloseKey(handle_sid)  # pylint: disable=no-member
        return


def __main():
    '''This module can also be run directly for testing
        Args:
            detail|list : Provide ``detail`` or version ``list``.
            system|system+user: System installed and System and User installs.
    '''
    if len(sys.argv) < 3:
        sys.stderr.write('usage: {0} <detail|list> <system|system+user>\n'.format(sys.argv[0]))
        sys.exit(64)
    user_pkgs = False
    version_only = False
    if six.text_type(sys.argv[1]) == 'list':
        version_only = True
    if six.text_type(sys.argv[2]) == 'system+user':
        user_pkgs = True
    import salt.utils.json
    import timeit

    def run():
        '''
        Main run code, when this module is run directly
        '''
        pkg_list = WinSoftware(user_pkgs=user_pkgs, version_only=version_only)
        print(salt.utils.json.dumps(pkg_list.data, sort_keys=True, indent=4))  # pylint: disable=superfluous-parens
        print('Total: {}'.format(len(pkg_list)))  # pylint: disable=superfluous-parens

    print('Time Taken: {}'.format(timeit.timeit(run, number=1)))  # pylint: disable=superfluous-parens


if __name__ == '__main__':
    __main()
