'use strict'

const fs = require('fs')
const http = require('http')
const path = require('path')
const { EventEmitter } = require('events')
const { spawn } = require('child_process')

const STATE_LABEL = {
  stopped: '已停止',
  starting: '启动中',
  running: '运行中',
  stopping: '停止中',
  crashed: '异常退出'
}

// 优雅关闭握手：POST server.shutdownPath，让服务端自己走 signal.NotifyContext
// 的关闭流程；请求失败或接口未实现时回退到进程信号。
const DEFAULT_SHUTDOWN_PATH = '/api/shutdown'
const SHUTDOWN_REQUEST_TIMEOUT_MS = 2000
// 服务端 srv.Shutdown 的超时是 10s，客户端必须留足余量再强杀
const DEFAULT_SHUTDOWN_TIMEOUT_MS = 12000
// 握手不可用时信号已能结束进程，不必再等满超时
const FALLBACK_FORCE_KILL_MS = 1500
// 连续健康这么久才认为崩溃计数可以清零
const HEALTHY_RESET_MS = 60000

// 服务端守护：拉起 scoreboard.exe、转发日志、健康探测、崩溃自动重启。
// 现场无人值守，所以「崩了自动拉起」比「暴露复杂控制」更重要。
class ServiceSupervisor extends EventEmitter {
  constructor({ values, exePath, log }) {
    super()
    this.values = values
    this.server = values.server
    this.exePath = exePath
    this.log = log

    this.child = null
    this.state = 'stopped'
    this.healthy = false
    this.pid = null
    this.restarts = 0
    this.startedAt = null
    this.lastError = null

    this.stopRequested = false
    this.healthySince = null
    this.healthTimer = null
    this.restartTimer = null
    this.forceKillTimer = null
  }

  get status() {
    const host = this.healthHost()
    return {
      state: this.state,
      stateLabel: STATE_LABEL[this.state] || this.state,
      healthy: this.healthy,
      pid: this.pid,
      restarts: this.restarts,
      startedAt: this.startedAt,
      lastError: this.lastError,
      exePath: this.exePath,
      url: `http://${host}:${this.server.port}`,
      adminUrl: `http://${host}:${this.server.port}/admin`
    }
  }

  // 服务端可能监听 0.0.0.0，本机探测要走回环地址
  healthHost() {
    const host = this.server.host || '127.0.0.1'
    return host === '0.0.0.0' || host === '::' ? '127.0.0.1' : host
  }

  emitStatus() {
    this.emit('status', this.status)
  }

  setState(state, patch = {}) {
    const changed = this.state !== state
    this.state = state
    Object.assign(this, patch)
    if (changed) {
      this.log.push('console', `服务状态：${STATE_LABEL[state] || state}${this.lastError ? `（${this.lastError}）` : ''}`)
    }
    this.emitStatus()
  }

  start() {
    if (this.child || this.state === 'starting' || this.state === 'running') return this.status
    this.stopRequested = false

    if (!this.exePath || !fs.existsSync(this.exePath)) {
      this.setState('crashed', {
        lastError: `未找到服务端程序：${this.exePath || this.server.exe}`
      })
      return this.status
    }

    const args = Array.isArray(this.server.args) ? this.server.args : []
    // 工作目录取 exe 所在目录：部署包里 config.yaml / data/ 都跟 exe 平级
    const cwd = path.dirname(this.exePath)

    this.lastError = null
    this.healthySince = null
    this.startedAt = new Date().toISOString()
    this.setState('starting')
    this.log.push('console', `启动服务端：${this.exePath} ${args.join(' ')}（cwd=${cwd}）`)

    let child
    try {
      child = spawn(this.exePath, args, {
        cwd,
        windowsHide: true,
        stdio: ['ignore', 'pipe', 'pipe']
      })
    } catch (err) {
      this.setState('crashed', { lastError: `启动失败：${err.message}` })
      this.scheduleRestart()
      return this.status
    }

    this.child = child
    this.pid = child.pid

    if (child.stdout) {
      child.stdout.setEncoding('utf8')
      child.stdout.on('data', (chunk) => this.log.append('server', chunk))
    }
    if (child.stderr) {
      child.stderr.setEncoding('utf8')
      child.stderr.on('data', (chunk) => this.log.append('server!', chunk))
    }

    child.on('error', (err) => {
      this.log.push('console', `服务端进程错误：${err.message}`)
      this.setState('crashed', { lastError: err.message })
    })

    child.on('exit', (code, signal) => this.handleExit(code, signal))

    this.setState('running')
    this.startHealthCheck()
    return this.status
  }

  handleExit(code, signal) {
    if (this.forceKillTimer) {
      clearTimeout(this.forceKillTimer)
      this.forceKillTimer = null
    }
    this.stopHealthCheck()
    this.child = null
    this.pid = null
    this.healthy = false
    this.healthySince = null

    const reason = signal ? `信号 ${signal}` : `退出码 ${code}`
    if (this.stopRequested) {
      this.log.push('console', `服务端已停止（${reason}）`)
      this.setState('stopped', { lastError: null })
      return
    }

    this.setState('crashed', { lastError: `服务端意外退出（${reason}）` })
    this.scheduleRestart()
  }

  scheduleRestart() {
    const max = Number(this.server.maxRestarts) || 0
    if (max > 0 && this.restarts >= max) {
      this.log.push('console', `已达到最大重启次数 ${max}，不再自动拉起`)
      return
    }
    const delay = (Number(this.server.restartDelayMs) || 3000) * Math.min(this.restarts + 1, 5)
    this.restarts += 1
    this.log.push('console', `${Math.round(delay / 1000)} 秒后自动重启服务端（第 ${this.restarts} 次）`)
    this.emitStatus()
    if (this.restartTimer) clearTimeout(this.restartTimer)
    this.restartTimer = setTimeout(() => {
      this.restartTimer = null
      if (!this.stopRequested) this.start()
    }, delay)
  }

  stop() {
    return new Promise((resolve) => {
      if (this.restartTimer) {
        clearTimeout(this.restartTimer)
        this.restartTimer = null
      }
      const child = this.child
      if (!child) {
        this.setState('stopped', { lastError: null })
        resolve()
        return
      }

      this.stopRequested = true
      this.setState('stopping')
      this.log.push('console', '正在停止服务端…')

      child.once('exit', () => resolve())

      const timeoutMs = Number(this.server.shutdownTimeoutMs) || DEFAULT_SHUTDOWN_TIMEOUT_MS
      // 先按最坏情况挂强杀兜底，握手成功后也不撤：服务端可能卡在关闭流程里
      this.armForceKill(timeoutMs)

      this.requestShutdown().then((accepted) => {
        if (this.child !== child) return
        if (accepted) {
          this.log.push('console', `服务端已接受关闭请求，最多等待 ${Math.round(timeoutMs / 1000)} 秒`)
          return
        }
        // 握手不可用：服务端还没实现该接口，或进程已无响应。
        // 退回进程信号；Windows 上 Node 的 kill() 等同强杀，所以这条路只是兜底，
        // 真正的优雅关闭依赖服务端补上 shutdownPath 接口。
        this.log.push('console', '关闭接口不可用，退回进程信号')
        this.armForceKill(FALLBACK_FORCE_KILL_MS)
        try {
          child.kill()
        } catch (err) {
          this.log.push('console', `发送停止信号失败：${err.message}`)
        }
      })
    })
  }

  // 优雅关闭握手：让服务端自己走 signal.NotifyContext → srv.Shutdown 的流程，
  // 10s 内落盘退出。接口按回环地址访问、不鉴权，只在本机有意义。
  // 依赖：服务端实现 POST <server.shutdownPath>（2xx 表示已受理）。
  requestShutdown() {
    return new Promise((resolve) => {
      const body = Buffer.from('{}')
      const request = http.request(
        {
          host: this.healthHost(),
          port: this.server.port,
          path: this.server.shutdownPath || DEFAULT_SHUTDOWN_PATH,
          method: 'POST',
          timeout: SHUTDOWN_REQUEST_TIMEOUT_MS,
          headers: {
            'Content-Type': 'application/json',
            'Content-Length': body.length,
            Connection: 'close'
          }
        },
        (response) => {
          response.resume()
          const accepted = response.statusCode >= 200 && response.statusCode < 300
          if (!accepted) this.log.push('console', `关闭接口返回 HTTP ${response.statusCode}`)
          resolve(accepted)
        }
      )
      request.on('timeout', () => request.destroy(new Error('请求超时')))
      request.on('error', (err) => {
        this.log.push('console', `关闭接口请求失败：${err.message}`)
        resolve(false)
      })
      request.end(body)
    })
  }

  armForceKill(ms) {
    if (this.forceKillTimer) clearTimeout(this.forceKillTimer)
    this.forceKillTimer = setTimeout(() => {
      this.forceKillTimer = null
      if (!this.child || !this.pid) return
      this.log.push('console', `服务端未在 ${Math.round(ms / 1000)} 秒内退出，强制结束`)
      try {
        this.child.kill('SIGKILL')
      } catch {
        // 进程可能已经没了
      }
    }, ms)
  }

  async restart() {
    await this.stop()
    this.restarts = 0
    return this.start()
  }

  startHealthCheck() {
    this.stopHealthCheck()
    const interval = Number(this.server.healthIntervalMs) || 5000
    const tick = () => this.probe()
    setTimeout(tick, 800)
    this.healthTimer = setInterval(tick, interval)
  }

  stopHealthCheck() {
    if (this.healthTimer) {
      clearInterval(this.healthTimer)
      this.healthTimer = null
    }
  }

  probe() {
    if (!this.child) return
    const request = http.get(
      {
        host: this.healthHost(),
        port: this.server.port,
        path: '/api/health',
        timeout: 2500
      },
      (response) => {
        response.resume()
        const ok = response.statusCode === 200
        this.setHealthy(ok)
      }
    )
    request.on('timeout', () => request.destroy())
    request.on('error', () => this.setHealthy(false))
  }

  setHealthy(ok) {
    const changed = this.healthy !== ok
    if (ok) {
      if (!this.healthySince) this.healthySince = Date.now()
    } else {
      this.healthySince = null
    }
    this.healthy = ok
    if (changed) {
      this.log.push('console', ok ? '服务端健康检查通过' : '服务端健康检查失败（等待重试）')
    }

    // 连续健康一段时间后清零崩溃计数：否则长时间赛事里历史崩溃会耗尽
    // maxRestarts 配额，之后真崩了反而不自动拉起
    let reset = false
    if (ok && this.restarts > 0) {
      const resetAfter = Number(this.server.healthyResetMs) || HEALTHY_RESET_MS
      if (Date.now() - this.healthySince >= resetAfter) {
        this.restarts = 0
        reset = true
        this.log.push('console', '服务端持续健康，崩溃计数已清零')
      }
    }

    if (changed || reset) this.emitStatus()
  }

  dispose() {
    if (this.restartTimer) clearTimeout(this.restartTimer)
    if (this.forceKillTimer) clearTimeout(this.forceKillTimer)
    this.stopHealthCheck()
    this.removeAllListeners()
  }
}

module.exports = { ServiceSupervisor, STATE_LABEL }