# Copyright (C) 2005-2024 Splunk Inc. All Rights Reserved.

import sys

from splunk.clilib.bundle_paths import make_splunkhome_path
import splunk.rest as rest

sys.path.append(make_splunkhome_path(['etc', 'apps', 'SA-ITOA', 'lib']))
sys.path.append(make_splunkhome_path(['etc', 'apps', 'SA-ITOA', 'lib', 'SA_ITOA_app_common']))
import itsi_path
from itsi_py3 import _

from ITOA.itoa_common import modular_input_should_run, is_feature_enabled

from itsi.itsi_version_compare import VersionComparison
from itsi.itsi_utils import ITOAInterfaceUtils
from itsi.upgrade.rename_re_log_files import RenameRELogFiles
# make sure itsi_migration_log is first in order, to setup global logger
from itsi.upgrade.java_file_fixer import JavaFileFixer
from itsi.itoa_rest_interface_provider.itoa_rest_interface_provider import ItoaInterfaceProvider
from SA_ITOA_app_common.solnlib.modular_input import ModularInput

from ITOA.setup_logging import getLogger4ModInput
from ITOA.mod_input_utils import skip_run_during_migration
from itsi.upgrade.constants import NEW_VERSION


class ConfigureITSI(ModularInput):
    """
    Just a basic modular input responsible for configuring ITSI.
    Here are just one of the many amazing things it does
        - Import entities from the conf file system into the statestore

    """
    title                    = _("IT Service Intelligence Configurator")  # noqa
    description              = _("Configures IT Service Intelligence")  # noqa
    handlers                 = None  # noqa
    app                      = 'SA-ITOA'  # noqa
    name                     = 'configure_itsi'  # noqa
    use_single_instance      = False  # noqa
    use_kvstore_checkpointer = False
    use_hec_event_writer     = False  # noqa

    def __init__(self):
        # Since logger is used before do_run is called, initialize logger first:
        super (ConfigureITSI, self).__init__()

    def extra_arguments(self):
        return [
            {
                'name'        : "log_level",
                'title'       : _("Logging Level"),
                'description' : _("This is the level at which the modular input will log data.")
            },
            {
                'name'        : "is_configured",
                'title'       : _("Configuration flag"),
                'description' : _("Old configuration")
            }
        ]

    @skip_run_during_migration
    def do_run(self, input_config):
        """
        First part, we need to find the ITSI stanzas, and then move them into the statestore
        The stanzas are just organized by type (entity, kpi, service) etc.  We are just going
        to do a 1:1 import into the statestore
        """
        logger = getLogger4ModInput(input_config)
        # log the message for restartless upgrade testing which can be useful while debugging.
        stanza_name = next(iter(input_config.keys()))
        logger.info(f"Restartless upgrade - Reloaded modular input {stanza_name}")
        # rename the rules engine log files
        try:
            rename_re_log_files = RenameRELogFiles(self.session_key, logger=logger)
            rename_re_log_files.run()
        except Exception:
            logger.exception('Failed to rename Rules Engine log file(s) on the search head.')
        try:
            java_fixer = JavaFileFixer(self.session_key, logger=logger)
            java_fixer.run()
        except Exception:
            logger.exception('Failed to run the Java archive file fixer on the search head.')

        if not modular_input_should_run(self.session_key, logger=logger):
            logger.info("Modular input will not run on this node.")
            return
        version_compare = VersionComparison()
        should_migrate = version_compare.should_render_migration_page(self.session_key)
        # if migrate, configure itsi along with migration process(upgrade/itsi_migration.py)
        if should_migrate:
            logger.info((
                'Migration pending. Exiting configure ITSI modular input as configuration'
                'will be handled by the migration process at the end'
            ))
            return
        # if not migrate, configure itsi with modular input
        ITOAInterfaceUtils.configure_version(self.session_key)
        ITOAInterfaceUtils.configure_team(self.session_key)
        ITOAInterfaceUtils.configure_itsi(self.session_key, logger)
        if is_feature_enabled('itsi-bulk-delete-retired-entities', self.session_key):
            ItoaInterfaceProvider.get_and_post_itsi_retired_entity_delete_status(self.session_key,
                                                                                 'nobody',
                                                                                 'entity',
                                                                                 is_restart=True)
        ITOAInterfaceUtils.configure_in_operator_support(self.session_key)
        # By default there should not be any enabled real time saved search
        # To resolve the https://splunk.atlassian.net/browse/ITSI-20861 app-inspect failure
        # itsi_event_grouping saved search is enabled if there is not entry in local conf
        # do not enable if high-scale-ea is enabled
        is_high_scale_ea_enabled = is_feature_enabled('itsi-high-scale-ea', self.session_key)
        if not is_high_scale_ea_enabled:
            ITOAInterfaceUtils.enable_itsi_event_grouping(self.session_key, logger)
        # The below function needs to be added in itsi_migration.py as well
        # This code is not executed during ITSI upgrade scenario as function returns from should_migrate check
        # Added function here for fresh installation of ITSI
        ITOAInterfaceUtils.update_itsi_cp_saved_searches_collection(self.session_key, logger)


if __name__ == "__main__":
    worker = ConfigureITSI()
    worker.execute()
    sys.exit(0)