// SPDX-License-Identifier: Apache-2.0
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
import fs from 'node:fs';
import path from 'node:path';
import { SoloError } from './errors/solo-error.js';
import { IllegalArgumentError } from './errors/illegal-argument-error.js';
import { MissingArgumentError } from './errors/missing-argument-error.js';
import * as yaml from 'yaml';
import dot from 'dot-object';
import * as semver from 'semver';
import { readFile, writeFile } from 'node:fs/promises';
import { Flags as flags } from '../commands/flags.js';
import { Templates } from './templates.js';
import * as constants from './constants.js';
import * as helpers from './helpers.js';
import { inject, injectable } from 'tsyringe-neo';
import { patchInject } from './dependency-injection/container-helper.js';
import * as versions from '../../version.js';
import { NamespaceName } from '../types/namespace/namespace-name.js';
import { InjectTokens } from './dependency-injection/inject-tokens.js';
import { PathEx } from '../business/utils/path-ex.js';
import { AccountManager } from './account-manager.js';
import { LocalConfigRuntimeState } from '../business/runtime-state/config/local/local-config-runtime-state.js';
let ProfileManager = class ProfileManager {
    logger;
    configManager;
    cacheDir;
    k8Factory;
    remoteConfig;
    accountManager;
    localConfig;
    profiles;
    profileFile;
    constructor(logger, configManager, cacheDirectory, k8Factory, remoteConfig, accountManager, localConfig) {
        this.logger = patchInject(logger, InjectTokens.SoloLogger, this.constructor.name);
        this.configManager = patchInject(configManager, InjectTokens.ConfigManager, this.constructor.name);
        this.cacheDir = PathEx.resolve(patchInject(cacheDirectory, InjectTokens.CacheDir, this.constructor.name));
        this.k8Factory = patchInject(k8Factory, InjectTokens.K8Factory, this.constructor.name);
        this.remoteConfig = patchInject(remoteConfig, InjectTokens.RemoteConfigRuntimeState, this.constructor.name);
        this.accountManager = patchInject(accountManager, InjectTokens.AccountManager, this.constructor.name);
        this.localConfig = patchInject(localConfig, InjectTokens.LocalConfigRuntimeState, this.constructor.name);
        this.profiles = new Map();
    }
    /**
     * Load profiles from a profile file and populate the profiles map.
     *
     * @param [forceReload = false] - forces the profiles map to override even if it exists.
     * @returns reference to the populated profiles map.
     *
     * @throws {IllegalArgumentError} if the profile file is not found.
     */
    loadProfiles(forceReload = false) {
        const profileFile = this.configManager.getFlagFile(flags.profileFile);
        if (!profileFile) {
            throw new MissingArgumentError('profileFile is required');
        }
        // return the cached value as quickly as possible
        if (this.profiles && this.profileFile === profileFile && !forceReload) {
            return this.profiles;
        }
        if (!fs.existsSync(profileFile)) {
            throw new IllegalArgumentError(`profileFile does not exist: ${profileFile}`);
        }
        // load profile file
        this.profiles = new Map();
        const yamlData = fs.readFileSync(profileFile, 'utf8');
        const profileItems = yaml.parse(yamlData);
        // add profiles
        for (const key in profileItems) {
            let profile = profileItems[key];
            profile = profile || {};
            this.profiles.set(key, profile);
        }
        this.profileFile = profileFile;
        return this.profiles;
    }
    /**
     * Get profile from the profiles map, loads them on demand if they are not loaded already.
     *
     * @param profileName - profile name (key in the map).
     * @returns the profile.
     *
     * @throws {IllegalArgumentError} if profiles can't be loaded or the profile name is not found in the map.
     */
    getProfile(profileName) {
        if (!profileName) {
            throw new MissingArgumentError('profileName is required');
        }
        if (!this.profiles || this.profiles.size <= 0) {
            this.loadProfiles();
        }
        if (!this.profiles || !this.profiles.has(profileName)) {
            throw new IllegalArgumentError(`Profile does not exists with name: ${profileName}`);
        }
        return this.profiles.get(profileName);
    }
    /**
     * Set value in the YAML object
     * @param itemPath - item path in the yaml
     * @param value - value to be set
     * @param yamlRoot - root of the YAML object
     * @returns
     */
    _setValue(itemPath, value, yamlRoot) {
        // find the location where to set the value in the YAML
        const itemPathParts = itemPath.split('.');
        let parent = yamlRoot;
        let current = parent;
        let previousItemPath = '';
        for (let itemPathPart of itemPathParts) {
            if (helpers.isNumeric(itemPathPart)) {
                // @ts-ignore
                itemPathPart = Number.parseInt(itemPathPart); // numeric path part can only be array index i.e., an integer
                if (!Array.isArray(parent[previousItemPath])) {
                    parent[previousItemPath] = [];
                }
                if (!parent[previousItemPath][itemPathPart]) {
                    parent[previousItemPath][itemPathPart] = {};
                }
                parent = parent[previousItemPath];
                previousItemPath = itemPathPart;
                current = parent[itemPathPart];
            }
            else {
                if (!current[itemPathPart]) {
                    current[itemPathPart] = {};
                }
                parent = current;
                previousItemPath = itemPathPart;
                current = parent[itemPathPart];
            }
        }
        parent[previousItemPath] = value;
        return yamlRoot;
    }
    /**
     * Set items for the chart
     * @param itemPath - item path in the YAML, if empty then root of the YAML object will be used
     * @param items - the element object
     * @param yamlRoot - root of the YAML object to update
     */
    _setChartItems(itemPath, items, yamlRoot) {
        if (!items) {
            return;
        }
        const dotItems = dot.dot(items);
        for (const key in dotItems) {
            let itemKey = key;
            // if it is an array key like extraEnv[0].JAVA_OPTS, convert it into a dot separated key as extraEnv.0.JAVA_OPTS
            if (key.includes('[')) {
                itemKey = key.replace('[', '.').replace(']', '');
            }
            if (itemPath) {
                this._setValue(`${itemPath}.${itemKey}`, dotItems[key], yamlRoot);
            }
            else {
                this._setValue(itemKey, dotItems[key], yamlRoot);
            }
        }
    }
    async prepareStagingDirectory(consensusNodes, nodeAliases, yamlRoot, domainNamesMapping, deploymentName, applicationPropertiesPath) {
        const accountMap = this.accountManager.getNodeAccountMap(consensusNodes.map(node => node.name), deploymentName);
        // set consensus pod level resources
        for (const [nodeIndex, nodeAlias] of nodeAliases.entries()) {
            this._setValue(`hedera.nodes.${nodeIndex}.name`, nodeAlias, yamlRoot);
            this._setValue(`hedera.nodes.${nodeIndex}.nodeId`, `${Templates.nodeIdFromNodeAlias(nodeAlias)}`, yamlRoot);
            this._setValue(`hedera.nodes.${nodeIndex}.accountId`, accountMap.get(nodeAlias), yamlRoot);
        }
        const stagingDirectory = Templates.renderStagingDir(this.configManager.getFlag(flags.cacheDir), this.configManager.getFlag(flags.releaseTag));
        if (!fs.existsSync(stagingDirectory)) {
            fs.mkdirSync(stagingDirectory, { recursive: true });
        }
        const configTxtPath = await this.prepareConfigTxt(accountMap, consensusNodes, stagingDirectory, this.configManager.getFlag(flags.releaseTag), domainNamesMapping, this.configManager.getFlag(flags.app), this.configManager.getFlag(flags.chainId), this.configManager.getFlag(flags.loadBalancerEnabled));
        // Update application.properties with shard and realm
        await this.updateApplicationPropertiesWithRealmAndShard(applicationPropertiesPath, this.localConfig.configuration.realmForDeployment(deploymentName), this.localConfig.configuration.shardForDeployment(deploymentName));
        await this.updateApplicationPropertiesForBlockNode(applicationPropertiesPath);
        for (const flag of flags.nodeConfigFileFlags.values()) {
            const filePath = this.configManager.getFlagFile(flag);
            if (!filePath) {
                throw new SoloError(`Configuration file path is missing for: ${flag.name}`);
            }
            const fileName = path.basename(filePath);
            const destinationPath = PathEx.join(stagingDirectory, 'templates', fileName);
            this.logger.debug(`Copying configuration file to staging: ${filePath} -> ${destinationPath}`);
            fs.cpSync(filePath, destinationPath, { force: true });
        }
        this._setFileContentsAsValue('hedera.configMaps.configTxt', configTxtPath, yamlRoot);
        this._setFileContentsAsValue('hedera.configMaps.log4j2Xml', PathEx.joinWithRealPath(stagingDirectory, 'templates', 'log4j2.xml'), yamlRoot);
        this._setFileContentsAsValue('hedera.configMaps.settingsTxt', PathEx.joinWithRealPath(stagingDirectory, 'templates', 'settings.txt'), yamlRoot);
        this._setFileContentsAsValue('hedera.configMaps.applicationProperties', PathEx.joinWithRealPath(stagingDirectory, 'templates', 'application.properties'), yamlRoot);
        this._setFileContentsAsValue('hedera.configMaps.apiPermissionsProperties', PathEx.joinWithRealPath(stagingDirectory, 'templates', 'api-permission.properties'), yamlRoot);
        this._setFileContentsAsValue('hedera.configMaps.bootstrapProperties', PathEx.joinWithRealPath(stagingDirectory, 'templates', 'bootstrap.properties'), yamlRoot);
        this._setFileContentsAsValue('hedera.configMaps.applicationEnv', PathEx.joinWithRealPath(stagingDirectory, 'templates', 'application.env'), yamlRoot);
    }
    async resourcesForConsensusPod(profile, consensusNodes, nodeAliases, yamlRoot, domainNamesMapping, deploymentName, applicationPropertiesPath) {
        if (!profile) {
            throw new MissingArgumentError('profile is required');
        }
        await this.prepareStagingDirectory(consensusNodes, nodeAliases, yamlRoot, domainNamesMapping, deploymentName, applicationPropertiesPath);
        if (profile.consensus) {
            // set default for consensus pod
            this._setChartItems('defaults.root', profile.consensus.root, yamlRoot);
            // set sidecar resources
            for (const sidecar of constants.HEDERA_NODE_SIDECARS) {
                this._setChartItems(`defaults.sidecars.${sidecar}`, profile.consensus[sidecar], yamlRoot);
            }
        }
        return yamlRoot;
    }
    resourcesForHaProxyPod(profile, yamlRoot) {
        if (!profile) {
            throw new MissingArgumentError('profile is required');
        }
        if (!profile.haproxy) {
            return;
        } // use chart defaults
        return this._setChartItems('defaults.haproxy', profile.haproxy, yamlRoot);
    }
    resourcesForEnvoyProxyPod(profile, yamlRoot) {
        if (!profile) {
            throw new MissingArgumentError('profile is required');
        }
        if (!profile.envoyProxy) {
            return;
        } // use chart defaults
        return this._setChartItems('defaults.envoyProxy', profile.envoyProxy, yamlRoot);
    }
    resourcesForHederaExplorerPod(profile, yamlRoot) {
        if (!profile) {
            throw new MissingArgumentError('profile is required');
        }
        if (!profile.explorer) {
            return;
        }
        return this._setChartItems('', profile.explorer, yamlRoot);
    }
    resourcesForMinioTenantPod(profile, yamlRoot) {
        if (!profile) {
            throw new MissingArgumentError('profile is required');
        }
        // @ts-ignore
        if (!profile.minio || !profile.minio.tenant) {
            return {};
        } // use chart defaults
        for (const poolIndex in profile.minio.tenant.pools) {
            const pool = profile.minio.tenant.pools[poolIndex];
            for (const property in pool) {
                if (property !== 'resources') {
                    this._setValue(`minio-server.tenant.pools.${poolIndex}.${property}`, pool[property], yamlRoot);
                }
            }
            this._setChartItems(`minio-server.tenant.pools.${poolIndex}`, pool, yamlRoot);
        }
        return yamlRoot;
    }
    /**
     * Prepare a values file for Solo Helm chart
     * @param profileName - resource profile name
     * @param consensusNodes - the list of consensus nodes
     * @param domainNamesMapping
     * @param deploymentName
     * @param applicationPropertiesPath
     * @returns mapping of cluster-ref to the full path to the values file
     */
    async prepareValuesForSoloChart(profileName, consensusNodes, domainNamesMapping, deploymentName, applicationPropertiesPath) {
        if (!profileName) {
            throw new MissingArgumentError('profileName is required');
        }
        const profile = this.getProfile(profileName);
        const filesMapping = {};
        for (const [clusterReference] of this.remoteConfig.getClusterRefs()) {
            const nodeAliases = consensusNodes
                .filter(consensusNode => consensusNode.cluster === clusterReference)
                .map(consensusNode => consensusNode.name);
            // generate the YAML
            const yamlRoot = {};
            await this.resourcesForConsensusPod(profile, consensusNodes, nodeAliases, yamlRoot, domainNamesMapping, deploymentName, applicationPropertiesPath);
            this.resourcesForHaProxyPod(profile, yamlRoot);
            this.resourcesForEnvoyProxyPod(profile, yamlRoot);
            this.resourcesForMinioTenantPod(profile, yamlRoot);
            const cachedValuesFile = PathEx.join(this.cacheDir, `solo-${profileName}-${clusterReference}.yaml`);
            filesMapping[clusterReference] = await this.writeToYaml(cachedValuesFile, yamlRoot);
        }
        return filesMapping;
    }
    async bumpHederaConfigVersion(applicationPropertiesPath) {
        const lines = (await readFile(applicationPropertiesPath, 'utf-8')).split('\n');
        for (const line of lines) {
            if (line.startsWith('hedera.config.version=')) {
                const version = Number.parseInt(line.split('=')[1]) + 1;
                lines[lines.indexOf(line)] = `hedera.config.version=${version}`;
                break;
            }
        }
        await writeFile(applicationPropertiesPath, lines.join('\n'));
    }
    async updateApplicationPropertiesForBlockNode(applicationPropertiesPath) {
        const hasDeployedBlockNodes = Object.keys(this.remoteConfig.configuration.components.state.blockNodes).length > 0;
        if (!hasDeployedBlockNodes) {
            return;
        }
        const lines = (await readFile(applicationPropertiesPath, 'utf-8')).split('\n');
        const streamMode = 'BOTH';
        const writerMode = 'FILE_AND_GRPC';
        let streamModeUpdated = false;
        let writerModeUpdated = false;
        for (const line of lines) {
            if (line.startsWith('blockStream.streamMode=')) {
                lines[lines.indexOf(line)] = `blockStream.streamMode=${streamMode}`;
                streamModeUpdated = true;
                continue;
            }
            if (line.startsWith('blockStream.writerMode=')) {
                lines[lines.indexOf(line)] = `blockStream.writerMode=${writerMode}`;
                writerModeUpdated = true;
            }
        }
        if (!streamModeUpdated) {
            lines.push(`blockStream.streamMode=${streamMode}`);
        }
        if (!writerModeUpdated) {
            lines.push(`blockStream.writerMode=${writerMode}`);
        }
        await writeFile(applicationPropertiesPath, lines.join('\n') + '\n');
    }
    async updateApplicationPropertiesWithRealmAndShard(applicationPropertiesPath, realm, shard) {
        const lines = (await readFile(applicationPropertiesPath, 'utf-8')).split('\n');
        let realmUpdated = false;
        let shardUpdated = false;
        for (const line of lines) {
            if (line.startsWith('hedera.realm=')) {
                lines[lines.indexOf(line)] = `hedera.realm=${realm}`;
                realmUpdated = true;
                continue;
            }
            if (line.startsWith('hedera.shard=')) {
                lines[lines.indexOf(line)] = `hedera.shard=${shard}`;
                shardUpdated = true;
            }
        }
        if (!realmUpdated) {
            lines.push(`hedera.realm=${realm}`);
        }
        if (!shardUpdated) {
            lines.push(`hedera.shard=${shard}`);
        }
        await writeFile(applicationPropertiesPath, lines.join('\n') + '\n');
    }
    async prepareValuesForNodeTransaction(configTxtPath, applicationPropertiesPath) {
        const yamlRoot = {};
        this._setFileContentsAsValue('hedera.configMaps.configTxt', configTxtPath, yamlRoot);
        await this.bumpHederaConfigVersion(applicationPropertiesPath);
        this._setFileContentsAsValue('hedera.configMaps.applicationProperties', applicationPropertiesPath, yamlRoot);
        const cachedValuesFile = PathEx.join(this.cacheDir, 'solo-node-transaction.yaml');
        return this.writeToYaml(cachedValuesFile, yamlRoot);
    }
    /**
     * Prepare a values file for rpc-relay Helm chart
     * @param profileName - resource profile name
     * @returns return the full path to the values file
     */
    async prepareValuesForRpcRelayChart(profileName) {
        if (!profileName) {
            throw new MissingArgumentError('profileName is required');
        }
        const profile = this.getProfile(profileName);
        if (!profile.rpcRelay) {
            return '';
        } // use chart defaults
        // generate the YAML
        const yamlRoot = {};
        this._setChartItems('', profile.rpcRelay, yamlRoot);
        const cachedValuesFile = PathEx.join(this.cacheDir, `rpcRelay-${profileName}.yaml`);
        return this.writeToYaml(cachedValuesFile, yamlRoot);
    }
    async prepareValuesHederaExplorerChart(profileName) {
        if (!profileName) {
            throw new MissingArgumentError('profileName is required');
        }
        const profile = this.getProfile(profileName);
        // generate the YAML
        const yamlRoot = {};
        this.resourcesForHederaExplorerPod(profile, yamlRoot);
        const cachedValuesFile = PathEx.join(this.cacheDir, `explorer-${profileName}.yaml`);
        return this.writeToYaml(cachedValuesFile, yamlRoot);
    }
    /**
     * Writes the YAML to file.
     *
     * @param cachedValuesFile - the target file to write the YAML root to.
     * @param yamlRoot - object to turn into YAML and write to file.
     */
    async writeToYaml(cachedValuesFile, yamlRoot) {
        return await new Promise((resolve, reject) => {
            fs.writeFile(cachedValuesFile, yaml.stringify(yamlRoot), error => {
                if (error) {
                    reject(error);
                }
                resolve(cachedValuesFile);
            });
        });
    }
    /**
     * Prepare a values file for mirror-node Helm chart
     * @param profileName - resource profile name
     * @returns the full path to the values file
     */
    async prepareValuesForMirrorNodeChart(profileName) {
        if (!profileName) {
            throw new MissingArgumentError('profileName is required');
        }
        const profile = this.getProfile(profileName);
        if (!profile.mirror) {
            return '';
        } // use chart defaults
        // generate the YAML
        const yamlRoot = {};
        if (profile.mirror.postgresql) {
            if (profile.mirror.postgresql.persistence) {
                this._setValue('postgresql.persistence.size', profile.mirror.postgresql.persistence.size, yamlRoot);
            }
            this._setChartItems('postgresql.postgresql', profile.mirror.postgresql.postgresql, yamlRoot);
        }
        this._setChartItems('importer', profile.mirror.importer, yamlRoot);
        this._setChartItems('rest', profile.mirror.rest, yamlRoot);
        this._setChartItems('web3', profile.mirror.web3, yamlRoot);
        this._setChartItems('grpc', profile.mirror.grpc, yamlRoot);
        this._setChartItems('monitor', profile.mirror.monitor, yamlRoot);
        const cachedValuesFile = PathEx.join(this.cacheDir, `mirror-${profileName}.yaml`);
        return this.writeToYaml(cachedValuesFile, yamlRoot);
    }
    /**
     * Writes the contents of a file as a value for the given nested item path in the YAML object
     * @param itemPath - nested item path in the YAML object to store the file contents
     * @param valueFilePath - path to the file whose contents will be stored in the YAML object
     * @param yamlRoot - root of the YAML object
     */
    _setFileContentsAsValue(itemPath, valueFilePath, yamlRoot) {
        const fileContents = fs.readFileSync(valueFilePath, 'utf8');
        this._setValue(itemPath, fileContents, yamlRoot);
    }
    /**
     * Prepares config.txt file for the node
     * @param nodeAccountMap - the map of node aliases to account IDs
     * @param consensusNodes - the list of consensus nodes
     * @param destPath - path to the destination directory to write the config.txt file
     * @param releaseTagOverride - release tag override
     * @param domainNamesMapping
     * @param [appName] - the app name (default: HederaNode.jar)
     * @param [chainId] - chain ID (298 for local network)
     * @param [loadBalancerEnabled] - whether the load balancer is enabled (flag is not set by default)
     * @returns the config.txt file path
     */
    async prepareConfigTxt(nodeAccountMap, consensusNodes, destinationPath, releaseTagOverride, domainNamesMapping, appName = constants.HEDERA_APP_NAME, chainId = constants.HEDERA_CHAIN_ID, loadBalancerEnabled = false) {
        let releaseTag = releaseTagOverride;
        if (!nodeAccountMap || nodeAccountMap.size === 0) {
            throw new MissingArgumentError('nodeAccountMap the map of node IDs to account IDs is required');
        }
        if (!releaseTag) {
            releaseTag = versions.HEDERA_PLATFORM_VERSION;
        }
        if (!fs.existsSync(destinationPath)) {
            throw new IllegalArgumentError(`config destPath does not exist: ${destinationPath}`, destinationPath);
        }
        const configFilePath = PathEx.join(destinationPath, 'config.txt');
        if (fs.existsSync(configFilePath)) {
            fs.unlinkSync(configFilePath);
        }
        // init variables
        const internalPort = +constants.HEDERA_NODE_INTERNAL_GOSSIP_PORT;
        const externalPort = +constants.HEDERA_NODE_EXTERNAL_GOSSIP_PORT;
        const nodeStakeAmount = constants.HEDERA_NODE_DEFAULT_STAKE_AMOUNT;
        // @ts-expect-error - TS2353: Object literal may only specify known properties, and includePrerelease does not exist in type Options
        const releaseVersion = semver.parse(releaseTag, { includePrerelease: true });
        try {
            const configLines = [];
            configLines.push(`swirld, ${chainId}`, `app, ${appName}`);
            let nodeSeq = 0;
            for (const consensusNode of consensusNodes) {
                const internalIP = helpers.getInternalAddress(releaseVersion, NamespaceName.of(consensusNode.namespace), consensusNode.name);
                const domainName = domainNamesMapping?.[consensusNode.name];
                const externalIP = domainName
                    ? domainName
                    : await helpers.getExternalAddress(consensusNode, this.k8Factory.getK8(consensusNode.context), loadBalancerEnabled);
                const account = nodeAccountMap.get(consensusNode.name);
                configLines.push(`address, ${nodeSeq}, ${nodeSeq}, ${consensusNode.name}, ${nodeStakeAmount}, ${internalIP}, ${internalPort}, ${externalIP}, ${externalPort}, ${account}`);
                nodeSeq += 1;
            }
            // TODO: remove once we no longer need less than v0.56
            if (releaseVersion.minor >= 41 && releaseVersion.minor < 56) {
                configLines.push(`nextNodeId, ${nodeSeq}`);
            }
            fs.writeFileSync(configFilePath, configLines.join('\n'));
            return configFilePath;
        }
        catch (error) {
            throw new SoloError(`failed to generate config.txt, ${error instanceof Error ? error.message : 'unknown error'}`, error);
        }
    }
};
ProfileManager = __decorate([
    injectable(),
    __param(0, inject(InjectTokens.SoloLogger)),
    __param(1, inject(InjectTokens.ConfigManager)),
    __param(2, inject(InjectTokens.CacheDir)),
    __param(3, inject(InjectTokens.K8Factory)),
    __param(4, inject(InjectTokens.RemoteConfigRuntimeState)),
    __param(5, inject(InjectTokens.AccountManager)),
    __param(6, inject(InjectTokens.LocalConfigRuntimeState)),
    __metadata("design:paramtypes", [Object, Function, String, Object, Object, AccountManager,
        LocalConfigRuntimeState])
], ProfileManager);
export { ProfileManager };
//# sourceMappingURL=profile-manager.js.map