import { get } from 'lodash';
import { match } from '@cirrusct/core-node';
import { MonoRepo, MonoRepoPackage, MrPackageConfig } from '@cirrusct/mr-core';
import { BuildSpecConfig, TypescriptTranspilerConfigOptions, BuildPathsConfig, MrBuild } from '@cirrusct/mr-build';
import { MrConfig, MrDeployConfig, MrDeploymentConfig, ResolvedDeploymentConfig, MrDeployOptions } from './types';
import { DeploymentConfigResolver } from './DeployConfigResolver';

export const getDeploymentConfigsMap = (monoRepo: MonoRepo<MrConfig>): { [name: string]: MrDeploymentConfig } => {
    const deployConfig = monoRepo.config.deploy;
    return deployConfig && deployConfig.deployments ? deployConfig.deployments : {};
};

export const findPackagenames = (mrPackage: MonoRepoPackage): string[] => {
    const mr = mrPackage.monoRepo as MonoRepo<MrConfig>;
    const deployConfig = mr.config.deploy;
    const found: string[] = [];
    if (deployConfig.deployments) {
        for (const name in deployConfig.deployments) {
            const config = deployConfig.deployments[name];
            let foundPkg: MonoRepoPackage = null;
            if (config.package) {
                // mrPackage is defined in deployment config.  Get the package using an acceptable form of it's name
                foundPkg = mr.findPackage(config.package);
            } else {
                // if mrPackage not defined, assuming key name matches a form of package name
                foundPkg = mr.findPackage(name);
            }
            if (foundPkg && foundPkg.name === mrPackage.name) {
                // add deployment to ret
                found.push(name);
            }
        }
    }
    return found;
};

export const getPackagesWithDeployments = async (
    monoRepo: MonoRepo<MrConfig>,
    filter: MonoRepoPackage[] = []
): Promise<MonoRepoPackage[]> => {
    const packages: { [name: string]: MonoRepoPackage } = {};
    filter = filter.length > 0 ? filter : monoRepo.localPackages;

    for (const pkg of filter) {
        const names = findPackagenames(pkg);
        if (names.length > 0) {
            packages[pkg.name] = pkg;
        }
    }

    return Object.keys(packages).map(pn => packages[pn]);
};

export const getDeploymentConfigs = (
    pattern: string,
    mr: MonoRepo<MrConfig>
): { [name: string]: MrDeploymentConfig } => {
    const deploymentConfigs = getDeploymentConfigsMap(mr);
    const names = match(Object.getOwnPropertyNames(deploymentConfigs), pattern);
    const configs: { [name: string]: MrDeploymentConfig } = {};
    for (const name of names) {
        configs[name] = deploymentConfigs[name];
    }
    return configs;
};

export const matchnames = (pattern: string, mr: MonoRepo<MrConfig>): string[] => {
    const deploymentConfigs = getDeploymentConfigsMap(mr);
    return match(Object.getOwnPropertyNames(deploymentConfigs), pattern);
};

export const getResolvedConfigs = async (
    pattern: string,
    options: MrDeployOptions = {},
    mr: MonoRepo<MrConfig>,
    buildSpec?: BuildSpecConfig
): Promise<ResolvedDeploymentConfig[]> => {
    debugger;
    const configs = getDeploymentConfigs(pattern, mr);
    const deployConfig = mr.config.deploy;

    let resolved: ResolvedDeploymentConfig[] = [];

    for (const deploymentConfigName in configs) {
        const deploymentConfig = configs[deploymentConfigName];
        const mrPackage = mr.findPackage(deploymentConfig.package);
        const buildConfig = await MrBuild.getPackageBuildConfig(mrPackage);

        // TODO: hack, centralize this
        buildSpec =
            buildSpec || get(buildConfig.specs, 'default', get(buildConfig.specs, Object.keys(buildConfig.specs)[0]));

        const resolver = new DeploymentConfigResolver(
            mrPackage,
            deployConfig,
            buildSpec,
            options,
            deploymentConfigName
        );

        resolved.push(...(await resolver.resolve()));
    }

    return resolved;
};