import { lefuService } from '../../lefu/index'
import type { LeFuWifiItem, WifiVersion } from '../../lefu/index'

/** WiFi 展示项 */
interface WifiItem {
    ssid: string
    /** 是否已通过本页配网成功 */
    connected: boolean
}

/** 当前已连接设备（顶部卡片） */
interface CurrentDevice {
    id: string
    name: string
}

/** 密码态选中的 WiFi */
interface SelectedWifi {
    ssid: string
}

/** 页面状态 */
type WifiStatus = 'idle' | 'searching' | 'list' | 'empty' | 'password' | 'configuring'

Page({
    /** 配网协议版本，两种都支持，默认 domain2（有鉴权） */
    _wifiVersion: 'domain2' as WifiVersion,

    data: {
        /**
         * 页面状态
         *  - idle:        未搜索
         *  - searching:   正在从设备获取 WiFi 列表
         *  - list:        列表已就绪
         *  - empty:       设备未扫描到任何 WiFi
         *  - password:    选中某项，正在输入密码
         *  - configuring: 正在将 WiFi 写入设备
         */
        status: 'idle' as WifiStatus,

        /** 顶部固定卡片 */
        currentDevice: {
            id: '',
            name: '智能体重秤',
        } as CurrentDevice,

        /** 蓝牙连接状态常量（从插件获取，供 wxml 做条件判断） */
        BLUE_STATE: {} as Record<string, string>,

        /** 当前蓝牙连接状态（实时更新） */
        connectState: '',

        /** 顶部卡片蓝牙状态：connected / failed / connecting */
        bleStatus: 'connected' as 'connected' | 'failed' | 'connecting',

        /** WiFi 列表 */
        wifiList: [] as WifiItem[],

        /** 是否已有任一 WiFi 配网成功 */
        hasConnected: false,

        /** 当前密码态选中的 WiFi */
        selectedWifi: { ssid: '' } as SelectedWifi,

        /** 密码输入框值 */
        selectWifiPWD: '',

        /** 密码框明文/密文切换：true 为密文（默认） */
        type: true,
    },

    _toBleStatus(state: string): 'connected' | 'failed' | 'connecting' {
        const bs = lefuService.BLUE_STATE
        if (state === bs.CONNECTSUCCESS || state === bs.WIFISUCCESS) return 'connected'
        if (state === bs.CONNECTFAILED) return 'failed'
        return 'connecting'
    },

    onLoad() {
        this.setData({
            bleStatus: this._toBleStatus(lefuService.connectState),
            currentDevice: { id: '', name: lefuService.deviceInfo?.modelNumber ?? '智能体重秤' },
        })
        this.onStartSearch()
    },

    onShow() {
        lefuService.onConnectState((state) => {
            const bs = lefuService.BLUE_STATE
            // 只处理明确的连接/断开状态，忽略蓝牙初始化过程中的中间状态
            if (state === bs.CONNECTSUCCESS || state === bs.WIFISUCCESS || state === bs.CONNECTFAILED) {
                this.setData({ bleStatus: this._toBleStatus(state) })
            }
        })
        lefuService.onDeviceInfo((info) => {
            this.setData({ currentDevice: { id: '', name: info.modelNumber } })
        })
    },

    onUnload() {
        wx.hideLoading()
        if (this.data.status === 'configuring') {
            lefuService.disconnect()
        }
    },

    /** 从设备获取 WiFi 列表 */
    onStartSearch() {
        this.setData({ status: 'searching', wifiList: [] })
        wx.showLoading({ title: '正在获取 WiFi 列表...', mask: true })

        lefuService.getWifiList()
            .then((items: LeFuWifiItem[]) => {
                wx.hideLoading()
                if (!items.length) {
                    this.setData({ status: 'empty' })
                    return
                }
                const list: WifiItem[] = items.map(item => ({
                    ssid: item.ssid,
                    connected: false,
                }))
                this.setData({ status: 'list', wifiList: list })
            })
            .catch(() => {
                wx.hideLoading()
                this.setData({ status: 'empty' })
            })
    },

    /** 空态刷新 */
    onRefresh() {
        this.onStartSearch()
    },

    /** 点击 WiFi 项 → 进密码态 */
    onTapWifi(e: WechatMiniprogram.TouchEvent) {
        const ssid = e.currentTarget.dataset.ssid as string
        const target = this.data.wifiList.find(item => item.ssid === ssid)
        if (!target || target.connected) return

        this.setData({
            status: 'password',
            selectedWifi: { ssid },
            selectWifiPWD: '',
            type: true,
        })
    },

    /** 密码输入 */
    passwordInput(e: WechatMiniprogram.Input) {
        this.setData({ selectWifiPWD: e.detail.value })
    },

    /** 明文/密文切换 */
    inputTypeChange() {
        this.setData({ type: !this.data.type })
    },

    /** 密码态「取消」→ 回列表 */
    onCancelPwd() {
        this.setData({
            status: 'list',
            selectedWifi: { ssid: '' },
            selectWifiPWD: '',
        })
    },

    /** 密码态「连接」→ 将 WiFi 写入设备 */
    onConfirmPwd() {
        const { selectedWifi, selectWifiPWD } = this.data
        if (!selectedWifi.ssid) return

        this.setData({ status: 'configuring' })
        wx.showLoading({ title: '正在配网...', mask: true })

        lefuService.configWifi(selectedWifi.ssid, selectWifiPWD, this._wifiVersion)
            .then(() => {
                wx.hideLoading()
                const next = this.data.wifiList.map(item => ({
                    ...item,
                    connected: item.ssid === selectedWifi.ssid,
                }))
                this.setData({
                    status: 'list',
                    wifiList: next,
                    hasConnected: true,
                    selectedWifi: { ssid: '' },
                    selectWifiPWD: '',
                })
            })
            .catch((err: Error) => {
                wx.hideLoading()
                wx.showToast({ title: err.message || '配网失败，请重试', icon: 'none' })
                this.setData({ status: 'password' })
            })
    },

    /** 底部「确认」：已有 WiFi 配网成功才可点击 */
    onConfirm() {
        if (!this.data.hasConnected) return
        wx.navigateTo({ url: '/pages/supplementPersonal/supplementPersonal' })
    },
})