var ble = require('../../services/ble')
var api = require('../../utils/api')
var diagnosis = require('../../services/diagnosis')
var i18n = require('../../i18n/index')
var SCAN_TIMEOUT = 180000

Page({
  data: {
    statusBarHeight: 44,
    regions: 0x1F,
    phase: 'ready',
    frameCount: 0,
    pdAvg: [],
    vbat: 0,
    battery: 0,
    error: ''
  },

  onBack: function () {
    wx.navigateBack({
      fail: function () {
        wx.reLaunch({ url: '/pages/index/index' })
      }
    })
  },

  onLoad: function (options) {
    var app = getApp()
    this.setData({
      statusBarHeight: app.globalData.statusBarHeight,
      regions: parseInt(options.regions) || 0x1F
    })
  },

  onShow: function () {
    i18n.bind(this)
  },

  _cleanup: function () {
    if (this._timeoutTimer) { clearTimeout(this._timeoutTimer); this._timeoutTimer = null }
    if (this._onAdc) { ble.off('adc', this._onAdc); this._onAdc = null }
    if (this._onFitting) { ble.off('fitting', this._onFitting); this._onFitting = null }
    if (this._onRunState) { ble.off('run_state', this._onRunState); this._onRunState = null }
  },

  onStartScan: function () {
    var self = this

    if (!ble.isConnected()) {
      self.setData({ error: i18n.t('common.deviceNotConnected') })
      return
    }

    // 按扫描光色分桶累加（FFE4 Byte17 高三位，新协议）。旧固件无标识 → 全部归 red 桶。
    self._buckets = {}
    self._frameCount = 0
    self._completed = false
    self._collecting = false
    self._seenRunState1 = false
    self._lastFitting = -1
    self._lastRunState = -1
    self.setData({ phase: 'waiting_fit', frameCount: 0, pdAvg: [], error: '' })

    self._onFitting = function (data) {
      if (self._completed) return
      if (data.fitting !== self._lastFitting) {
        console.log('[SCAN] fitting:', data.fitting)
        self._lastFitting = data.fitting
      }
      if (data.fitting === 1 && self._lastRunState === 1 && !self._collecting) {
        console.log('[SCAN] 贴合确认，开始采集PD数据')
        self._collecting = true
        self.setData({ phase: 'collecting' })
      }
    }
    ble.on('fitting', self._onFitting)

    self._onRunState = function (data) {
      if (self._completed) return
      if (data.run_state !== self._lastRunState) {
        console.log('[SCAN] run_state:', data.run_state)
        self._lastRunState = data.run_state
      }

      // 设备故障(Byte18=0xFF)：立即中止，不等 3 分钟超时
      if (data.run_state === 0xFF) {
        console.error('[SCAN] 设备故障，中止扫描')
        self._completed = true
        self._cleanup()
        self.setData({ phase: 'ready', error: i18n.t('autoScan.deviceFault') })
        return
      }

      if (data.run_state === 1) {
        self._seenRunState1 = true
      }

      if (self._lastFitting === 1 && data.run_state === 1 && !self._collecting) {
        console.log('[SCAN] 贴合确认，开始采集PD数据')
        self._collecting = true
        self.setData({ phase: 'collecting' })
      }

      if (self._seenRunState1 && self._lastFitting === 0 && data.run_state === 0 && self.data.phase === 'waiting_fit') {
        console.log('[SCAN] 未贴合，检测失败')
        self._completed = true
        self._cleanup()
        self.setData({ phase: 'ready', error: i18n.t('autoScan.notWorn') })
        return
      }

      if (data.run_state === 0 && self._collecting) {
        console.log('[SCAN] 扫描完成，共', self._frameCount, '帧')
        self._scanComplete()
      }
    }
    ble.on('run_state', self._onRunState)

    self._onAdc = function (data) {
      if (self._completed || !self._collecting) return
      if (!data || !data.pd || data.pd.length < 7) return

      var wave = data.scan_wave || 'red' // 旧固件帧无光色标识，按单波长红光兼容
      var bucket = self._buckets[wave]
      if (!bucket) {
        bucket = { sum: [0, 0, 0, 0, 0, 0, 0], n: 0 }
        self._buckets[wave] = bucket
      }
      bucket.n++
      for (var i = 0; i < 7; i++) {
        bucket.sum[i] += data.pd[i]
      }
      self._frameCount++
      self.setData({
        frameCount: self._frameCount,
        vbat: data.vbat || self.data.vbat,
        battery: data.battery || self.data.battery
      })
    }
    ble.on('adc', self._onAdc)

    console.log('[SCAN] 发送检测命令 control=0x01')
    ble.setParams({
      region_mask: self.data.regions,
      wavelength: 2,
      brightness: 128,
      hold_time: 0,
      control: 0x01
    }).then(function () {
      console.log('[SCAN] 检测命令发送成功，等待贴合...')
    }).catch(function (err) {
      console.error('[SCAN] 检测命令发送失败:', err)
      self._cleanup()
      self.setData({ phase: 'ready', error: i18n.t('autoScan.cmdFailed') })
    })

    self._timeoutTimer = setTimeout(function () {
      if (self._completed) return
      console.log('[SCAN] 超时（3分钟），已收到', self._frameCount, '帧')
      if (self._frameCount > 0) {
        self._scanComplete()
      } else {
        self._completed = true
        self._cleanup()
        self.setData({ phase: 'ready', error: i18n.t('autoScan.timeout') })
      }
    }, SCAN_TIMEOUT)
  },

  _scanComplete: function () {
    if (this._completed) return
    this._completed = true
    this._cleanup()

    // 每个光色桶各自求平均 → waves: { red:[7], ir:[7], uv:[7], yellow:[7] }（有几色算几色）
    var waves = {}
    var firstAvg = []
    for (var wave in this._buckets) {
      if (!this._buckets.hasOwnProperty(wave)) continue
      var b = this._buckets[wave]
      if (!b.n) continue
      var avg = []
      for (var i = 0; i < 7; i++) avg.push(Math.round(b.sum[i] / b.n))
      waves[wave] = avg
      if (!firstAvg.length) firstAvg = avg
    }

    this.setData({ phase: 'done', pdAvg: firstAvg, frameCount: this._frameCount })
    getApp().globalData.lastScanPdAvg = firstAvg
    console.log('[SCAN] 分桶结果:', JSON.stringify(Object.keys(waves).map(function (k) { return k })), '总帧数:', this._frameCount)

    this._buildAndGoReport(waves)
  },

  // Scan finished -> run the (placeholder) diagnosis, store + persist a report, and
  // navigate to the report page so the user sees their skin tendencies and chooses
  // care. This replaces the previous auto-start-treatment behavior.
  //
  // NOTE: thresholds + PD->region mapping in services/diagnosis.js are placeholders
  // pending hardware confirmation / calibration (tunable via server diagnosis_config).
  // Old firmware sends no wave marker -> everything lands in the red bucket and the
  // pipeline degrades to single-wavelength gracefully.
  _buildAndGoReport: function (waves) {
    var self = this
    var app = getApp()
    var mask = self.data.regions || 0x1F
    // Same device-id source the treating page uses (services/ble getDeviceId + currentDevice fallback).
    var deviceId = ble.getDeviceId() || (app.globalData.currentDevice && app.globalData.currentDevice.device_id) || null
    var scannedAt = Date.now()

    function proceed(config) {
      var scanData = diagnosis.buildScanData(waves, mask, deviceId, scannedAt)
      var report = diagnosis.analyze(scanData, config || diagnosis.DEFAULT_CONFIG)
      app.globalData.lastScanReport = report

      // Best-effort persist (also seeds the calibration dataset via raw_pd); never blocks navigation.
      api.saveReport({
        device_id: report.device_id,
        scanned_at: report.scanned_at,
        regions: report.regions,
        overall: report.overall,
        recommend_mask: report.recommend_mask,
        recommend_plan: report.recommend_plan,
        raw_pd: report.raw_pd,
        calibrated: report.calibrated
      }).catch(function () {})

      wx.redirectTo({ url: '/pages/scan-report/scan-report' })
    }

    api.getDiagnosisConfig().then(function (cfg) {
      // 非空对象即采用——缺失字段由 analyze 逐项回退 DEFAULT；只发部分字段(如仅调 pd_region_map)也生效
      var usable = cfg && typeof cfg === 'object' && Object.keys(cfg).length > 0
      proceed(usable ? cfg : diagnosis.DEFAULT_CONFIG)
    }).catch(function () {
      proceed(diagnosis.DEFAULT_CONFIG)
    })
  },

  onUnload: function () {
    if (!this._completed && (this.data.phase === 'waiting_fit' || this.data.phase === 'collecting')) {
      ble.stopTreatment().catch(function () {})
    }
    this._cleanup()
  }
})