import { getCurrentInstance } from 'vue'

class UniPush {
  constructor() {
    this.isUniApp = typeof uni !== 'undefined'
    this.is5PlusApp = typeof plus !== 'undefined' && !this.isUniApp
    this.clientId = null
    this.pushEnabled = false
    this.forceNotificationMode = false // 是否使用 force_notification:true 模式
    this.init()
  }

  async init() {
    if (!this.isUniApp && !this.is5PlusApp) {
      console.warn('当前环境不是uni-app或5+App，无法使用推送功能')
      return
    }

    try {
      // 获取客户端标识
      const info = await this.getClientInfo()
      
      // 显示客户端ID（仅开发环境使用）
      // if (process.env.NODE_ENV === 'development') {
        if (this.isUniApp) {
          uni.showModal({
            title: 'uni-push客户端ID',
            content:JSON.stringify(info),
            showCancel: false
          })
        } else if (this.is5PlusApp && plus.nativeUI) {
          plus.nativeUI.alert(JSON.stringify(info), () => {}, '5+App推送客户端ID')
        }
      // }
      
      this.clientId = info.clientId
      console.log('推送客户端ID:', this.clientId)
      
      // 监听推送消息
      this.setupPushListener()
      
      this.pushEnabled = true
    } catch (error) {
      console.error('推送初始化失败:', error)
    }
  }

  // 获取客户端信息
  getClientInfo() {
    return new Promise((resolve, reject) => {
      if (this.isUniApp) {
        // uni-app 环境
        uni.getPushClientId({
          success: (res) => {
            resolve({
              clientId: res.cid,
              platform: 'uniapp'
            })
          },
          fail: (err) => {
            reject(err)
          }
        })
      } else if (this.is5PlusApp) {
        // 5+App 环境 - 优先尝试使用原生推送API
        if (plus.push && typeof plus.push.getClientInfoAsync === 'function') {
          plus.push.getClientInfoAsync((result) => {
            if (result && result.clientid) {
              // 成功获取到推送客户端ID
              resolve({
                clientId: result.clientid,
                platform: '5plus',
                appid: result.appid,
                token: result.token
              })
            } else {
              // 原生推送不可用，回退到自定义生成
              this.fallbackToCustomClientId(resolve, reject)
            }
          }, (error) => {
            // 获取失败，回退到自定义生成
            console.warn('plus.push.getClientInfoAsync 失败:', error)
            this.fallbackToCustomClientId(resolve, reject)
          })
        } else {
          // 原生推送API不可用，使用自定义生成
          this.fallbackToCustomClientId(resolve, reject)
        }
      } else {
        reject(new Error('不支持的环境'))
      }
    })
  }

  // 回退到自定义客户端ID生成
  fallbackToCustomClientId(resolve, reject) {
    try {
      const deviceInfo = plus.device
      const clientId = this.generate5PlusClientId()
      resolve({
        clientId: clientId,
        platform: '5plus',
        deviceId: deviceInfo.uuid || deviceInfo.imei || 'unknown',
        fallback: true // 标记为回退方案
      })
    } catch (error) {
      reject(new Error('5+App环境获取设备信息失败'))
    }
  }

  // 设置推送监听
  setupPushListener() {
    if (this.isUniApp) {
      // uni-app 环境监听
      uni.onPushMessage((res) => {
        console.log('推送消息类型:', res.type, '内容:', res)
        
        if (res.type === 'click') {
          // 用户点击通知栏消息（在线/离线都会触发）
          console.log('用户点击了推送消息:', res)
          this.handlePushClick(res)
        } else if (res.type === 'receive') {
          // 应用在线时接收到的消息（不使用 force_notification:true 时触发）
          console.log('应用在线收到推送消息:', res)
          this.handlePushMessage(res)
        }
      })
    } else if (this.is5PlusApp) {
      // 5+App 环境监听 - 使用原生推送监听
      this.setup5PlusPushListener()
    }
  }

  // 设置5+App推送监听
  setup5PlusPushListener() {
    if (plus.push && typeof plus.push.addEventListener === 'function') {
      // 监听接收消息事件
      plus.push.addEventListener('receive', (msg) => {
        console.log('5+App收到推送消息:', msg)
        this.handle5PlusPushMessage(msg)
      }, false)
      
      // 监听点击消息事件
      plus.push.addEventListener('click', (msg) => {
        console.log('5+App点击推送消息:', msg)
        this.handle5PlusPushClick(msg)
      }, false)
    } else {
      console.warn('5+App原生推送监听不可用，将使用自定义消息处理')
    }
  }

  // 处理5+App推送消息
  handle5PlusPushMessage(message) {
    console.log('处理5+App推送消息:', message)
    
    // 解析消息内容
    const pushData = this.parse5PlusPushData(message)
    
    // 触发自定义事件
    if (typeof this.onMessage === 'function') {
      this.onMessage(pushData)
    }
  }

  // 处理5+App推送点击
  handle5PlusPushClick(message) {
    console.log('处理5+App推送点击:', message)
    
    const pushData = this.parse5PlusPushData(message)
    
    // 根据消息内容跳转到对应页面
    if (pushData.page) {
      // 这里可以添加页面跳转逻辑
      console.log('跳转到页面:', pushData.page)
    }
  }

  // 解析5+App推送数据
  parse5PlusPushData(message) {
    try {
      // 尝试解析JSON格式的payload
      let payload = {}
      if (message.payload) {
        payload = typeof message.payload === 'string' 
          ? JSON.parse(message.payload) 
          : message.payload
      }
      
      return {
        type: 'receive',
        data: payload,
        title: message.title || payload.title,
        content: message.content || payload.content
      }
    } catch (error) {
      console.warn('解析5+App推送数据失败:', error)
      return {
        type: 'receive',
        data: {},
        title: message.title,
        content: message.content
      }
    }
  }

  // 处理推送消息
  handlePushMessage(message) {
    console.log('处理推送消息（使用 force_notification:true 时在线不会触发）:', message)
    
    // 注意：当后端使用 force_notification:true 时，应用在线时不会触发此方法
    // 消息会直接显示在通知栏，用户点击后才会触发 handlePushClick
    
    // 如果不使用 force_notification:true，可以在此处显示本地通知
    if (!this.forceNotificationMode && this.isUniApp && message.data) {
      uni.showNotification({
        title: message.data.title || '新消息',
        content: message.data.content || '您有一条新消息',
        payload: message.data
      })
    }

    // 触发自定义事件
    if (typeof this.onMessage === 'function') {
      this.onMessage(message)
    }
  }

  // 处理推送点击
  handlePushClick(message) {
    // 根据消息内容跳转到对应页面
    if (message.data && message.data.page) {
    //   this.navigateToPage(message.data.page, message.data.params)
    }

    // 触发自定义点击事件
    if (typeof this.onClick === 'function') {
      this.onClick(message)
    }
  }

  // 页面跳转
  navigateToPage(page, params = {}) {
    if (!this.isUniApp) return

    const pages = {
      'home': '/pages/index/index',
      'message': '/pages/message/message',
      'workbench': '/pages/workbench/workbench'
    }

    const path = pages[page] || '/pages/index/index'
    
    uni.navigateTo({
      url: path + '?' + new URLSearchParams(params).toString()
    })
  }

  // 检查推送权限
  checkPermission() {
    return new Promise((resolve) => {
      if (this.isUniApp) {
        uni.getPushProvider({
          success: (res) => {
            resolve(res.provider !== 'none')
          },
          fail: () => {
            resolve(false)
          }
        })
      } else if (this.is5PlusApp) {
        // 5+App 环境检查推送服务是否可用
        if (plus.push) {
          resolve(true)
        } else {
          resolve(false)
        }
      } else {
        resolve(false)
      }
    })
  }

  // 请求推送权限
  requestPermission() {
    return new Promise((resolve, reject) => {
      if (this.isUniApp) {
        uni.requestPushPermission({
          success: (res) => {
            resolve(res)
          },
          fail: (err) => {
            reject(err)
          }
        })
      } else if (this.is5PlusApp) {
        // 5+App 环境通常不需要额外请求权限
        // 直接返回成功，实际权限由系统控制
        resolve({ status: 'granted' })
      } else {
        reject(new Error('不支持的环境'))
      }
    })
  }

  // 设置推送标签
  setTags(tags) {
    return new Promise((resolve, reject) => {
      if (this.isUniApp) {
        uni.setPushTags({
          tags: tags,
          success: (res) => {
            resolve(res)
          },
          fail: (err) => {
            reject(err)
          }
        })
      } else if (this.is5PlusApp) {
        // 5+App 环境暂不支持标签设置，返回成功但不执行操作
        console.log('5+App环境暂不支持推送标签设置')
        resolve({ success: true })
      } else {
        reject(new Error('不支持的环境'))
      }
    })
  }

  // 获取推送标签
  getTags() {
    return new Promise((resolve, reject) => {
      if (this.isUniApp) {
        uni.getPushTags({
          success: (res) => {
            resolve(res.tags)
          },
          fail: (err) => {
            reject(err)
          }
        })
      } else if (this.is5PlusApp) {
        // 5+App 环境暂不支持标签获取，返回空数组
        resolve([])
      } else {
        reject(new Error('不支持的环境'))
      }
    })
  }

  // 生成 5+App 客户端ID
  generate5PlusClientId() {
    try {
      let clientId = null
      
      // 优先尝试使用 5+App 的本地存储
      if (plus.storage) {
        clientId = plus.storage.getItem('5plus_client_id')
      }
      
      // 如果 5+App 存储不可用，尝试使用浏览器 localStorage
      if (!clientId && typeof localStorage !== 'undefined') {
        clientId = localStorage.getItem('5plus_client_id')
      }
      
      if (!clientId) {
        // 生成新的客户端ID
        const deviceInfo = plus.device
        const timestamp = Date.now()
        const random = Math.random().toString(36).substr(2, 9)
        
        // 使用设备信息生成唯一ID
        clientId = `5plus_${deviceInfo.uuid || 'unknown'}_${timestamp}_${random}`
        
        // 存储到本地
        if (plus.storage) {
          plus.storage.setItem('5plus_client_id', clientId)
        } else if (typeof localStorage !== 'undefined') {
          localStorage.setItem('5plus_client_id', clientId)
        }
      }
      
      return clientId
    } catch (error) {
      // 备用方案：使用时间戳和随机数
      return `5plus_fallback_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
    }
  }

  // 设置 force_notification 模式
  setForceNotificationMode(enabled) {
    this.forceNotificationMode = enabled
    console.log(`force_notification 模式: ${enabled ? '已启用' : '已禁用'}`)
  }

  // 销毁推送实例
  destroy() {
    if (this.isUniApp) {
      uni.offPushMessage()
    }
    this.pushEnabled = false
  }
}

// 创建全局推送实例
const pushInstance = new UniPush()

export default pushInstance