import "source-map-support/register"
import { TSRouteParser } from "./tsRouteParser"
import * as fs from "fs-extra"
import * as pathModule from "path"
import * as ts from "typescript"
import * as helper from "./helper"
import * as wrench from "wrench"
import * as commander from "commander"
import { Context } from "./context"
import { TSConfigParser } from "./tsConfigParser"
import { ComposerServer } from "../../composer/server/src/composer"
import * as colors from "colors"
import { TSAPIParser } from "./tsAPIParser"
import * as tsfmt from "typescript-formatter"
let program = commander
    .description("Core util to generate leaf-ts required resources")
    .usage("[path-to-R.d.ts] [options...]")
    .option("-g --global", "created R.ts don't export")
    .option("-l --leaf <leaf>", "relative link to leaf.d.ts")
    .option("-c --create", "create the R.d.ts")
    .option("--export", "create module file instead of a global file")
    .option("--create-api <file>", "create api from root-ts spec")
    .option("--create-root-ts-target <path>", "create generated root ts api by search for root-ts project route ")
    .option("--root-name <name>", "using custom root namespace instead of \"R\"")
    .option("--composer", "start composer server")
    .option("--composer-port <port>", "port for the composer")
    .option("--composer-style-path <path>", "If your style file isn't at /style/main.css, set it here. The path is relative to R.d.ts or `Root` value of R.d.ts")
    .option("--perf", "Show performance statistics")
    .parse(process.argv)
interface UIInfo {
    tagName: string
    name: string
}
interface VMInfo {
    name: string
    usage: string[]
}
let defaultTemplate = `type Template = "./template"
type Output = "./script/R"
type StyleOutput = "./style/R.less"
type Root = "./"
`
const defaultFileName = "R.conf.d.ts"
if (program["createApi"]) {
    let files = [program["createApi"]]
    let parser = new TSAPIParser()
    parser.parse(files)
    let result = parser.generate()

    tsfmt.processString("_.ts", result, {
        replace: false,
        verify: false,
        tsconfig: false,
        tslint: true,
        editorconfig: true,
        tsfmt: true,
        tsconfigFile: null,
        tslintFile: null,
        vscode: null,
        vscodeFile: null,
        tsfmtFile: null,
    }).then((result) => {
        let content = result.dest
        let code = content.replace(/\r\n/ig, "\n").replace(/\n\s*\n/ig, "\n").trim()
        console.log(code)
    })
} else if (program["createRootTsTarget"]) {
    let path = program["createRootTsTarget"]
    let parser = new TSRouteParser(path.split(","))
    process.exit(0)
} else {

    if (program["create"]) {
        fs.writeFileSync(defaultFileName, defaultTemplate)
        process.exit(0)
    }
    let configPath = program.args[0] || defaultFileName
    configPath = pathModule.resolve(process.cwd() + "/", configPath)

    if (!fs.existsSync(configPath)) {
        console.error(colors.red(`Can't find config ${defaultFileName} at ${configPath}`))
        program.help()
        process.exit(1)
    }
    let parser = new TSConfigParser(configPath)
    if (program["composer"]) {
        let server = new ComposerServer(parser);
        if (program["composerStylePath"]) {
            server.setStylePath(program["composerStylePath"])
        }
        server.start(program["composerPort"] || 3780)
    } else {
        let context = new Context(parser.getTemplatePath())
        if (program["rootName"]) {
            context.rootName = program["rootName"]
        }
        // compile mode
        let dateStart = Date.now()
        let files = wrench.readdirSyncRecursive(parser.getTemplatePath()).filter(item => fs.statSync(pathModule.join(parser.getTemplatePath(), item)).isFile())
        let supportedExtnames = [".html", ".widget"]
        let dateReadFile = Date.now()
        for (let file of files) {
            let ext = pathModule.extname(file)
            if (supportedExtnames.indexOf(ext) < 0) continue
            context.includeWidgetByRelativeFilePath(file)
        }
        let dateInclude = Date.now()
        let jsOutput = context.compileJavascript()
        let dateBuildJS = Date.now()
        let tsdOutput = context.compileDefinition({
            export: program["export"] && true || false
        })
        let dateBuildDTS = Date.now()
        if (program["leaf"]) {
            tsdOutput = `///<reference path="${program["leaf"]}"/>` + "\n" + tsdOutput
        }
        fs.writeFileSync(parser.getOutputJavascriptPath(), jsOutput)
        fs.writeFileSync(parser.getOutputDefinitionPath(), tsdOutput)
        let dateWriteAll = Date.now()
        let styleOutput = parser.getStyleOutputPath()
        if (styleOutput) {
            let content = context.compileStyle()
            if (content) {
                fs.writeFileSync(styleOutput, content)
            }
        }
        let dateLessAll = Date.now()
        if (program["perf"]) {
            let dates = [{ dateLessAll }, { dateWriteAll }, { dateBuildDTS }, { dateBuildJS }, { dateInclude }, { dateReadFile }, { dateStart }]
            dates.reverse()
            dates.forEach((item, index) => {
                if (index === 0) return
                let name = Object.keys(item)[0]
                let prev = dates[index - 1]
                let prevName = Object.keys(prev)[0]
                console.log(name, item[name] - prev[prevName], "ms")
            })
        }
    }
}