const requiredVersion = require('../package.json').engines.node
const {semver, error} = require('@vue/cli-shared-utils')

if (!semver.satisfies(process.version, requiredVersion, {includePrerelease: true})) {
    error(
        `You are using Node ${process.version}, but vue-cli-service ` +
        `requires Node ${requiredVersion}.\nPlease upgrade your Node version.`
    )
    process.exit(1)
}

const Service = require('../lib/Service')
const service = new Service(process.env.VUE_CLI_CONTEXT || process.cwd())

const rawArgv = process.argv.slice(2)

const args = require('minimist')(rawArgv, {
    boolean: [
        // build
        'modern',
        'report',
        'report-json',
        'inline-vue',
        'watch',
        // serve
        'open',
        'copy',
        'https',
        // inspect
        'verbose'
    ]
})

const command = args._[0]

service.run(command, args, rawArgv).catch(err => {
    error(err)
    process.exit(1)
})

class Service {
    constructor(context, {plugins, pkg, inlineOptions, useBuiltIn} = {}) {
        // 将当前类储存到process.VUE_CLI_SERVICE中
        process.VUE_CLI_SERVICE = this
        // 是否初始化完毕
        this.initialized = false
        // 上下文路径，一般为当前路径
        this.context = context
        // 内联配置options选项
        this.inlineOptions = inlineOptions
        // chainWebpack配置项
        this.webpackChainFns = []
        // configureWebpack配置项
        this.webpackRawConfigFns = []
        // webpack devServer配置项
        this.devServerConfigFns = []
        // 指令合集
        this.commands = {}
        // package.json的路径 一般为当前路径
        this.pkgContext = context
        // 解析package.json内的配置项
        this.pkg = this.resolvePkg(pkg)
        // package.json内配置的插件和默认提供的插件等插件的合并结果
        this.plugins = this.resolvePlugins(plugins, useBuiltIn)
        // 需要跳过初始化装载的plugins
        this.pluginsToSkip = new Set()
        // 构建模式合集
        // 将plugins内提供了defaultModes的插件添加到构建模式合集
        // 默认 { serve: development, build: production, inspect: development }
        this.modes = this.plugins.reduce((modes, {apply: {defaultModes}}) => {
            return Object.assign(modes, defaultModes)
        }, {})
    }

    // ...
}

const {resolvePkg} = require('@vue/cli-shared-utils')

class Service {
    // ...
    resolvePkg(inlinePkg, context = this.context) {
        if (inlinePkg) {
            return inlinePkg
        }

        const pkg = resolvePkg(context)

        if (pkg.vuePlugins && pkg.vuePlugins.resolveFrom) {
            this.pkgContext = path.resolve(context, pkg.vuePlugins.resolveFrom)
            return this.resolvePkg(null, this.pkgContext)
        }
        return pkg
    }

    // ...
}

const fs = require('fs')
const path = require('path')
const readPkg = require('read-pkg')

// 使用read-pkg.js读取package.json内的配置
exports.resolvePkg = function (context) {
    // 使用existsSync检查是否存在package.json文件
    if (fs.existsSync(path.join(context, 'package.json'))) {
        return readPkg.sync({cwd: context})
    }
    return {}
}

class Service {
    // ...
    resolvePlugins(inlinePlugins, useBuiltIn) {
        const idToPlugin = id => ({
            id: id.replace(/^.\//, 'built-in:'),
            apply: require(id)
        })

        let plugins

        // 默认配置的plugin
        const builtInPlugins = [
            './commands/serve',
            './commands/build',
            './commands/inspect',
            './commands/help',
            // config plugins are order sensitive
            './config/base',
            './config/css',
            './config/prod',
            './config/app'
        ].map(idToPlugin)

        if (inlinePlugins) {
            plugins = useBuiltIn !== false
                ? builtInPlugins.concat(inlinePlugins)
                : inlinePlugins
        } else {
            const projectPlugins = Object.keys(this.pkg.devDependencies || {})
                .concat(Object.keys(this.pkg.dependencies || {}))
                .filter(isPlugin)
                .map(id => {
                    if (
                        this.pkg.optionalDependencies &&
                        id in this.pkg.optionalDependencies
                    ) {
                        let apply = () => {
                        }
                        try {
                            apply = require(id)
                        } catch (e) {
                            warn(`Optional dependency ${id} is not installed.`)
                        }

                        return {id, apply}
                    } else {
                        return idToPlugin(id)
                    }
                })

            plugins = builtInPlugins.concat(projectPlugins)
        }

        if (this.pkg.vuePlugins && this.pkg.vuePlugins.service) {
            const files = this.pkg.vuePlugins.service
            // service必须是一个数组形式
            if (!Array.isArray(files)) {
                throw new Error(`Invalid type for option 'vuePlugins.service', expected 'array' but got ${typeof files}.`)
            }
            plugins = plugins.concat(files.map(file => ({
                id: `local:${file}`,
                apply: loadModule(`./${file}`, this.pkgContext)
            })))
        }

        return plugins
    }

    // ...
}

const idToPlugin = id => ({
    id: id.replace(/^.\//, 'built-in:'),
    apply: require(id)
})

const builtInPlugins = [
    './commands/serve',
    './commands/build',
    './commands/inspect',
    './commands/help',
    // config plugins are order sensitive
    './config/base',
    './config/css',
    './config/prod',
    './config/app'
].map(idToPlugin)

if (inlinePlugins) {
    plugins = useBuiltIn !== false
        ? builtInPlugins.concat(inlinePlugins)
        : inlinePlugins
} else {
    const projectPlugins = Object.keys(this.pkg.devDependencies || {})
        .concat(Object.keys(this.pkg.dependencies || {}))
        .filter(isPlugin)
        .map(id => {
            if (
                this.pkg.optionalDependencies &&
                id in this.pkg.optionalDependencies
            ) {
                let apply = () => {
                }
                try {
                    apply = require(id)
                } catch (e) {
                    warn(`Optional dependency ${id} is not installed.`)
                }

                return {id, apply}
            } else {
                return idToPlugin(id)
            }
        })

    plugins = builtInPlugins.concat(projectPlugins)
}

if (this.pkg.vuePlugins && this.pkg.vuePlugins.service) {
    const files = this.pkg.vuePlugins.service
    // service必须是一个数组形式
    if (!Array.isArray(files)) {
        throw new Error(`Invalid type for option 'vuePlugins.service', expected 'array' but got ${typeof files}.`)
    }
    plugins = plugins.concat(files.map(file => ({
        id: `local:${file}`,
        apply: loadModule(`./${file}`, this.pkgContext)
    })))
}

class Service {
    // ...
    async run(name, args = {}, rawArgv = []) {
        const mode = args.mode || (name === 'build' && args.watch ? 'development' : this.modes[name])

        this.setPluginsToSkip(args)

        this.init(mode)

        args._ = args._ || []

        // 从指令集合内读取指令
        let command = this.commands[name]
        if (!command && name) {
            error(`command "${name}" does not exist.`)
            process.exit(1)
        }
        // 若未输入任何指令，即vue-cli-service 或 vue-cli-service help则调用help指令
        if (!command || args.help || args.h) {
            command = this.commands.help
        } else {
            // 读取完毕后移除该指令
            args._.shift() // remove command itself
            rawArgv.shift()
        }
        // 执行指令
        const {fn} = command
        return fn(args, rawArgv)
    }

    // ...
}

const mode = args.mode || (name === 'build' && args.watch ? 'development' : this.modes[name])

class Service {
    // ...
    init(mode = process.env.VUE_CLI_MODE) {
        // 判断是否已完成初始化
        if (this.initialized) {
            return
        }
        this.initialized = true
        this.mode = mode

        // 读取.env.[mode]文件
        if (mode) {
            this.loadEnv(mode)
        }
        // 读取.env文件
        this.loadEnv()

        // 读取用户配置的vue.config.js文件
        const userOptions = this.loadUserOptions()
        // 将默认配置合并到用户配置中，默认配置内的选项将不会覆盖用户配置的选项
        // 具体参考defaultsDeep函数的实现
        this.projectOptions = defaultsDeep(userOptions, defaults())

        debug('vue:project-config')(this.projectOptions)

        // 调用所有plugin
        this.plugins.forEach(({id, apply}) => {
            // 跳过不需要在初始化时调用的插件
            if (this.pluginsToSkip.has(id)) return
            apply(new PluginAPI(id, this), this.projectOptions)
        })

        // 合并vue.config.js内的chainWebpack和configureWebpack属性
        if (this.projectOptions.chainWebpack) {
            this.webpackChainFns.push(this.projectOptions.chainWebpack)
        }
        if (this.projectOptions.configureWebpack) {
            this.webpackRawConfigFns.push(this.projectOptions.configureWebpack)
        }
    }

    // ...
}

class Service {
    // ...
    loadEnv(mode) {
        const logger = debug('vue:env')
        const basePath = path.resolve(this.context, `.env${mode ? `.${mode}` : ``}`)
        const localPath = `${basePath}.local`

        const load = envPath => {
            try {
                const env = dotenv.config({path: envPath, debug: process.env.DEBUG})
                dotenvExpand(env)
                logger(envPath, env)
            } catch (err) {
                // only ignore error if file is not found
                if (err.toString().indexOf('ENOENT') < 0) {
                    error(err)
                }
            }
        }

        load(localPath)
        load(basePath)

        // by default, NODE_ENV and BABEL_ENV are set to "development" unless mode
        // is production or test. However the value in .env files will take higher
        // priority.
        if (mode) {
            // always set NODE_ENV during tests
            // as that is necessary for tests to not be affected by each other
            const shouldForceDefaultEnv = (
                process.env.VUE_CLI_TEST &&
                !process.env.VUE_CLI_TEST_TESTING_ENV
            )
            // 若为production/test下则直接使用该mode值，否则一律使用development
            const defaultNodeEnv = (mode === 'production' || mode === 'test')
                ? mode
                : 'development'
            // 若配置文件内未定义NODE_ENV则设置默认值
            if (shouldForceDefaultEnv || process.env.NODE_ENV == null) {
                process.env.NODE_ENV = defaultNodeEnv
            }
            // 若配置文件内未定义BABEL_ENV则设置默认值
            if (shouldForceDefaultEnv || process.env.BABEL_ENV == null) {
                process.env.BABEL_ENV = defaultNodeEnv
            }
        }
    }

    // ...
}

const basePath = path.resolve(this.context, `.env${mode ? `.${mode}` : ``}`)
const localPath = `${basePath}.local`

 if (mode) {
    // always set NODE_ENV during tests
    // as that is necessary for tests to not be affected by each other
    const shouldForceDefaultEnv = (
        process.env.VUE_CLI_TEST &&
        !process.env.VUE_CLI_TEST_TESTING_ENV
    )
    // 若为production/test下则直接使用该mode值，否则一律使用development
    const defaultNodeEnv = (mode === 'production' || mode === 'test')
        ? mode
        : 'development'
    // 若配置文件内未定义NODE_ENV则设置默认值
    if (shouldForceDefaultEnv || process.env.NODE_ENV == null) {
        process.env.NODE_ENV = defaultNodeEnv
    }
    // 若配置文件内未定义BABEL_ENV则设置默认值
    if (shouldForceDefaultEnv || process.env.BABEL_ENV == null) {
        process.env.BABEL_ENV = defaultNodeEnv
    }
}

class Service {
    // ...
    loadUserOptions() {
        // vue.config.c?js
        let fileConfig, pkgConfig, resolved, resolvedFrom
        const esm = this.pkg.type && this.pkg.type === 'module'

        const possibleConfigPaths = [
            process.env.VUE_CLI_SERVICE_CONFIG_PATH,
            './vue.config.js',
            './vue.config.cjs'
        ]

        let fileConfigPath
        for (const p of possibleConfigPaths) {
            const resolvedPath = p && path.resolve(this.context, p)
            if (resolvedPath && fs.existsSync(resolvedPath)) {
                fileConfigPath = resolvedPath
                break
            }
        }

        if (fileConfigPath) {
            if (esm && fileConfigPath === './vue.config.js') {
                throw new Error(`Please rename ${chalk.bold('vue.config.js')} to ${chalk.bold('vue.config.cjs')} when ECMAScript modules is enabled`)
            }

            try {
                fileConfig = loadModule(fileConfigPath, this.context)

                if (typeof fileConfig === 'function') {
                    fileConfig = fileConfig()
                }

                if (!fileConfig || typeof fileConfig !== 'object') {
                    // TODO: show throw an Error here, to be fixed in v5
                    error(
                        `Error loading ${chalk.bold(fileConfigPath)}: should export an object or a function that returns object.`
                    )
                    fileConfig = null
                }
            } catch (e) {
                error(`Error loading ${chalk.bold(fileConfigPath)}:`)
                throw e
            }
        }

        // package.vue
        pkgConfig = this.pkg.vue
        if (pkgConfig && typeof pkgConfig !== 'object') {
            error(
                `Error loading vue-cli config in ${chalk.bold(`package.json`)}: ` +
                `the "vue" field should be an object.`
            )
            pkgConfig = null
        }

        if (fileConfig) {
            if (pkgConfig) {
                warn(
                    `"vue" field in package.json ignored ` +
                    `due to presence of ${chalk.bold('vue.config.js')}.`
                )
                warn(
                    `You should migrate it into ${chalk.bold('vue.config.js')} ` +
                    `and remove it from package.json.`
                )
            }
            resolved = fileConfig
            resolvedFrom = 'vue.config.js'
        } else if (pkgConfig) {
            resolved = pkgConfig
            resolvedFrom = '"vue" field in package.json'
        } else {
            resolved = this.inlineOptions || {}
            resolvedFrom = 'inline options'
        }

        if (resolved.css && typeof resolved.css.modules !== 'undefined') {
            if (typeof resolved.css.requireModuleExtension !== 'undefined') {
                warn(
                    `You have set both "css.modules" and "css.requireModuleExtension" in ${chalk.bold('vue.config.js')}, ` +
                    `"css.modules" will be ignored in favor of "css.requireModuleExtension".`
                )
            } else {
                warn(
                    `"css.modules" option in ${chalk.bold('vue.config.js')} ` +
                    `is deprecated now, please use "css.requireModuleExtension" instead.`
                )
                resolved.css.requireModuleExtension = !resolved.css.modules
            }
        }

        // normalize some options
        ensureSlash(resolved, 'publicPath')
        if (typeof resolved.publicPath === 'string') {
            resolved.publicPath = resolved.publicPath.replace(/^\.\//, '')
        }
        removeSlash(resolved, 'outputDir')

        // validate options
        validate(resolved, msg => {
            error(
                `Invalid options in ${chalk.bold(resolvedFrom)}: ${msg}`
            )
        })

        return resolved
    }

    // ...
}

const esm = this.pkg.type && this.pkg.type === 'module'

 const possibleConfigPaths = [
    process.env.VUE_CLI_SERVICE_CONFIG_PATH,
    './vue.config.js',
    './vue.config.cjs'
]

let fileConfigPath
for (const p of possibleConfigPaths) {
    const resolvedPath = p && path.resolve(this.context, p)
    if (resolvedPath && fs.existsSync(resolvedPath)) {
        fileConfigPath = resolvedPath
        break
    }
}

if (esm && fileConfigPath === './vue.config.js') {
    throw new Error(`Please rename ${chalk.bold('vue.config.js')} to ${chalk.bold('vue.config.cjs')} when ECMAScript modules is enabled`)
}

try {
    fileConfig = loadModule(fileConfigPath, this.context)

    if (typeof fileConfig === 'function') {
        fileConfig = fileConfig()
    }

    if (!fileConfig || typeof fileConfig !== 'object') {
        // TODO: show throw an Error here, to be fixed in v5
        error(
            `Error loading ${chalk.bold(fileConfigPath)}: should export an object or a function that returns object.`
        )
        fileConfig = null
    }
} catch (e) {
    error(`Error loading ${chalk.bold(fileConfigPath)}:`)
    throw e
}

// package.vue
pkgConfig = this.pkg.vue
if (pkgConfig && typeof pkgConfig !== 'object') {
    error(
        `Error loading vue-cli config in ${chalk.bold(`package.json`)}: ` +
        `the "vue" field should be an object.`
    )
    pkgConfig = null
}

if (fileConfig) {
    if (pkgConfig) {
        warn(
            `"vue" field in package.json ignored ` +
            `due to presence of ${chalk.bold('vue.config.js')}.`
        )
        warn(
            `You should migrate it into ${chalk.bold('vue.config.js')} ` +
            `and remove it from package.json.`
        )
    }
    resolved = fileConfig
    resolvedFrom = 'vue.config.js'
} else if (pkgConfig) {
    resolved = pkgConfig
    resolvedFrom = '"vue" field in package.json'
} else {
    resolved = this.inlineOptions || {}
    resolvedFrom = 'inline options'
}

 if (resolved.css && typeof resolved.css.modules !== 'undefined') {
    if (typeof resolved.css.requireModuleExtension !== 'undefined') {
        warn(
            `You have set both "css.modules" and "css.requireModuleExtension" in ${chalk.bold('vue.config.js')}, ` +
            `"css.modules" will be ignored in favor of "css.requireModuleExtension".`
        )
    } else {
        warn(
            `"css.modules" option in ${chalk.bold('vue.config.js')} ` +
            `is deprecated now, please use "css.requireModuleExtension" instead.`
        )
        resolved.css.requireModuleExtension = !resolved.css.modules
    }
}

// 为传递的publicPath的路径结尾拼接'/'，如/root => /root/
ensureSlash(resolved, 'publicPath')
// 移除publicPath中的'./'字符
if (typeof resolved.publicPath === 'string') {
    resolved.publicPath = resolved.publicPath.replace(/\.\//, '')
}
// 移除尾部的'/'，如/root/ => /root
removeSlash(resolved, 'outputDir')

class Service {
    // ...
    resolveChainableWebpackConfig() {
        const chainableConfig = new Config()
        // apply chains
        this.webpackChainFns.forEach(fn => fn(chainableConfig))
        return chainableConfig
    }

    resolveWebpackConfig(chainableConfig = this.resolveChainableWebpackConfig()) {
        if (!this.initialized) {
            throw new Error('Service must call init() before calling resolveWebpackConfig().')
        }
        // get raw config
        let config = chainableConfig.toConfig()
        const original = config
        // apply raw config fns
        this.webpackRawConfigFns.forEach(fn => {
            if (typeof fn === 'function') {
                // function with optional return value
                const res = fn(config)
                if (res) config = merge(config, res)
            } else if (fn) {
                // merge literal values
                config = merge(config, fn)
            }
        })

        // #2206 If config is merged by merge-webpack, it discards the __ruleNames
        // information injected by webpack-chain. Restore the info so that
        // vue inspect works properly.
        if (config !== original) {
            cloneRuleNames(
                config.module && config.module.rules,
                original.module && original.module.rules
            )
        }

        // check if the user has manually mutated output.publicPath
        const target = process.env.VUE_CLI_BUILD_TARGET
        if (
            !process.env.VUE_CLI_TEST &&
            (target && target !== 'app') &&
            config.output.publicPath !== this.projectOptions.publicPath
        ) {
            throw new Error(
                `Do not modify webpack output.publicPath directly. ` +
                `Use the "publicPath" option in vue.config.js instead.`
            )
        }

        if (
            !process.env.VUE_CLI_ENTRY_FILES &&
            typeof config.entry !== 'function'
        ) {
            let entryFiles
            if (typeof config.entry === 'string') {
                entryFiles = [config.entry]
            } else if (Array.isArray(config.entry)) {
                entryFiles = config.entry
            } else {
                entryFiles = Object.values(config.entry || []).reduce((allEntries, curr) => {
                    return allEntries.concat(curr)
                }, [])
            }

            entryFiles = entryFiles.map(file => path.resolve(this.context, file))
            process.env.VUE_CLI_ENTRY_FILES = JSON.stringify(entryFiles)
        }

        return config
    }

    // ...
}

resolveChainableWebpackConfig()
{
    const chainableConfig = new Config()
    // apply chains
    this.webpackChainFns.forEach(fn => fn(chainableConfig))
    return chainableConfig
}

if (!this.initialized) {
    throw new Error('Service must call init() before calling resolveWebpackConfig().')
}

let config = chainableConfig.toConfig()
const original = config

this.webpackRawConfigFns.forEach(fn => {
    if (typeof fn === 'function') {
        // function with optional return value
        const res = fn(config)
        if (res) config = merge(config, res)
    } else if (fn) {
        // merge literal values
        config = merge(config, fn)
    }
})

 const target = process.env.VUE_CLI_BUILD_TARGET
if (
    !process.env.VUE_CLI_TEST &&
    (target && target !== 'app') &&
    config.output.publicPath !== this.projectOptions.publicPath
) {
    throw new Error(
        `Do not modify webpack output.publicPath directly. ` +
        `Use the "publicPath" option in vue.config.js instead.`
    )
}

 if (
    !process.env.VUE_CLI_ENTRY_FILES &&
    typeof config.entry !== 'function'
) {
    let entryFiles
    if (typeof config.entry === 'string') {
        entryFiles = [config.entry]
    } else if (Array.isArray(config.entry)) {
        entryFiles = config.entry
    } else {
        entryFiles = Object.values(config.entry || []).reduce((allEntries, curr) => {
            return allEntries.concat(curr)
        }, [])
    }

    entryFiles = entryFiles.map(file => path.resolve(this.context, file))
    process.env.VUE_CLI_ENTRY_FILES = JSON.stringify(entryFiles)
}