// SPDX-License-Identifier: Apache-2.0
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import { format } from 'node:util';
import { SoloError } from './errors/solo-error.js';
import { Templates } from './templates.js';
import * as constants from './constants.js';
import { PrivateKey, ServiceEndpoint } from '@hiero-ledger/sdk';
import { NamespaceName } from '../types/namespace/namespace-name.js';
import chalk from 'chalk';
import { PathEx } from '../business/utils/path-ex.js';
import { Flags, Flags as flags } from '../commands/flags.js';
import { execSync } from 'node:child_process';
import yaml from 'yaml';
import { BlockNodesJsonWrapper } from './block-nodes-json-wrapper.js';
import { K8Helper } from '../business/utils/k8-helper.js';
import { SemanticVersion } from '../business/utils/semantic-version.js';
export function getInternalAddress(releaseVersion, namespaceName, nodeAlias) {
    return new SemanticVersion(releaseVersion).greaterThanOrEqual('0.58.5')
        ? '127.0.0.1'
        : Templates.renderFullyQualifiedNetworkPodName(namespaceName, nodeAlias);
}
export function sleep(duration) {
    return new Promise((resolve) => {
        setTimeout(resolve, duration.toMillis());
    });
}
export function parseNodeAliases(input, consensusNodes, configManager) {
    let nodeAliases = splitFlagInput(input, ',');
    if (nodeAliases.length === 0) {
        nodeAliases = consensusNodes?.map((node) => {
            return node.name;
        });
        configManager?.setFlag(flags.nodeAliasesUnparsed, nodeAliases.join(','));
        if (!nodeAliases || nodeAliases.length === 0) {
            return [];
        }
    }
    return nodeAliases;
}
export function splitFlagInput(input, separator = ',') {
    if (!input) {
        return [];
    }
    else if (typeof input !== 'string') {
        throw new SoloError(`input [input='${input}'] is not a comma separated string`);
    }
    return input
        .split(separator)
        .map((s) => s.trim())
        .filter(Boolean);
}
/**
 * @param arr - The array to be cloned
 * @returns a new array with the same elements as the input array
 */
export function cloneArray(array) {
    return structuredClone(array);
}
export function getTemporaryDirectory() {
    return fs.mkdtempSync(PathEx.join(os.tmpdir(), 'solo-'));
}
export function createBackupDirectory(destinationDirectory, prefix = 'backup', currentDate = new Date()) {
    const dateDirectory = format('%s%s%s_%s%s%s', currentDate.getFullYear(), currentDate.getMonth().toString().padStart(2, '0'), currentDate.getDate().toString().padStart(2, '0'), currentDate.getHours().toString().padStart(2, '0'), currentDate.getMinutes().toString().padStart(2, '0'), currentDate.getSeconds().toString().padStart(2, '0'));
    const backupDirectory = PathEx.join(destinationDirectory, prefix, dateDirectory);
    if (!fs.existsSync(backupDirectory)) {
        fs.mkdirSync(backupDirectory, { recursive: true });
    }
    return backupDirectory;
}
export function makeBackup(fileMap = new Map(), removeOld = true) {
    for (const entry of fileMap) {
        const sourcePath = entry[0];
        const destinationPath = entry[1];
        if (fs.existsSync(sourcePath)) {
            fs.cpSync(sourcePath, destinationPath);
            if (removeOld) {
                fs.rmSync(sourcePath);
            }
        }
    }
}
export function backupOldTlsKeys(nodeAliases, keysDirectory, currentDate = new Date(), directoryPrefix = 'tls') {
    const backupDirectory = createBackupDirectory(keysDirectory, `unused-${directoryPrefix}`, currentDate);
    const fileMap = new Map();
    for (const nodeAlias of nodeAliases) {
        const sourcePath = PathEx.join(keysDirectory, Templates.renderTLSPemPrivateKeyFile(nodeAlias));
        const destinationPath = PathEx.join(backupDirectory, Templates.renderTLSPemPrivateKeyFile(nodeAlias));
        fileMap.set(sourcePath, destinationPath);
    }
    makeBackup(fileMap, true);
    return backupDirectory;
}
export function backupOldPemKeys(nodeAliases, keysDirectory, currentDate = new Date(), directoryPrefix = 'gossip-pem') {
    const backupDirectory = createBackupDirectory(keysDirectory, `unused-${directoryPrefix}`, currentDate);
    const fileMap = new Map();
    for (const nodeAlias of nodeAliases) {
        const sourcePath = PathEx.join(keysDirectory, Templates.renderGossipPemPrivateKeyFile(nodeAlias));
        const destinationPath = PathEx.join(backupDirectory, Templates.renderGossipPemPrivateKeyFile(nodeAlias));
        fileMap.set(sourcePath, destinationPath);
    }
    makeBackup(fileMap, true);
    return backupDirectory;
}
export function getEnvironmentValue(environmentVariableArray, name) {
    const kvPair = environmentVariableArray.find((v) => v.startsWith(`${name}=`));
    return kvPair ? kvPair.split('=')[1] : undefined;
}
export function parseIpAddressToUint8Array(ipAddress) {
    const parts = ipAddress.split('.');
    const uint8Array = new Uint8Array(4);
    for (let index = 0; index < 4; index++) {
        uint8Array[index] = Number.parseInt(parts[index], 10);
    }
    return uint8Array;
}
/** If the basename of the src did not match expected basename, rename it first, then copy to destination */
export function renameAndCopyFile(sourceFilePath, expectedBaseName, destinationDirectory) {
    const sourceDirectory = path.dirname(sourceFilePath);
    if (path.basename(sourceFilePath) !== expectedBaseName) {
        fs.renameSync(sourceFilePath, PathEx.join(sourceDirectory, expectedBaseName));
    }
    // copy public key and private key to key directory
    fs.copyFile(PathEx.joinWithRealPath(sourceDirectory, expectedBaseName), PathEx.join(destinationDirectory, expectedBaseName), (error) => {
        if (error) {
            throw new SoloError(`Error copying file: ${error.message}`);
        }
    });
}
/**
 * Add debug options to valuesArg used by helm chart
 * @param valuesArgument the valuesArg to update
 * @param debugNodeAlias the node ID to attach the debugger to
 * @param index the index of extraEnv to add the debug options to
 * @returns updated valuesArg
 */
export function addDebugOptions(valuesArgument, debugNodeAlias, index = 0) {
    if (debugNodeAlias) {
        const nodeId = Templates.nodeIdFromNodeAlias(debugNodeAlias);
        valuesArgument += ` --set "hedera.nodes[${nodeId}].root.extraEnv[${index}].name=JAVA_OPTS"`;
        valuesArgument += String.raw ` --set "hedera.nodes[${nodeId}].root.extraEnv[${index}].value=-agentlib:jdwp=transport=dt_socket\,server=y\,suspend=y\,address=*:${constants.JVM_DEBUG_PORT}"`;
    }
    return valuesArgument;
}
/**
 * Append root.image registry/repository/tag settings for a given node path to a Helm values argument string.
 * @param valuesArgument - existing values argument string (may be empty)
 * @param nodePath - base node path, e.g. `hedera.nodes[0]`
 * @param registry - image registry
 * @param repository - image repository
 * @param tag - image tag
 * @returns updated values argument string
 */
export function addRootImageValues(valuesArgument, nodePath, registry, repository, tag) {
    let updatedValuesArgument = valuesArgument ?? '';
    updatedValuesArgument += ` --set "${nodePath}.root.image.registry=${registry}"`;
    updatedValuesArgument += ` --set "${nodePath}.root.image.tag=${tag}"`;
    updatedValuesArgument += ` --set "${nodePath}.root.image.repository=${repository}"`;
    return updatedValuesArgument;
}
/**
 * Returns an object that can be written to a file without data loss.
 * Contains fields needed for adding a new node through separate commands
 * @param ctx
 * @returns file writable object
 */
export function addSaveContextParser(context_) {
    const exportedContext = {};
    const config = context_.config;
    const exportedFields = ['tlsCertHash', 'upgradeZipHash', 'newNode'];
    exportedContext.signingCertDer = context_.signingCertDer.toString();
    exportedContext.gossipEndpoints = context_.gossipEndpoints.map((endpoint) => `${endpoint._domainName}:${endpoint._port}`);
    exportedContext.grpcServiceEndpoints = context_.grpcServiceEndpoints.map((endpoint) => `${endpoint._domainName}:${endpoint._port}`);
    exportedContext.adminKey = context_.adminKey.toString();
    // @ts-expect-error - existingNodeAliases may not be defined on config
    exportedContext.existingNodeAliases = config.existingNodeAliases;
    for (const property of exportedFields) {
        exportedContext[property] = context_[property];
    }
    return exportedContext;
}
/**
 * Initializes objects in the context from a provided string
 * Contains fields needed for adding a new node through separate commands
 * @param ctx - accumulator object
 * @param ctxData - data in string format
 * @returns file writable object
 */
export function addLoadContextParser(context_, contextData) {
    const config = context_.config;
    context_.signingCertDer = new Uint8Array(contextData.signingCertDer.split(','));
    context_.gossipEndpoints = prepareEndpoints(context_.config.endpointType, contextData.gossipEndpoints, constants.HEDERA_NODE_INTERNAL_GOSSIP_PORT);
    context_.grpcServiceEndpoints = prepareEndpoints(context_.config.endpointType, contextData.grpcServiceEndpoints, constants.HEDERA_NODE_EXTERNAL_GOSSIP_PORT);
    context_.adminKey = PrivateKey.fromStringED25519(contextData.adminKey);
    config.nodeAlias = contextData.newNode.name;
    config.existingNodeAliases = contextData.existingNodeAliases;
    config.allNodeAliases = [...config.existingNodeAliases, contextData.newNode.name];
    config.newNodeAliases = [contextData.newNode.name];
    const fieldsToImport = ['tlsCertHash', 'upgradeZipHash', 'newNode'];
    for (const property of fieldsToImport) {
        context_[property] = contextData[property];
    }
}
export function prepareEndpoints(endpointType, endpoints, defaultPort) {
    const returnValue = [];
    for (const endpoint of endpoints) {
        const parts = endpoint.split(':');
        let url = '';
        let port = defaultPort;
        if (parts.length === 2) {
            url = parts[0].trim();
            port = +parts[1].trim();
        }
        else if (parts.length === 1) {
            url = parts[0];
        }
        else {
            throw new SoloError(`incorrect endpoint format. expected url:port, found ${endpoint}`);
        }
        if (endpointType.toUpperCase() === constants.ENDPOINT_TYPE_IP) {
            returnValue.push(new ServiceEndpoint({
                port: +port,
                ipAddressV4: parseIpAddressToUint8Array(url),
            }));
        }
        else {
            returnValue.push(new ServiceEndpoint({
                port: +port,
                domainName: url,
            }));
        }
    }
    return returnValue;
}
/** Adds all the types of flags as properties on the provided argv object */
export function addFlagsToArgv(argv, flags) {
    argv.required = flags.required;
    argv.optional = flags.optional;
    return argv;
}
export function resolveValidJsonFilePath(filePath, defaultPath) {
    if (!filePath) {
        if (defaultPath) {
            return resolveValidJsonFilePath(defaultPath);
        }
        return '';
    }
    const resolvedFilePath = PathEx.realPathSync(filePath);
    if (!fs.existsSync(resolvedFilePath)) {
        if (defaultPath) {
            return resolveValidJsonFilePath(defaultPath);
        }
        throw new SoloError(`File does not exist: ${filePath}`);
    }
    // If the file is empty (or size cannot be determined) then fallback on the default values
    const throttleInfo = fs.statSync(resolvedFilePath);
    if (throttleInfo.size === 0 && defaultPath) {
        return resolveValidJsonFilePath(defaultPath);
    }
    else if (throttleInfo.size === 0) {
        throw new SoloError(`File is empty: ${filePath}`);
    }
    try {
        // Ensure the file contains valid JSON data
        JSON.parse(fs.readFileSync(resolvedFilePath, 'utf8'));
        return resolvedFilePath;
    }
    catch {
        // Fallback to the default values if an error occurs due to invalid JSON data or unable to read the file size
        if (defaultPath) {
            return resolveValidJsonFilePath(defaultPath);
        }
        throw new SoloError(`Invalid JSON data in file: ${filePath}`);
    }
}
export function prepareValuesFiles(valuesFile) {
    let valuesArgument = '';
    if (valuesFile) {
        const valuesFiles = valuesFile.split(',');
        for (const vf of valuesFiles) {
            const vfp = PathEx.resolve(vf);
            valuesArgument += ` --values ${vfp}`;
        }
    }
    return valuesArgument;
}
export function populateHelmArguments(valuesMapping) {
    let valuesArgument = '';
    for (const [key, value] of Object.entries(valuesMapping)) {
        valuesArgument += ` --set ${key}=${value}`;
    }
    return valuesArgument;
}
/**
 * @param nodeAlias
 * @param consensusNodes
 * @returns context of the node
 */
export function extractContextFromConsensusNodes(nodeAlias, consensusNodes) {
    if (!consensusNodes) {
        return undefined;
    }
    if (consensusNodes.length === 0) {
        return undefined;
    }
    const consensusNode = consensusNodes.find((node) => node.name === nodeAlias);
    return consensusNode ? consensusNode.context : undefined;
}
/**
 * Check if the namespace exists in the context of given consensus nodes
 * @param consensusNodes
 * @param k8Factory
 * @param namespace
 */
export async function checkNamespace(consensusNodes, k8Factory, namespace) {
    for (const consensusNode of consensusNodes) {
        const k8 = k8Factory.getK8(consensusNode.context);
        if (!(await k8.namespaces().has(namespace))) {
            throw new SoloError(`namespace ${namespace} does not exist in context ${consensusNode.context}`);
        }
    }
}
/**
 * Show a banner with the chart name and version
 * @param logger
 * @param chartName The name of the chart
 * @param version The version of the chart
 * @param type The action that was performed such as 'Installed' or 'Upgraded'
 */
// TODO convert usages to leverage the logger.addMessageGroupMessage()
export function showVersionBanner(logger, chartName, version, type = 'Installed') {
    logger.showUser(chalk.cyan(` - ${type} ${chartName} chart, version:`, chalk.yellow(version)));
}
/**
 * Check if the input is a valid IPv4 address
 * @param input
 * @returns true if the input is a valid IPv4 address, false otherwise
 */
export function isIpV4Address(input) {
    const ipv4Regex = /^(25[0-5]|2[0-4][0-9]|1?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|1?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|1?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|1?[0-9][0-9]?)$/;
    return ipv4Regex.test(input);
}
/**
 * Convert an IPv4 address to a base64 string
 * @param ipv4 The IPv4 address to convert
 * @returns The base64 encoded string representation of the IPv4 address
 */
export function ipV4ToBase64(ipv4) {
    // Split the IPv4 address into its octets
    const octets = ipv4.split('.').map((octet) => {
        const number_ = Number.parseInt(octet, 10);
        // eslint-disable-next-line unicorn/prefer-number-properties
        if (isNaN(number_) || number_ < 0 || number_ > 255) {
            throw new Error(`Invalid IPv4 address: ${ipv4}`);
        }
        return number_;
    });
    if (octets.length !== 4) {
        throw new Error(`Invalid IPv4 address: ${ipv4}`);
    }
    // Convert the octets to a Uint8Array
    const uint8Array = new Uint8Array(octets);
    // Base64 encode the byte array
    return btoa(String.fromCodePoint(...uint8Array));
}
export function entityId(shard, realm, number) {
    return `${shard}.${realm}.${number}`;
}
export async function withTimeout(promise, duration, errorMessage = 'Timeout') {
    return Promise.race([promise, throwAfter(duration, errorMessage)]);
}
async function throwAfter(duration, message = 'Timeout') {
    await sleep(duration);
    throw new SoloError(message);
}
/**
 * Checks if a Docker image with the given name and tag exists locally.
 * @param imageName The name of the Docker image (e.g., "block-node-server").
 * @param imageTag The tag of the Docker image (e.g., "0.12.0").
 * @returns True if the image exists, false otherwise.
 */
export function checkDockerImageExists(imageName, imageTag) {
    const fullImageName = `${imageName}:${imageTag}`;
    try {
        // Execute the 'docker images' command and filter by the image name
        // The --format "{{.Repository}}:{{.Tag}}" ensures consistent output
        // We use grep to filter for the exact image:tag
        const command = `docker images --format "{{.Repository}}:{{.Tag}}" | grep -E "^${fullImageName}$"`;
        const output = execSync(command, { encoding: 'utf8', stdio: 'pipe' });
        return output.trim() === fullImageName;
    }
    catch (error) {
        console.error(`Error checking Docker image ${fullImageName}:`, error.message);
        return false;
    }
}
export function createDirectoryIfNotExists(file) {
    const directory = path.dirname(file);
    if (!fs.existsSync(directory)) {
        fs.mkdirSync(directory, { recursive: true });
    }
}
export async function findMinioOperator(context, k8) {
    const minioTenantPod = await k8
        .getK8(context)
        .pods()
        .listForAllNamespaces(['app.kubernetes.io/name=operator', 'operator=leader'])
        .then((pods) => pods[0]);
    if (!minioTenantPod) {
        return {
            exists: false,
            releaseName: undefined,
        };
    }
    return {
        exists: true,
        releaseName: minioTenantPod.labels?.['app.kubernetes.io/instance'],
    };
}
export function remoteConfigsToDeploymentsTable(remoteConfigs) {
    const rows = [];
    if (remoteConfigs.length > 0) {
        rows.push('Namespace : deployment');
        for (const remoteConfig of remoteConfigs) {
            const remoteConfigData = yaml.parse(remoteConfig.data['remote-config-data']);
            for (const cluster of remoteConfigData.clusters) {
                rows.push(`${remoteConfig.namespace.name} : ${cluster.deployment}`);
            }
        }
    }
    return rows;
}
/**
 * Prepare the values files map for each cluster
 *
 * Order of precedence:
 * 1. Chart's default values file (if chartDirectory is set)
 * 2. Profile values file
 * 3. User's values file
 * @param clusterReferences
 * @param valuesFileInput - the values file input string
 * @param chartDirectory - the chart directory
 * @param profileValuesFile - the profile values file full path
 */
export function prepareValuesFilesMap(clusterReferences, chartDirectory, profileValuesFile, valuesFileInput) {
    // initialize the map with an empty array for each cluster-ref
    const valuesFiles = {
        [Flags.KEY_COMMON]: '',
    };
    for (const [clusterReference] of clusterReferences) {
        valuesFiles[clusterReference] = '';
    }
    // add the chart's default values file for each cluster-ref if chartDirectory is set
    // this should be the first in the list of values files as it will be overridden by user's input
    if (chartDirectory) {
        const chartValuesFile = PathEx.join(chartDirectory, 'solo-deployment', 'values.yaml');
        for (const clusterReference in valuesFiles) {
            valuesFiles[clusterReference] += ` --values ${chartValuesFile}`;
        }
    }
    if (profileValuesFile) {
        const parsed = Flags.parseValuesFilesInput(profileValuesFile);
        for (const [clusterReference, files] of Object.entries(parsed)) {
            let vf = '';
            for (const file of files) {
                vf += ` --values ${file}`;
            }
            if (clusterReference === Flags.KEY_COMMON) {
                for (const [cf] of Object.entries(valuesFiles)) {
                    valuesFiles[cf] += vf;
                }
            }
            else {
                valuesFiles[clusterReference] += vf;
            }
        }
    }
    if (valuesFileInput) {
        const parsed = Flags.parseValuesFilesInput(valuesFileInput);
        for (const [clusterReference, files] of Object.entries(parsed)) {
            let vf = '';
            for (const file of files) {
                vf += ` --values ${file}`;
            }
            if (clusterReference === Flags.KEY_COMMON) {
                for (const [clusterReference_] of Object.entries(valuesFiles)) {
                    valuesFiles[clusterReference_] += vf;
                }
            }
            else {
                valuesFiles[clusterReference] += vf;
            }
        }
    }
    if (Object.keys(valuesFiles).length > 1) {
        // delete the common key if there is another cluster to use
        delete valuesFiles[Flags.KEY_COMMON];
    }
    return valuesFiles;
}
/**
 * Prepare the values files map for each cluster
 *
 * Order of precedence:
 * 1. Chart's default values file (if chartDirectory is set)
 * 2. Base values files (applied after chart defaults, before the generated profile values file)
 * 3. Profile values file
 * 4. User's values file
 * @param clusterReferences
 * @param chartDirectory - the chart directory
 * @param profileValuesFile - mapping of clusterRef to the profile values file full path
 * @param valuesFileInput - the values file input string
 * @param baseValuesFiles - optional list of values file paths inserted between chart defaults and profile values
 */
export function prepareValuesFilesMapMultipleCluster(clusterReferences, chartDirectory, profileValuesFile, valuesFileInput, baseValuesFiles) {
    // initialize the map with an empty array for each cluster-ref
    const valuesFiles = { [Flags.KEY_COMMON]: '' };
    for (const [clusterReference] of clusterReferences) {
        valuesFiles[clusterReference] = '';
    }
    // add the chart's default values file for each cluster-ref if chartDirectory is set
    // this should be the first in the list of values files as it will be overridden by user's input
    if (chartDirectory) {
        const chartValuesFile = PathEx.join(chartDirectory, 'solo-deployment', 'values.yaml');
        for (const clusterReference in valuesFiles) {
            valuesFiles[clusterReference] += ` --values ${chartValuesFile}`;
        }
    }
    // add base values files (e.g. component defaults) after chart defaults but before profile values
    if (baseValuesFiles) {
        for (const file of baseValuesFiles) {
            for (const clusterReference in valuesFiles) {
                valuesFiles[clusterReference] += ` --values ${file}`;
            }
        }
    }
    if (profileValuesFile) {
        for (const [clusterReference, file] of Object.entries(profileValuesFile)) {
            const valuesArgument = ` --values ${file}`;
            if (clusterReference === Flags.KEY_COMMON) {
                for (const clusterReference_ of Object.keys(valuesFiles)) {
                    valuesFiles[clusterReference_] += valuesArgument;
                }
            }
            else {
                valuesFiles[clusterReference] += valuesArgument;
            }
        }
    }
    if (valuesFileInput) {
        const parsed = Flags.parseValuesFilesInput(valuesFileInput);
        for (const [clusterReference, files] of Object.entries(parsed)) {
            let vf = '';
            for (const file of files) {
                vf += ` --values ${file}`;
            }
            if (clusterReference === Flags.KEY_COMMON) {
                for (const [clusterReference_] of Object.entries(valuesFiles)) {
                    valuesFiles[clusterReference_] += vf;
                }
            }
            else {
                valuesFiles[clusterReference] += vf;
            }
        }
    }
    if (Object.keys(valuesFiles).length > 1) {
        // delete the common key if there is another cluster to use
        delete valuesFiles[Flags.KEY_COMMON];
    }
    return valuesFiles;
}
/**
 * @param consensusNode - the targeted consensus node
 * @param logger
 * @param k8Factory
 */
export async function createAndCopyBlockNodeJsonFileForConsensusNode(consensusNode, logger, k8Factory) {
    const { nodeId, context, name: nodeAlias, blockNodeMap, externalBlockNodeMap, namespace: namespaceNameAsString, } = consensusNode;
    const namespace = NamespaceName.of(namespaceNameAsString);
    const blockNodesJsonData = new BlockNodesJsonWrapper(blockNodeMap, externalBlockNodeMap).toJSON();
    const blockNodesJsonFilename = `${constants.BLOCK_NODES_JSON_FILE.replace('.json', '')}-${nodeId}.json`;
    const blockNodesJsonPath = PathEx.join(constants.SOLO_CACHE_DIR, blockNodesJsonFilename);
    fs.writeFileSync(blockNodesJsonPath, JSON.stringify(JSON.parse(blockNodesJsonData), undefined, 2));
    // Check if the file exists before copying
    if (!fs.existsSync(blockNodesJsonPath)) {
        logger.warn(`Block nodes JSON file not found: ${blockNodesJsonPath}`);
        return;
    }
    const k8 = k8Factory.getK8(context);
    const container = await new K8Helper(context).getConsensusNodeRootContainer(namespace, nodeAlias);
    await container.execContainer('pwd');
    const targetDirectory = `${constants.HEDERA_HAPI_PATH}/data/config`;
    await container.execContainer(`mkdir -p ${targetDirectory}`);
    // Copy the file and rename it to block-nodes.json in the destination
    await container.copyTo(blockNodesJsonPath, targetDirectory);
    // If using node-specific files, rename the copied file to the standard name
    const sourceFilename = path.basename(blockNodesJsonPath);
    await container.execContainer(`mv ${targetDirectory}/${sourceFilename} ${targetDirectory}/${constants.BLOCK_NODES_JSON_FILE}`);
    const applicationPropertiesFilePath = `${constants.HEDERA_HAPI_PATH}/data/config/application.properties`;
    const applicationPropertiesData = await container.execContainer(`cat ${applicationPropertiesFilePath}`);
    const lines = applicationPropertiesData.split('\n');
    // Remove line to enable overriding below.
    for (const line of lines) {
        if (line === 'blockStream.streamMode=RECORDS') {
            lines.splice(lines.indexOf(line), 1);
        }
    }
    // Switch to block streaming.
    if (!lines.some((line) => line.startsWith('blockStream.streamMode='))) {
        lines.push(`blockStream.streamMode=${constants.BLOCK_STREAM_STREAM_MODE}`);
    }
    if (!lines.some((line) => line.startsWith('blockStream.writerMode='))) {
        lines.push(`blockStream.writerMode=${constants.BLOCK_STREAM_WRITER_MODE}`);
    }
    await k8.configMaps().update(namespace, 'network-node-data-config-cm', {
        ['applicationProperties']: lines.join('\n'),
        ['application.properties']: lines.join('\n'),
    });
    const configName = `network-${nodeAlias}-data-config-cm`;
    const configMapExists = await k8.configMaps().exists(namespace, configName);
    await (configMapExists
        ? k8.configMaps().update(namespace, configName, { 'block-nodes.json': blockNodesJsonData })
        : k8.configMaps().create(namespace, configName, {}, { 'block-nodes.json': blockNodesJsonData }));
    logger.debug(`Copied block-nodes configuration to consensus node ${consensusNode.name}`);
    const updatedApplicationPropertiesFilePath = PathEx.join(constants.SOLO_CACHE_DIR, 'application.properties');
    fs.writeFileSync(updatedApplicationPropertiesFilePath, lines.join('\n'));
    await container.copyTo(updatedApplicationPropertiesFilePath, targetDirectory);
}
//# sourceMappingURL=helpers.js.map