// @ts-nocheck

import { main } from "../package.json"
import { join } from "path"
import * as electron from "electron"
import * as dotenv from "dotenv"
import * as ora from "ora"
import * as chalk from "chalk"
import * as minimist from "minimist"

import { exec, spawn, ChildProcess } from "child_process"
import { watch, rollup, OutputOptions } from "rollup"
import { waitOn } from "./utils"
import options from "./rollup.config"
// 注入环境变量
dotenv.config({ path: join(__dirname, "../.env") })
// 解析命令行参数
const argv = minimist(process.argv.slice(2))
// rollup配置
const opts = options(argv.env)
const TAG = "[build-main.ts]"
// 加载图
const spinner = ora(`${TAG} Electron build...`)
console.log(join(__dirname, "../node_modules/.bin/vite"))

function runVite() {
  return new Promise((resolve, reject) => {
    let viteProcess = spawn("node", [`D:/1XYX/pro/vite-electron/node_modules/vite/bin/vite.js`], {
      stdio: "pipe",
      env: Object.assign(process.env, { NODE_ENV: argv.env }),
    })
    if (viteProcess) {
      let isReady = false
      viteProcess.stdout.on("data", data => {
        // console.log(`${data}`)
        if (!isReady && data.indexOf("ready") != -1) {
          resolve(viteProcess)
        }
      })

      viteProcess.stderr.on("data", data => {
        console.error(`[vite err]: ${data}`)
        reject()
      })

      viteProcess.on("close", code => {
        console.log(`[vite close]: exited with code ${code}`)
        reject()
      })
    } else {
      reject()
    }
  })
}

function runElectron() {
  return new Promise((resolve, reject) => {
    let electronProcess = spawn(electron as unknown as string, [join(__dirname, `../${main}`)], {
      stdio: "pipe",
      env: Object.assign(process.env, { NODE_ENV: argv.env }),
    })
    if (electronProcess) {
      resolve(electronProcess)
    } else {
      reject()
    }
  })
}

;(async () => {
  let vitePorcess = await runVite()
  console.log('[vite]', chalk.green(`vite ready.`))

  const watcher = watch(opts)
  let child: ChildProcess | null
  let manualRestart = false
  watcher.on("change", filename => {
    const log = chalk.green(`change -- ${filename}`)
    console.log(TAG, log)
  })
  watcher.on("event",async ev => {
    if (ev.code === "END") {
      if (child && child.kill) {
        manualRestart = true
        child.kill()
        child = null
        setTimeout(() => {
          manualRestart = false
        }, 5000)
      }
      try {
        child = await runElectron()
        console.log('[electron]', chalk.green(`electron ready.`))
        child.on("close", () => {
          if (!manualRestart) {
            vitePorcess.kill()
            child.kill()
            process.exit()
          }
        })
      } catch (ev) {
        console.log(ev.error)
        vitePorcess.kill()
        child.kill()
        process.exit()
      }
    } else if (ev.code === "ERROR") {
      console.log(ev.error)
    }
  })
})()