/**
 * 地理计算工具函数
 * 提供距离计算、坐标转换等功能
 */

/**
 * 使用 Haversine 公式计算两点之间的直线距离
 * @param {Object} point1 - 第一个点 { lon, lat }
 * @param {Object} point2 - 第二个点 { lon, lat }
 * @returns {number} 距离（公里）
 */
export function calculateDistance(point1, point2) {
  const R = 6371 // 地球半径（公里）

  const toRad = (deg) => deg * (Math.PI / 180)

  const dLat = toRad(point2.lat - point1.lat)
  const dLon = toRad(point2.lon - point1.lon)

  const a =
    Math.sin(dLat / 2) ** 2 +
    Math.cos(toRad(point1.lat)) *
    Math.cos(toRad(point2.lat)) *
    Math.sin(dLon / 2) ** 2

  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))

  return R * c
}

/**
 * 生成缓存键
 * @param {Object} origin - 起点 { lon, lat }
 * @param {Object} destination - 终点 { lon, lat }
 * @returns {string} 缓存键
 */
export function generateCacheKey(origin, destination) {
  return `${origin.lon.toFixed(6)},${origin.lat.toFixed(6)}_${destination.lon.toFixed(6)},${destination.lat.toFixed(6)}`
}

/**
 * 简化路线（减少路点数量）
 * @param {string} polyline - 高德 polyline 字符串
 * @param {number} maxPoints - 最大路点数
 * @returns {string} 简化后的 polyline
 */
export function simplifyRoute(polyline, maxPoints = 50) {
  const points = polyline.split(';')

  if (points.length <= maxPoints) {
    return polyline
  }

  const step = Math.ceil(points.length / maxPoints)
  const simplified = points.filter((_, index) => index % step === 0)

  // 确保保留终点
  if (simplified[simplified.length - 1] !== points[points.length - 1]) {
    simplified.push(points[points.length - 1])
  }

  return simplified.join(';')
}

/**
 * 验证坐标是否有效
 * @param {Object} point - 坐标点 { lon, lat }
 * @returns {boolean} 是否有效
 */
export function isValidCoordinate(point) {
  if (!point || typeof point.lon !== 'number' || typeof point.lat !== 'number') {
    return false
  }

  // 中国境内经纬度范围
  const isLonValid = point.lon >= 73 && point.lon <= 135
  const isLatValid = point.lat >= 3 && point.lat <= 54

  return isLonValid && isLatValid
}

/**
 * 格式化距离显示
 * @param {number} meters - 距离（米）
 * @returns {string} 格式化后的距离字符串
 */
export function formatDistance(meters) {
  if (meters < 1000) {
    return `${Math.round(meters)}米`
  }
  return `${(meters / 1000).toFixed(1)}公里`
}

/**
 * 格式化时间显示
 * @param {number} seconds - 时间（秒）
 * @returns {string} 格式化后的时间字符串
 */
export function formatDuration(seconds) {
  const minutes = Math.ceil(seconds / 60)

  if (minutes < 60) {
    return `${minutes}分钟`
  }

  const hours = Math.floor(minutes / 60)
  const remainingMinutes = minutes % 60

  if (remainingMinutes === 0) {
    return `${hours}小时`
  }

  return `${hours}小时${remainingMinutes}分钟`
}

/**
 * Generate random offset in degrees for 10-30m distance
 * @param {number} minMeters - Minimum distance in meters (default: 10)
 * @param {number} maxMeters - Maximum distance in meters (default: 30)
 * @returns {Object} { lonOffset, latOffset }
 */
export function generateRandomOffset(minMeters = 10, maxMeters = 30) {
  // 1 degree latitude ≈ 111km
  // At 30° latitude, 1 degree longitude ≈ 96km
  const LAT_METERS_PER_DEGREE = 111000
  const LON_METERS_PER_DEGREE = 96000 // Approximate for China region

  // Random distance between min and max
  const distance = minMeters + Math.random() * (maxMeters - minMeters)

  // Random angle (0-360 degrees)
  const angle = Math.random() * 2 * Math.PI

  // Calculate offsets
  const latOffset = (distance * Math.cos(angle)) / LAT_METERS_PER_DEGREE
  const lonOffset = (distance * Math.sin(angle)) / LON_METERS_PER_DEGREE

  return { lonOffset, latOffset }
}

/**
 * Apply random offset to coordinates
 * @param {Object} coords - { lon, lat }
 * @param {number} minMeters - Min distance (default: 10)
 * @param {number} maxMeters - Max distance (default: 30)
 * @returns {Object} { lon, lat }
 */
export function applyRandomOffset(coords, minMeters = 10, maxMeters = 30) {
  const { lonOffset, latOffset } = generateRandomOffset(minMeters, maxMeters)
  return {
    lon: coords.lon + lonOffset,
    lat: coords.lat + latOffset
  }
}
