/**
 * APP桥接工具函数
 * 用于H5页面与原生APP之间的通信
 */

import {
  COMMON_HEADERS, // 公共请求头
} from '@/utils/http.js'

// ==================== 工具函数 ====================

/**
 * 检测是否为移动设备（Android、iOS）系统
 * @returns {boolean}
 */
export function android() {
  return /Android|iPad|iPhone|iPod/.test(navigator.userAgent)
}

/**
 * 检测是否为 Android 设备
 * @returns {boolean}
 */
export function isAndroidDevice() {
  if (typeof navigator === 'undefined') return false
  return /Android/i.test(navigator.userAgent || '')
}

/**
 * 检测是否为 iOS 设备
 * @returns {boolean}
 */
export function isIosDevice() {
  if (typeof navigator === 'undefined') return false
  const userAgent = navigator.userAgent || ''
  const isIosUserAgent = /iPad|iPhone|iPod/i.test(userAgent)
  const isIPadOS = /Macintosh/i.test(userAgent) && navigator.maxTouchPoints > 1
  return isIosUserAgent || isIPadOS
}

/**
 * 检测是否在APP环境中
 * @returns {boolean}
 */
export function isInApp() {
  return !!(window.app || window.webkit || window.FlutterPageControl)
}

// ==================== 安全日志系统 ====================

/**
 * 安全的日志函数，避免 iOS WebView 中的 "JavaScript execution returned a result of an unsupported type" 错误
 * @param {string} level - 日志级别 ('log', 'debug', 'warn', 'error')
 * @param {...any} args - 日志参数
 */
function createSafeLogger() {
  return function safeConsoleLog(level, ...args) {
    if (process.env.NODE_ENV === 'production') return
    try {
      // 非 iOS 设备正常使用
      console[level](...args)
    } catch (e) {
      if (process.env.NODE_ENV === 'development') {
        console.error('Console logging failed:', e)
      }
    }
  }
}

// 创建日志函数实例
const safeConsoleLog = createSafeLogger()
const debugLog = (...args) => safeConsoleLog('debug', ...args)
const errorLog = (...args) => safeConsoleLog('error', ...args)
const warnLog = (...args) => safeConsoleLog('warn', ...args)
const infoLog = (...args) => safeConsoleLog('log', ...args)

// ==================== 平台特定处理函数 ====================

/**
 * Android 平台处理逻辑
 * @param {Function} renderFun - 回调函数
 */
function handleAndroidPlatform(renderFun) {
  debugLog('Flutter Android WebView 检测')
  debugLog('window.app 对象:', window.app)

  // 检查Flutter注入的接口
  if (window.app) {
    debugLog('window.app 的所有方法:')
    debugLog(Object.keys(window.app))

    // 检查具体的方法
    debugLog('getAccessOrigin 方法存在?', typeof window.app.getAccessOrigin)
    debugLog('getAccessOrigin 是函数?', typeof window.app.getAccessOrigin === 'function')
  }

  // 等待Flutter注入完成
  const waitForFlutterInterface = () => {
    let attempts = 0
    const maxAttempts = 150 // 最多等待15秒

    const checkInterface = () => {
      attempts++
      debugLog(`尝试第 ${attempts} 次检查Flutter接口...`)

      if (
        window.app &&
        window.app.getAccessOrigin &&
        typeof window.app.getAccessOrigin === 'function'
      ) {
        debugLog('Flutter接口检测成功，调用 getAccessOrigin')

        try {
          const result = window.app.getAccessOrigin() // 获取原生APP向H5发送的请求头参数
          debugLog('getAccessOrigin 返回结果:', result)
          renderFun(result) // 传递给回调函数
        } catch (error) {
          errorLog('调用 getAccessOrigin 出错:', error)
        }
      } else if (attempts < maxAttempts) {
        if (
          (attempts === 1 || attempts % 20 === 0) &&
          window.FlutterPageControl &&
          window.FlutterPageControl.postMessage
        ) {
          window.FlutterPageControl.postMessage('requestAccessOrigin')
        }
        // 没找到，继续查询
        setTimeout(checkInterface, 100)
      } else {
        // 查询次数用完
        errorLog('Flutter接口注入超时，使用默认数据')
        if (process.env.NODE_ENV === 'development') {
          const mockAccess = JSON.stringify({
            Authorization: 'Bearer FLUTTER_MOCK_TOKEN',
            'Req-Lang': 'en',
            'Req-App-Intel': 'build=1.0;version=2.1;channel=flutter;Req-Imei=flutter-device',
            'Req-Sys-Origin': 'origin=LIKEI;originChild=LIKEI',
          })
          renderFun(mockAccess)
        } else if (window.FlutterPageControl && window.FlutterPageControl.postMessage) {
          window.FlutterPageControl.postMessage('requestAccessOrigin')
        }
      }
    }

    checkInterface()
  }

  // window.app已存在，直接检查
  if (window.app) {
    waitForFlutterInterface()
  } else {
    // window.app不存在，等待注入
    debugLog('等待Flutter注入window.app...')
    // 监听window.app的创建
    let checkCount = 0
    const checkApp = () => {
      checkCount++
      if (window.app) {
        debugLog('检测到window.app，开始连接')
        waitForFlutterInterface()
      } else if (checkCount < 150) {
        if (
          (checkCount === 1 || checkCount % 20 === 0) &&
          window.FlutterPageControl &&
          window.FlutterPageControl.postMessage
        ) {
          window.FlutterPageControl.postMessage('requestAccessOrigin')
        }
        setTimeout(checkApp, 100)
      } else {
        errorLog('等待window.app超时')
        // 手动通知Flutter注入接口
        if (window.FlutterApp && window.FlutterApp.postMessage) {
          window.FlutterApp.postMessage('requestAccessOrigin')
        } else if (window.FlutterPageControl && window.FlutterPageControl.postMessage) {
          window.FlutterPageControl.postMessage('requestAccessOrigin')
        }
      }
    }
    checkApp()
  }
}

/**
 * Web 浏览器环境处理逻辑
 * @param {Function} renderFun - 回调函数
 */
function handleWebPlatform(renderFun) {
  debugLog('非移动设备环境')
  // 非APP环境，可能是浏览器调试
  console.warn('Not in APP environment, using mock data for development')
  // 开发环境可以提供模拟数据
  if (process.env.NODE_ENV === 'development') {
    const mockAccess = JSON.stringify({
      Authorization: COMMON_HEADERS.authorization,
      'Req-Lang': COMMON_HEADERS['req-lang'],
      'Req-App-Intel': COMMON_HEADERS['req-app-intel'],
      'Req-Sys-Origin': COMMON_HEADERS['req-sys-origin'],
    })
    setTimeout(() => renderFun(mockAccess), 100)
  }
}

// ==================== 主要功能函数 ====================

/**
 * 连接APP并获取访问参数
 * @param {Function} renderFun 回调函数，接收APP传递的access参数
 */
export function connectApplication(renderFun) {
  window.renderData = renderFun
  // 兼容历史版本
  window.getIosAccessOriginParam = renderFun

  try {
    if (android()) {
      console.log('设备为设备环境')
      handleAndroidPlatform(renderFun)
    } else {
      console.log('设备为Web浏览器环境')
      handleWebPlatform(renderFun)
    }
  } catch (error) {
    errorLog('Failed to connect to APP:', error)
  }
}

// ==================== APP 通信函数 ====================

/**
 * 关闭当前页面（返回到Flutter上一页）
 */
export function closePage() {
  try {
    if (window.app && window.app.closePage) {
      // 使用注入的方法
      window.app.closePage()
    } else if (window.FlutterPageControl) {
      // 直接使用Flutter通道
      window.FlutterPageControl.postMessage('close_page')
    } else {
      // 降级处理：浏览器环境
      // if (window.history.length > 1) {
      //   window.history.back()
      // } else {
      //   window.close()
      // }
    }
  } catch (error) {
    errorLog('关闭页面失败:', error)
    // 降级处理
    window.history.back()
  }
}

/**
 * 前往私聊
 */
export function gotoPrivateChat(userId) {
  if (!userId) return
  try {
    infoLog(`userId:${userId}`)
    if (window.app && window.app.gotoPrivateChat) {
      infoLog('使用gotoPrivateChat')
      // 使用注入的方法
      window.app.gotoPrivateChat(userId)
    } else if (window.FlutterPageControl) {
      // 直接使用Flutter通道
      window.FlutterPageControl.postMessage(`private_chat:${userId}`)
    }
  } catch (error) {
    errorLog('前往私聊失败:', error)
  }
}

/**
 * 查看个人页面
 */
export function viewUserInfo(userId) {
  if (!userId) return
  try {
    infoLog(`userId:${userId}`)
    if (window.app && window.app.viewUserInfo) {
      infoLog('使用viewUserInfo')
      // 使用注入的方法
      window.app.viewUserInfo(userId)
    } else if (window.FlutterPageControl) {
      // 直接使用Flutter通道
      window.FlutterPageControl.postMessage(`view_user_info:${userId}`)
    }
  } catch (error) {
    errorLog('查看个人页面失败:', error)
  }
}

/**
 * 前往房间
 */
export function gotoRoom(roomId) {
  if (!roomId) return
  try {
    infoLog(`roomId:${roomId}`)
    if (window.app && window.app.gotoRoom) {
      infoLog('使用gotoRoom')
      // 使用注入的方法
      window.app.gotoRoom(roomId)
    } else if (window.FlutterPageControl) {
      // 直接使用Flutter通道
      window.FlutterPageControl.postMessage(`go_to_room:${roomId}`)
    }
  } catch (error) {
    errorLog('前往房间失败:', error)
  }
}

/**
 * 前往app页面
 */
export function gotoAppPage(pageName) {
  if (!pageName) return
  try {
    infoLog(`pageName:${pageName}`)
    // 直接使用Flutter通道
    window.FlutterPageControl.postMessage(pageName)
  } catch (error) {
    errorLog('前往APP页面失败:', error)
  }
}

/**
 * 通知 APP 调用 VAP 播放
 */
export function notifyAppPlayVap(sourceUrl) {
  if (!sourceUrl) return
  try {
    const message = `play_vap:${sourceUrl}`
    infoLog(message)
    // 直接使用Flutter通道
    window.FlutterPageControl.postMessage(message)
  } catch (error) {
    errorLog('通知APP调用VAP失败:', error)
  }
}

/**
 * 打开app组件
 */
export function openAppComponent(componentName) {
  if (!componentName) return
  try {
    infoLog(`componentName:${componentName}`)
    // 直接使用Flutter通道
    window.FlutterPageControl.postMessage(componentName)
  } catch (error) {
    errorLog('打开APP组件失败:', error)
  }
}

/**
 * 退出APP
 */
export function exitApp() {
  try {
    if (window.app && window.app.exitApp) {
      window.app.exitApp()
    } else if (window.FlutterPageControl) {
      window.FlutterPageControl.postMessage('exit_app')
    }
  } catch (error) {
    errorLog('退出APP失败:', error)
  }
}

/**
 * 处理返回按钮逻辑
 * @param {boolean} isHomePage 是否为首页
 */
export function handleBackButton(isHomePage = false) {
  if (isHomePage) {
    // 首页返回：关闭页面
    closePage()
  } else {
    // 非首页：正常返回
    window.history.back()
  }
}

// ==================== 数据解析函数 ====================

/**
 * 解析APP传递的访问参数
 * @param {string} access JSON字符串格式的访问参数
 * @returns {Object} 解析后的参数对象
 */
export function parseAccessOrigin(access) {
  try {
    const accessParam = JSON.parse(access)
    return {
      success: true,
      data: accessParam,
    }
  } catch (error) {
    errorLog('Failed to parse access origin:', error)
    return {
      success: false,
      error: 'accessOrigin Error.',
      data: null,
    }
  }
}

/**
 * 解析键值对字符串 (如: "key1=value1;key2=value2")
 * @param {string} values
 * @returns {Object}
 */
function parseKeyValString(values) {
  const keyValBody = {}
  if (!values) return keyValBody

  const valueArray = values.split(';')
  for (let index = 0; index < valueArray.length; index++) {
    const keyVal = valueArray[index]
    if (keyVal && keyVal.includes('=')) {
      const keyValArray = keyVal.split('=')
      keyValBody[keyValArray[0]] = keyValArray[1]
    }
  }
  return keyValBody
}

/**
 * 解析请求头信息
 * @param {Object} head 请求头对象
 * @returns {Object} 解析后的头信息
 */
export function parseHeader(head) {
  if (!head) {
    return {}
  }

  const reqAppIntel = head['Req-App-Intel'] || ''
  const reqSysOrigin = head['Req-Sys-Origin'] || ''
  const reqAppIntelObj = parseKeyValString(reqAppIntel)
  const reqSysOriginObj = parseKeyValString(reqSysOrigin)

  return {
    reqLang: head['Req-Lang'],
    authorization: head['Authorization'],
    buildVersion: reqAppIntelObj['build'],
    appVersion: reqAppIntelObj['version'],
    appChannel: reqAppIntelObj['channel'],
    reqImei: reqAppIntelObj['Req-Imei'],
    sysOrigin: reqSysOriginObj['origin'],
    sysOriginChild: reqSysOriginObj['child'],
  }
}

/**
 * 设置HTTP请求的默认头部信息
 * @param {Object} headerInfo 解析后的头部信息
 */
export async function setHttpHeaders(headerInfo) {
  try {
    const httpModule = await import('../utils/http.js')
    if (httpModule.setHeadersFromApp) {
      httpModule.setHeadersFromApp(headerInfo)
    }
  } catch (error) {
    errorLog('Failed to update HTTP headers:', error)
  }

  debugLog('🔑 Authorization token set:', headerInfo.authorization)
  debugLog('🌍 Language set:', headerInfo.reqLang)
  debugLog('📱 App info:', {
    version: headerInfo.appVersion,
    build: headerInfo.buildVersion,
    channel: headerInfo.appChannel,
    system: headerInfo.sysOrigin,
  })
}
