var ble = require('../../services/ble')
var api = require('../../utils/api')
var diagnosis = require('../../services/diagnosis')
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
    })
  },

  _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: '设备未连接' })
      return
    }

    self._pdSum = [0, 0, 0, 0, 0, 0, 0]
    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
      }

      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: '面膜未佩戴好，请重新佩戴后再试' })
        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

      self._frameCount++
      for (var i = 0; i < 7; i++) {
        self._pdSum[i] += data.pd[i]
      }
      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: '检测命令发送失败' })
    })

    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: '检测超时，未收到数据，请重试' })
      }
    }, SCAN_TIMEOUT)
  },

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

    var avg = []
    var count = this._frameCount || 1
    for (var i = 0; i < 7; i++) {
      avg.push(Math.round(this._pdSum[i] / count))
    }

    this.setData({ phase: 'done', pdAvg: avg, frameCount: count })
    getApp().globalData.lastScanPdAvg = avg
    console.log('[SCAN] PD平均值:', avg, '帧数:', count)

    this._buildAndGoReport(avg)
  },

  // 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: today only single-wavelength red PD is collected, and the thresholds +
  // PD->region mapping in services/diagnosis.js are placeholders pending calibration.
  // Report + persistence work end to end regardless; the numbers get real after
  // 4-wavelength scan collection and calibration land.
  _buildAndGoReport: function (avg) {
    var self = this
    var app = getApp()
    var mask = self.data.regions || 0x1F
    var deviceId = (app.globalData.connectedDevice && app.globalData.connectedDevice.device_id) || null
    var scannedAt = Date.now()

    function proceed(config) {
      var scanData = diagnosis.fromRedScan(avg, 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) {
      proceed(cfg && cfg.levels ? 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()
  }
})