import * as path from 'path'
import { REGEX_VAR } from "@plastichub/core/constants"
import { sync as read } from '@plastichub/fs/read'
import { sync as exists } from '@plastichub/fs/exists'
import { isString } from '@plastichub/core/primitives'
import { resolve, substitute } from './variables'

interface EnvVariables {
    [key: string]: string
}

interface EnvConfig {
    includes: string[]
    variables: EnvVariables
}

export interface IProfile {
    includes: string[]
    variables: EnvVariables
    env: {
        [key: string]: EnvConfig
    }
}


const _resolve = (config) => {
    for (const key in config) {
        if (config[key] && typeof config[key] == 'string') {
            const resolved = substitute(false, config[key], config)
            config[key] = resolved
        }
    }
    return config;
}
// @todo: Implement the function `resolveConfig`
export const resolveConfig = (config) => {
    config = _resolve(config)
    config = _resolve(config)
    return config
}
export const parseProfile = (profilePath: string, profile: IProfile, options: { env: string } = { env: 'default' }, rel?: string) => {
    profilePath = path.resolve(resolve(profilePath, false, profile.variables))
    if (!exists(profilePath as string)) {
        return
    }
    const _profile = read(profilePath as string, 'json') as any || { includes: [], variables: {} } as IProfile

    _profile.includes = _profile.includes || []
    _profile.variables = _profile.variables || {}

    if (options.env && _profile.env && _profile.env[options.env] && _profile.env[options.env].includes) {
        profile.includes = [
            ...profile.includes,
            ..._profile.includes,
            ..._profile.env[options.env].includes
        ]
    } else {
        profile.includes = [
            ...profile.includes,
            ..._profile.includes
        ]
    }
    if (options.env && _profile.env && _profile.env[options.env] && _profile.env[options.env].variables) {
        profile.variables = {
            ...profile.variables,
            ..._profile.variables,
            ..._profile.env[options.env].variables
        }
    }
    for (const k in _profile.variables) {
        if (isString(_profile.variables[k])) {
            _profile.variables[k] = substitute(false, _profile.variables[k], profile.variables)
        }
    }

    profile.variables = { ...profile.variables, ..._profile.variables, ..._profile.env[options.env]?.variables || {} }
    for (const k in profile.variables) {
        if (isString(profile.variables[k])) {
            profile.variables[k] = substitute(false, profile.variables[k], profile.variables)
        }
    }
    profile.includes = Array.from(new Set(profile.includes))
    profile.includes = [
        ...profile.includes.map((i) => {
            if (!path.isAbsolute(i) && rel && !i.match(REGEX_VAR)) {
                return path.resolve(`${rel}/${i}`)
            }
            let ret = resolve(i, false, profile.variables)
            ret = path.resolve(substitute(false, ret, profile.variables))
            return ret
        })]

    profile.includes = profile.includes.filter((include) =>
        include !== null &&
        include !== '')
    profile.includes = Array.from(new Set(profile.includes))
    return profile
}