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

import sys
import uuid
from concurrent.futures import ThreadPoolExecutor
from datetime import datetime
from itsi_py3 import _
from ITOA.itoa_common import get_current_utc_epoch
from ITOA.setup_logging import logger
from ITOA.storage.itoa_storage import ITOAStorage
from itsi.itsi_utils import ITOAInterfaceUtils
from itsi.objects.itsi_upgrade_readiness_prechecks import ItsiUpgradeReadinessPrechecks
from migration_utility.constants import MODES, MODES_STR_MAP, UPGRADE_READINESS_URL
from migration_utility.migration_utility_interface import ItsiMigrationUtilityInterface


class ItsiUpgradeReadinessLog(object):
    def __init__(self, session_key, app="SA-ITOA", user='nobody'):
        '''
        Constructor

        @type: string
        @param session_key:

        @type: string
        @param app: context of app invoking the request

        @type: string
        @param owner: "owner" user invoking this call

        @rtype: None
        @return: None
        '''
        self._session_key = session_key
        self._app = app
        self._user = user
        self._executor = ThreadPoolExecutor(max_workers=10)
        self.upgrade_readiness_precheck_obj = ItsiUpgradeReadinessPrechecks(
            self._session_key,
            'nobody'
        )

    def get_upgrade_readiness_precheck_job_status(self, transaction_id):
        '''
        Get the record of the upgrade readiness precheck job of the given transaction id.

        @type: string
        @param transaction_id

        @rtype: list of dictionary
        @return: objects retrieved on success, throws exceptions on errors
        '''
        filter_data = {
            'transaction_id': transaction_id
        }

        upgrade_readiness_precheck_job = self.upgrade_readiness_precheck_obj.get_bulk(
            'nobody',
            fields=['_key', 'start_time', 'transaction_id',
                    'status', 'object_type', 'title', 'operation_mode', 'precheck_started',
                    'precheck_start_time', 'remediation_started', 'remediation_start_time', 'process_id'],
            filter_data=filter_data)
        return upgrade_readiness_precheck_job

    def upgrade_readiness_activity(self, operation_mode=MODES["PRECHECK"]):
        '''
        Start a new upgrade readiness precheck job
        '''
        transaction_id = self._generate_transaction_id()
        logger.info(f'[transaction_id={transaction_id}] '
                    f'[operation_mode={MODES_STR_MAP[operation_mode]}] '
                    'Start synchronous job.')
        self._perform_upgrade_readiness_activity(transaction_id, MODES["PRECHECK"])

    def upgrade_readiness_activity_async(self,
                                         operation_mode,
                                         precheck_ids=None):
        '''
        Start a new async upgrade readiness precheck job
        '''
        transaction_id = self._generate_transaction_id()

        try:
            logger.info(f'[transaction_id={transaction_id}] '
                        f'[operation_mode={MODES_STR_MAP[operation_mode]}] '
                        'Enqueueing async job.')
            self._executor.submit(
                self._perform_upgrade_readiness_activity,
                transaction_id,
                operation_mode,
                precheck_ids,
            )

            return {
                "transaction_id": transaction_id,
                "status": "SUCCESS",
            }
        except Exception as e:
            logger.exception(e)
            logger.error(f'[transaction_id={transaction_id}] '
                         f'[operation_mode={MODES_STR_MAP[operation_mode]}] '
                         'Async job could not be enqueued.')
            return {
                "transaction_id": transaction_id,
                "status": "FAIL",
            }

    def _generate_transaction_id(self):
        '''
        Generate new transaction id by uuid.

        @rtype: string
        @return: new transaction_id
        '''
        return uuid.uuid4().hex

    def _perform_upgrade_readiness_activity(self,
                                            transaction_id,
                                            operation_mode,
                                            precheck_ids=None):
        '''
        Start a new upgrade readiness precheck job with a transaction id

        @type: string
        @return: transaction_id
        '''
        logger.info(f'[transaction_id={transaction_id}] '
                    f'[operation_mode={MODES_STR_MAP[operation_mode]}] '
                    'Performing upgrade readiness job.')
        kvstore = ITOAStorage()
        if kvstore.wait_for_storage_init(self._session_key):
            self.upgrade_readiness_precheck_obj.create_upgrade_readiness_precheck_job(transaction_id, operation_mode)

            # Execute upgrade readiness precheck or remediation
            jobs_processor = ItsiMigrationUtilityInterface(
                self._session_key, transaction_id)
            results, message, failed_precheck_count = jobs_processor.execute(operation_mode, precheck_ids)
            if results:
                self.upgrade_readiness_precheck_obj.update_upgrade_readiness_precheck_job(
                    transaction_id, status='COMPLETED', fail_message='')

                time = datetime.now().strftime('%H:%M:%S')
                date = datetime.now().strftime('%m/%d/%Y')
                WARNING_MESSAGE = _(
                    'The last upgrade readiness check executed at {0} on {1} and detected {2} issues. '
                    '[[{3}|View the Upgrade Readiness Dashboard.]]'
                ).format(time, date, failed_precheck_count, UPGRADE_READINESS_URL)
                ITOAInterfaceUtils.create_message(self._session_key, WARNING_MESSAGE)
                logger.info(f'[transaction_id={transaction_id}] '
                            f'[operation_mode={MODES_STR_MAP[operation_mode]}] '
                            '[final_message=completed_upgrade_readiness_job] Completed upgrade readiness job.')
            else:
                self.upgrade_readiness_precheck_obj.update_upgrade_readiness_precheck_job(
                    transaction_id, status='FAILED', fail_message=message)
                logger.error(f'[transaction_id={transaction_id}] '
                             f'[operation_mode={MODES_STR_MAP[operation_mode]}] '
                             'Job failed.')
        else:
            logger.error(f'[transaction_id={transaction_id}] '
                         f'[operation_mode={MODES_STR_MAP[operation_mode]}] '
                         'KV Store unavailable for Upgrade Readiness Job. Exiting.')
            self.upgrade_readiness_precheck_obj.update_upgrade_readiness_precheck_job(
                transaction_id, status='FAILED', fail_message='KV_UNAVAILABLE')