# Copyright (c) 2024-2025 Broadcom. All Rights Reserved.
# The term "Broadcom" refers to Broadcom Inc.
# and/or its subsidiaries.

import ipaddress
import glob
import logging
import os
import pathlib
import re
import shutil
import socket
import sys
import xml.etree.ElementTree as ET
from enum import Enum

from lib.console import print_text_warning
from lib.constants import RHTTPPROXY_CONFIG_FILE_PATH, STS_SERVER_CONFIG_FILE_PATH, STS_SERVER_CONFIG_PROPERTY_FILE_PATH
from lib.environment import Environment
from lib.execution_replay import ReplayContext
from lib.command_runner import CommandRunner
from lib.java_utils import load_property_file
from lib.text_utils import TextFilter

VMAFD_CLI = '/usr/lib/vmware-vmafd/bin/vmafd-cli'
LWREGSHELL_CLI = '/opt/likewise/bin/lwregshell'
TEE_CMD = '/usr/bin/tee'
FILE_CMD = '/usr/bin/file'
CHMOD_CMD = '/bin/chmod'


logger = logging.getLogger(__name__)


class VcVersion(Enum):
    """
    Define the recognized versions of VC.
    """
    # We assume the needed version values are only major and minor releases,
    # and not patches for example. This allows us to represent the versions as
    # floating point numbers for relative comparison. For code specific to
    # patch releases, the tool resorts to build numbers, which are checked as
    # needed.
    #
    # Also, the order of enum definitions must be kept in increasing order,
    # including minor releases.
    Invalid = None
    V7 = '7'
    V8 = '8'
    V9 = '9'

    @classmethod
    def min(cls):
        """Minimum supported vCenter version"""
        return min([float(v) for v in cls if v.value is not None])

    @classmethod
    def max(cls):
        """Maximum supported vCenter version"""
        return max([float(v) for v in cls if v.value is not None])

    @property
    def major(self):
        """Return the major release number for the release."""
        if self.value is None:
            return None
        # Floats that are actually integers always end with ".0" as a string.
        return str(float(self)).split('.')[0]

    @property
    def minor(self):
        """Return the minor release number for the release."""
        if self.value is None:
            return None
        # Floats that are actually integers always end with ".0" as a string.
        return str(float(self)).split('.')[1]

    def _validate(self, other):
        if not isinstance(other, VcVersion):
            raise ValueError(other)

    def __float__(self):
        # If there is no value (for the Invalid entry) then return float NaN
        # so all comparison operations return False. (However, we provide
        # special direct comparison overrides for != and == so that comparisons
        # with VcVersion.Invalid work as expected.)
        return float('nan') if self.value is None else float(self.value)

    def __lt__(self, other):
        self._validate(other)
        return float(self) < float(other)

    def __le__(self, other):
        self._validate(other)
        return float(self) <= float(other)

    def __eq__(self, other):
        self._validate(other)
        return self.value == other.value

    def __ne__(self, other):
        self._validate(other)
        return self.value != other.value

    def __gt__(self, other):
        self._validate(other)
        return float(self) > float(other)

    def __ge__(self, other):
        self._validate(other)
        return float(self) >= float(other)


def init_env_host():
    """
    Obtain basic information from VC server
    """
    vpxd_info = CommandRunner('vpxd', '-v').run_and_get_output().strip().split(' ')
    vc_version_long = vpxd_info[2]
    vc_version = '.'.join(vc_version_long.split('.')[:-1])
    vc_build = vpxd_info[3].split('-')[1]
    hostname = CommandRunner('hostname', '-f').run_and_get_output().strip()
    pnid = CommandRunner(VMAFD_CLI, 'get-pnid', '--server-name', 'localhost').run_and_get_output().strip()
    machine_id = CommandRunner(VMAFD_CLI, 'get-machine-id', '--server-name', 'localhost').run_and_get_output().strip()
    ifconfig_output = CommandRunner('/usr/sbin/ifconfig', 'eth0').run_and_get_output()
    ip_address = TextFilter(ifconfig_output).head(2).tail(1).get_text().strip().split('  ')[0].replace(':', ' ').split(' ')[-1]
    sso_domain = CommandRunner(VMAFD_CLI, 'get-domain-name', '--server-name', 'localhost').run_and_get_output().strip()
    sso_site = CommandRunner(VMAFD_CLI, 'get-site-name', '--server-name', 'localhost').run_and_get_output().strip()
    sso_domain_dn = "dc={}".format(",dc=".join(sso_domain.split('.')))
    vmdir_account_dn, vmdir_account_password = get_vmdir_machine_account()
    local_hostname = socket.getfqdn()

    env = Environment.get_environment()
    env.set_value('VC_VERSION', vc_version)
    env.set_value('VC_VERSION_LONG', vc_version_long)
    env.set_value('VC_BUILD', vc_build)
    env.set_value('HOSTNAME', hostname)
    env.set_value('LOCAL_HOSTNAME', local_hostname)
    env.set_value('PNID', pnid)
    env.set_value('MACHINE_ID', machine_id)
    env.set_value('IP_ADDRESS', ip_address)
    env.set_value('SSO_DOMAIN', sso_domain)
    env.set_value('SSO_SITE', sso_site)
    env.set_value('SSO_DOMAIN_DN', sso_domain_dn)
    env.set_value('VMDIR_MACHINE_ACCOUNT_DN', vmdir_account_dn)
    env.set_value('VMDIR_MACHINE_ACCOUNT_PASSWORD', vmdir_account_password)

    smart_card_filter_file = get_smart_card_filter_file()
    env.set_value('SMART_CARD_FILTER_FILE', smart_card_filter_file)

    init_env_solution_users()


def get_vmdir_machine_account():
    """
    Get machine account from likewise
    :return: a tupple of ( account_dn, account_password)
    """
    output = CommandRunner(LWREGSHELL_CLI, 'list_values',
                           r'[HKEY_THIS_MACHINE\services\vmdir]').run_and_get_output()

    account_dn = TextFilter(output).contain('"dcAccountDN"').cut('REG_SZ', [1]).get_text().strip()[1:-1]\
        .replace('\\"', r'"').replace('\\\\', '\\')
    account_password = TextFilter(output).contain('dcAccountPassword').cut('REG_SZ', [1]).get_text().strip()[1:-1]\
        .replace('\\"', r'"').replace('\\\\', '\\')
    return account_dn, account_password


def is_file_exists(file):
    """
    Wrapper for checking file existence.
    This wrapper is required to redirect operation when VCERT_REMOTE_EXEC is True

    :param file: file path to be checked
    :return: True if file is exist
    """
    if not is_remote_exec():
        return os.path.exists(file)

    return_code, _, _  = CommandRunner('/bin/ls', file, expected_return_code=None).run()
    return return_code == 0


def get_config_file_path(config_file):
    env = Environment.get_environment()
    if os.path.isabs(config_file):
        if is_file_exists(config_file):
            return config_file
        else:
            print_text_warning("Unable to find configuration file '{}'".format(config_file))
            print_text_warning('Script cannot continue. Exiting...')
            sys.exit(1)
    else:
        vcert_relative_config_path = "{}/{}".format(env.get_value('SCRIPT_DIR'), config_file)
        cwd_relative_config_path = "{}/{}".format(os.getcwd(), config_file)
        if is_file_exists(vcert_relative_config_path):
            return vcert_relative_config_path
        elif is_file_exists(cwd_relative_config_path):
            return cwd_relative_config_path
        else:
            print_text_warning("Configuration file does not exist in the vCert script directory ({}),".format(vcert_relative_config_path))
            print_text_warning("nor in the current working directory ({}).".format(cwd_relative_config_path))
            print_text_warning('Script cannot continue. Exiting...')
            sys.exit(1)


def make_directory(path):
    """
    Wrapper for making directory.
    This wrapper is required to redirect operation when VCERT_REMOTE_EXEC is True

    :param path: directory path to be created
    :return: True if the operation success, otherwise False
    """
    if is_remote_exec():
        command_runner = CommandRunner('/bin/mkdir', '-p', path, expected_return_code=None)
        return_code, _, _ = command_runner.run()
        return return_code == 0

    try:
        pathlib.Path(path).mkdir(parents=True, exist_ok=True)
        return True
    except Exception:
        return False


def remove_directory(path, remove_all=False):
    """
    Wrapper for removing directory
    This wrapper is required to redirect operation when VCERT_REMOTE_EXEC is True
    :param path: Directory path to remove
    :param remove_all: if True, this method will remove the directory contents before trying to
        remove the directory
    :return: True if the operation success, otherwise False
    """
    if is_remote_exec():
        if remove_all:
            command_runner = CommandRunner('/bin/rmdir', '-r', path, expected_return_code=None)
        else:
            command_runner = CommandRunner('/bin/rmdir', path, expected_return_code=None)
        return_code, _, _ = command_runner.run()
        return return_code == 0

    try:
        if remove_all:
            shutil.rmtree(path)
        else:
            pathlib.Path(path).rmdir()
    except Exception:
        return False


def get_file_contents(file):
    """
    Wrapper for reading file contents.
    This wrapper is required to redirect operation when VCERT_REMOTE_EXEC is True

    :param file: File path to load
    :return:  File contents
    """
    if not is_remote_exec():
        with open(file, 'r') as f:
            return f.read()

    command_runner = CommandRunner('/bin/cat', file, expected_return_code=0)
    _, stdout, _ = command_runner.run()
    return stdout


def get_hostname():
    """
    Wrapper obtaining remote hostname
    This wrapper is required to redirect operation when VCERT_REMOTE_EXEC is True

    :return: return VCERT_REMOTE_HOSTNAME value if VCERT_REMOTE_EXEC is True,
        otherwise return 'localhost'
    """
    if is_remote_exec():
        hostname = Environment.get_environment().get_value('VCERT_REMOTE_HOSTNAME')
    else:
        hostname = 'localhost'
    return hostname


def is_remote_exec():
    """
    Check if remote execution is set
    :return: True if remote execution is set, otherwise False
    """
    return Environment.get_environment().get_value('VCERT_REMOTE_EXEC') is True


def get_vc_version():
    """
    Get the VC version. The value is obtained from environment variable VC_VERSION

    :return: VC version as VcVersion enum
    """
    vc_version = Environment.get_environment().get_value('VC_VERSION')
    # Versions in VcVersion are kept in increasing order. Thus we search the
    # versions in reverse order to bulletproof the code against versions that
    # are represented just as a major release versus ones that are represented
    # as major.minor.
    for definedVcVersion in reversed(VcVersion):
       if (    definedVcVersion.value is not None
           and vc_version.startswith(definedVcVersion.value)):
          return definedVcVersion
    return VcVersion.Invalid


def init_env_solution_users():
    """
    Initialize set of solution users to be checked, saved the list into environment
    variable 'SOLUTION_USERS'
    """
    solutionUserDB = {
    #   Solution User        Version Constraint (None means all)
    #   -------------------  -----------------------------------
        'machine':           None,
        'vsphere-webclient': None,
        'vpxd':              None,
        'vpxd-extension':    None,
        'hvc':               None,
        'wcp':               [VcVersion.V7, VcVersion.V8],
        'wcpsvc':            [VcVersion.V9],
    }

    env = Environment.get_environment()
    vc_version = get_vc_version()

    solution_users = []
    for solutionUser, versionConstraint in solutionUserDB.items():
        if versionConstraint and not vc_version in versionConstraint:
           continue
        solution_users.append(solutionUser)

    env.set_value('SOLUTION_USERS', solution_users)


def is_valid_ip_address(hostname_or_ip):
    try:
        ipaddress.ip_address(hostname_or_ip)
        return True
    except ValueError:
        return False


def get_ip_address(hostname_or_ip):
    if is_valid_ip_address(hostname_or_ip):
        return hostname_or_ip
    else:
        return socket_gethostbyname(hostname_or_ip)


def socket_gethostbyname(hostname):
    category = 'other'
    command_args = ['socket', 'gethostbyname', 'hostname', hostname]
    context = ReplayContext.get_replay_context()
    if context and context.is_replaying:
        result = context.get_execution_result(category, command_args, None)
        if result is not None:
            _, ip_address, _ = result
            return ip_address

    try:
        ip_address = socket.gethostbyname(hostname)
    except socket.gaierror:
        ip_address = ''
    if context and context.is_capturing:
        context.store_result(category, command_args, None, 0, ip_address, None)

    return ip_address


def save_text_to_file(text, filename):
    """
    A wrapper to write {text} to file {filename}
    :param filename:  the output filename
    :param text:  file contents
    """
    if is_remote_exec():
        CommandRunner(TEE_CMD, filename, command_input=text, expected_return_code=0).run()
        return

    with open(filename, 'w') as file:
        file.write(text)


def append_text_to_file(text, filename, start_new_line=True):
    """
    A wrapper to append {text} to file {filename}
    :param text:  text to append
    :param file:  the existing filename
    :param start_new_line:  start appending data on a new line
    """
    if is_remote_exec():
        CommandRunner(TEE_CMD, '-a', filename, command_input=text, expected_return_code=0).run()
        return

    with open(filename, 'a') as file:
        if start_new_line:
            file.write("\n{}".format(text))
        else:
            file.write(text)

def find_files(pattern):
    """
    Wrapper for glob.glob({pattern}) method
    :param pattern: glob patter for matching
    """

    if is_remote_exec():
        output = CommandRunner('/usr/bin/sh', '-c', "eval ls -1 '{}'".format(pattern)).run_and_get_output()
        return output.splitlines()

    return glob.glob(pattern)


def get_file_type(filename):
    """
    Get file type returned by /usr/bin/file command
    """
    output = CommandRunner(FILE_CMD, filename,
                expected_return_code =0).run_and_get_output()
    return TextFilter(output).cut(delimiter=':', fields=[1]).get_text().strip()


def set_file_mode(file_path, mode):
    """
    A wrapper for setting file mode on {filename}
    :param file_path: File path to be modified
    :param mode: permission value, the exact permission value to be passed to os.chmod()
    """
    if is_remote_exec():
        mode_string = "{:04o}".format(mode)
        CommandRunner(CHMOD_CMD, mode_string, file_path, expected_return_code=0).run()
    else:
        os.chmod(file_path, mode)


def get_smart_card_filter_file():
    def revproxy_get_file():
        # Before 7.0 U3i the location of the Smart Card filter file is defined
        # in the reverse proxy config.
        config = ET.parse(RHTTPPROXY_CONFIG_FILE_PATH)
        root = config.getroot()
        client_ca_list_file = root.find('clientCAListFile')
        if client_ca_list_file is None:
            filter_file = ''
        else:
            filter_file = client_ca_list_file.text
            filter_file = '/etc/vmware-rhttpproxy/{}'.format(filter_file) if filter_file.startswith('/') is False else filter_file
        return filter_file

    def xml_config_get_file():
        # After 7.0 U3i the location of the Smart Card filter file is
        # hard-coded in the STS server config which is an XML file.
        config = ET.parse(STS_SERVER_CONFIG_FILE_PATH)
        root = config.getroot()
        for connector in root.iter('Connector'):
            if connector.attrib['port'] == '${bio-ssl-clientauth.https.port}':
                return connector.find('SSLHostConfig').attrib['truststoreFile']
        return '' # Not found

    def prop_config_get_file():
        # Starting with 9.0 the Smart Card filter file is in the STS server
        # configuration file which is a Java property file.
        config = load_property_file(STS_SERVER_CONFIG_PROPERTY_FILE_PATH)
        return config.get('vmidentity.server.connector.ssl.client.auth.truststore.file', '')

    # In the following DB, search stops on first match.
    # Order of entries in the DB must be from most specific to least specific
    # (for example an entry with a version specifying a build must be before
    # the same version with no build).
    smartCardConfigDB = [
    #   Version        Build     Retrieval Function
    #   -------------  --------  ---------------------
        (VcVersion.V7, 20845200, xml_config_get_file),
        (VcVersion.V7, None,     revproxy_get_file),
        (VcVersion.V8, None,     xml_config_get_file),
        (VcVersion.V9, None,     prop_config_get_file),
    ]

    env = Environment.get_environment()
    vc_version = get_vc_version()
    vc_build = int(env.get_value('VC_BUILD'))

    # Resolve the retrieval function. We break on first match.
    get_file = None
    for versionConstraint, buildConstraint, func in smartCardConfigDB:
        if vc_version != versionConstraint:
            continue
        if buildConstraint and vc_build < buildConstraint:
            continue

        # Found a match.
        get_file = func
        break

    # If found, execute the retrieval function; otherwise return an empty
    # string.
    return get_file() if get_file else ''