import { get, post } from '../../utils/request/index'
import { leFuService } from '../../lefu/index'
import type { SyncUserData } from '../../lefu/index'
import { calcAge } from '../../utils/idCard/index'

/** 连接状态订阅句柄 */
let unsubDeviceConnect: (() => void) | null = null
let unsubDisconnected: (() => void) | null = null
/** 同步完成关闭弹框定时器 */
let syncCloseTimer: number | null = null
/** selectUserBySn/user 返回的单条结构 */
interface SysUserDevice {
    id: string
    userId: string
    realname: string
    height: number
    birthday: string
    sex: number
    dataType: number
    relationType: number | null
    syncStatus?: number
}

/** 展示用成员项 */
interface MemberItem {
    id: string
    userId: string
    name: string
    gender: string
    age: number
    height: number
    sync: string
    syncClass: string
}

/** 展示用分组 */
interface GroupItem {
    title: string
    members: MemberItem[]
}

/** 获取设备成员列表 */
const getDeviceMembers = (sn: string, userId: string) =>
    get<SysUserDevice[]>('weighingScale/v3/selectUserBySn/user', { sn, userId })

/** 标记用户已同步到设备 */
const markSynced = (data: { sn: string; list: string[] }) =>
    post('weighingScale/v6/markSynced', data, { loading: false })

/** equipment 页传入的目标设备 */
let targetDevice: { sn: string; deviceId: string; name: string; connected: boolean; connectDeviceInfo: string } | null = null

Page({
    data: {
        device: {
            name: '智能体重秤',
            status: false,
            deviceId: '',
            sn: ''
        },
        memberCount: 0,
        hasData: false,
        self: null as null | MemberItem,
        groups: [] as GroupItem[],
        syncShow: false,
        syncPercent: 0,
        syncStatus: ''
    },

    onLoad(options: Record<string, string>) {
        targetDevice = {
            sn: decodeURIComponent(options.sn || ''),
            deviceId: decodeURIComponent(options.deviceId || ''),
            name: decodeURIComponent(options.name || ''),
            connected: options.status === 'true',
            connectDeviceInfo: decodeURIComponent(options.connectDeviceInfo || ''),
        }
        this.setData({
            'device.name': targetDevice.name || '智能体重秤',
            'device.deviceId': targetDevice.deviceId,
            'device.sn': targetDevice.sn,
            'device.status': targetDevice.connected,
        })
        this._subscribeDeviceState()
        this._loadMembers()
    },

    onUnload() {
        unsubDeviceConnect?.()
        unsubDisconnected?.()
        unsubDeviceConnect = null
        unsubDisconnected = null
        if (syncCloseTimer !== null) { clearTimeout(syncCloseTimer); syncCloseTimer = null }
    },

    /** 订阅连接状态，实时同步设备卡（判断是否连接的目标设备） */
    _subscribeDeviceState() {
        unsubDeviceConnect?.()
        unsubDisconnected?.()
        unsubDeviceConnect = leFuService.onDeviceConnect(() => {
            this.setData({ 'device.status': leFuService.lastRawDevice?.deviceId === targetDevice?.deviceId })
        })
        unsubDisconnected = leFuService.onDisconnected(() => {
            this.setData({ 'device.status': false })
        })
    },

    /** 拉取设备成员列表，映射到本人 + 员工/家庭用户分组 */
    _loadMembers() {
        if (!targetDevice?.sn) return
        const userInfo = wx.getStorageSync('userInfo') as { userId?: string } | null
        const userId = userInfo?.userId ?? ''
        if (!userId) return

        getDeviceMembers(targetDevice.sn, userId)
            .then(res => {
                const list = res.result
                const toMember = (item: SysUserDevice): MemberItem => ({
                    id: item.id,
                    userId: item.userId,
                    name: item.realname,
                    gender: item.sex === 1 ? '男' : '女',
                    age: calcAge(item.birthday),
                    height: item.height,
                    sync: item.syncStatus === 1 ? '已同步' : '待同步',
                    syncClass: item.syncStatus === 1 ? 'done' : 'pending',
                })
                const self = list.find(m => m.relationType === 1)
                this.setData({
                    self: self ? toMember(self) : null,
                    groups: [
                        { title: '员工', members: list.filter(m => m.relationType !== 1 && m.dataType === 0).map(toMember) },
                        { title: '家庭用户', members: list.filter(m => m.relationType !== 1 && m.dataType === 1).map(toMember) },
                    ].filter(g => g.members.length),
                    memberCount: list.length,
                    hasData: list.length > 0,
                })
            })
            .catch(() => {
                wx.showToast({ title: '加载用户列表失败', icon: 'none' })
            })
    },

    /** 校验是否连接的是目标设备：不是则弹框提示连接/取消 */
    _ensureConnected(): boolean {
        const connected = leFuService.isConnected && leFuService.lastRawDevice?.deviceId === targetDevice?.deviceId
        if (connected) return true
        this.setData({ 'device.status': false })
        wx.showModal({
            title: '未连接设备',
            content: '请先连接该设备后再同步用户',
            cancelText: '取消同步',
            confirmText: '连接设备',
            success: (res) => {
                if (res.confirm) {
                    this._connectTargetDevice()
                }
            },
        })
        return false
    },

    /** 本页面扫描并连接目标设备 */
    _connectTargetDevice() {
        const targetDeviceId = targetDevice?.deviceId
        if (!targetDeviceId) return
        if (leFuService.isConnected) leFuService.disconnect()

        wx.showLoading({ title: '连接中...', mask: true })
        wx.openBluetoothAdapter({
            success: () => {
                let unsubList: (() => void) | null = null
                let unsubConnect: (() => void) | null = null
                const timer = setTimeout(() => {
                    unsubList?.()
                    unsubList = null
                    wx.hideLoading()
                    wx.showToast({ title: '未找到设备', icon: 'none' })
                }, 15000)

                unsubList = leFuService.onDevicesList((devices) => {
                    const matched = devices.find(d => d.raw.deviceId === targetDeviceId)
                    if (!matched) return
                    clearTimeout(timer)
                    unsubList?.()
                    unsubList = null
                    leFuService.stopScan()
                    leFuService.connect(matched.raw)
                    unsubConnect = leFuService.onDeviceConnect(() => {
                        unsubConnect?.()
                        unsubConnect = null
                        wx.hideLoading()
                        wx.setStorageSync('connectDeviceInfo', matched.raw)
                        this.setData({ 'device.status': true })
                        this.onTapSync()
                    })
                })
                leFuService.startScan()
            },
            fail: () => {
                wx.hideLoading()
                wx.showToast({ title: '蓝牙未开启', icon: 'none' })
            },
        })
    },

    /** 同步用户至设备：只下发「待同步」的用户 */
    onTapSync() {
        if (!this._ensureConnected()) return

        // 组装所有用户（本人第一个，作为主用户），性别：男=1 女=0
        const self = this.data.self
        const allUsers = [
            ...(self ? [{
                id: self.id, userId: self.userId, name: self.name,
                gender: self.gender === '男' ? 1 : 0,
                age: self.age, height: self.height, sync: self.sync,
            }] : []),
            ...this.data.groups.flatMap(g => g.members.map(m => ({
                id: String(m.id), userId: m.userId, name: m.name,
                gender: m.gender === '男' ? 1 : 0, age: m.age, height: m.height, sync: m.sync,
            }))),
        ]
        if (!allUsers.length) {
            wx.showToast({ title: '暂无用户可同步', icon: 'none' })
            return
        }
        const mainUser = allUsers[0]
        // 只下发「待同步」的用户
        const pendingUsers = allUsers.filter(u => u.sync !== '已同步')
        if (!pendingUsers.length) {
            wx.showToast({ title: '没有需要同步的用户', icon: 'none' })
            return
        }
        // 组装下发参数（SyncUserData），主用户 memberID 为空
        const syncDataList: SyncUserData[] = pendingUsers.map((user, index) => ({
            userID: mainUser.id,
            userName: user.name,
            memberID: user.id === mainUser.id ? '' : user.id,
            age: user.age,
            gender: user.gender,
            height: user.height,
            isAthleteMode: 0,
            deviceHeaderIndex: index,
            currentWeight: '',
            targetWeight: '',
            idealWeight: '',
            recentData: [],
        }))

        // 直接下发待同步用户（不清空）
        this.setData({ syncShow: true, syncPercent: 0, syncStatus: '正在同步信息，请勿离开...' })
        leFuService.syncMembersToDevice(syncDataList, (current, total) => {
            this.setData({
                syncPercent: Math.round((current / total) * 100),
                syncStatus: `正在同步 ${current}/${total}...`,
            })
        })
            .then(() => {
                this.setData({ syncPercent: 100, syncStatus: '同步完成' })
                wx.showToast({ title: '用户同步成功', icon: 'success' })
                const syncedIds = pendingUsers.map(u => u.userId).filter(Boolean)
                if (targetDevice?.sn && syncedIds.length) {
                    markSynced({ sn: targetDevice.sn, list: syncedIds })
                        .then(() => {
                            // 标记成功后，把对应成员更新为「已同步」
                            const syncedSet = new Set(syncedIds)
                            this.setData({
                                self: this.data.self && syncedSet.has(this.data.self.userId)
                                    ? { ...this.data.self, sync: '已同步', syncClass: 'done' }
                                    : this.data.self,
                                groups: this.data.groups.map(g => ({
                                    ...g,
                                    members: g.members.map(m => syncedSet.has(m.userId) ? { ...m, sync: '已同步', syncClass: 'done' } : m),
                                })),
                            })
                        })
                        .catch(() => {})
                }
                if (syncCloseTimer !== null) { clearTimeout(syncCloseTimer); syncCloseTimer = null }
                syncCloseTimer = setTimeout(() => {
                    syncCloseTimer = null
                    this.setData({ syncShow: false })
                }, 1000)
            })
            .catch((err: Error) => {
                this.setData({ syncShow: false })
                wx.showToast({ title: err.message || '同步失败，请重试', icon: 'none' })
            })
    },

    /** 添加用户 */
    onTapAddUser() {
        const sn = targetDevice?.sn || ''
        wx.navigateTo({ url: `/pages/addUser/addUser?sn=${encodeURIComponent(sn)}` })
    },

    /** 一键添加本人 */
    onTapAddSelf() {
        // 一键添加本人（待接入）
    },

    /** 添加新用户 */
    onTapAddNew() {
        wx.navigateTo({ url: '/pages/addUser/addUser' })
    }
})