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); }
};
/**
 * Copyright (C) 2024 Hedera Hashgraph, LLC
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
import os from 'os';
import { SoloError } from '../errors.js';
import { ShellRunner } from '../shell_runner.js';
import { HelmDependencyManager } from './helm_dependency_manager.js';
import { container, inject, injectable } from 'tsyringe-neo';
import * as constants from '../constants.js';
let DependencyManager = class DependencyManager extends ShellRunner {
    depManagerMap;
    constructor(helmDepManager) {
        super();
        if (helmDepManager) {
            this.depManagerMap = new Map().set(constants.HELM, helmDepManager);
        }
        else {
            this.depManagerMap = new Map().set(constants.HELM, container.resolve(HelmDependencyManager));
        }
    }
    /**
     * Check if the required dependency is installed or not
     * @param dep - is the name of the program
     * @param [shouldInstall] - Whether or not install the dependency if not installed
     */
    async checkDependency(dep, shouldInstall = true) {
        this.logger.debug(`Checking for dependency: ${dep}`);
        let status = false;
        const manager = this.depManagerMap.get(dep);
        if (manager) {
            // @ts-ignore
            status = await manager.checkVersion(shouldInstall);
        }
        if (!status) {
            throw new SoloError(`Dependency '${dep}' is not found`);
        }
        this.logger.debug(`Dependency '${dep}' is found`);
        return true;
    }
    taskCheckDependencies(deps) {
        return deps.map(dep => {
            return {
                title: `Check dependency: ${dep} [OS: ${os.platform()}, Release: ${os.release()}, Arch: ${os.arch()}]`,
                task: () => this.checkDependency(dep),
            };
        });
    }
};
DependencyManager = __decorate([
    injectable(),
    __param(0, inject(HelmDependencyManager)),
    __metadata("design:paramtypes", [HelmDependencyManager])
], DependencyManager);
export { DependencyManager };
//# sourceMappingURL=dependency_manager.js.map