kiku-agent 1.3.2 → 1.3.3

package/server/agent/locationService.js

@@ -0,0 +1,797 @@
+const OSM_CACHE = new Map();
+const CACHE_TTL_MS = 600_000;
+const EARTH_RADIUS_METERS = 6371000;
+const USER_AGENT_HEADER = 'KikuAgent-LocationService/1.4 (https://github.com/Themehackers/jujingyi_kikuuu)';
+
+export function calculateHaversineDistance(lat1, lon1, lat2, lon2) {
+  const p1 = Number(lat1) * Math.PI / 180;
+  const p2 = Number(lat2) * Math.PI / 180;
+  const deltaP = (Number(lat2) - Number(lat1)) * Math.PI / 180;
+  const deltaL = (Number(lon2) - Number(lon1)) * Math.PI / 180;
+
+  const a = Math.sin(deltaP / 2) * Math.sin(deltaP / 2) +
+            Math.cos(p1) * Math.cos(p2) *
+            Math.sin(deltaL / 2) * Math.sin(deltaL / 2);
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+
+  return EARTH_RADIUS_METERS * c;
+}
+
+export function estimateWalkingTime(meters) {
+  return Math.max(1, Math.ceil(meters / 80));
+}
+
+export function estimateDrivingTime(meters) {
+  return Math.max(1, Math.ceil(meters / 667));
+}
+
+export function formatDistance(meters) {
+  if (meters < 1000) {
+    return `${Math.round(meters)} m`;
+  }
+  return `${(meters / 1000).toFixed(1)} km`;
+}
+
+export const LANDMARK_REGISTRY = Object.freeze([
+  {
+    id: 'democracy_monument',
+    nameTh: 'อนุสาวรีย์ประชาธิปไตย',
+    nameEn: 'Democracy Monument',
+    nameZh: '民主纪念碑',
+    latitude: 13.7567,
+    longitude: 100.5018,
+    category: 'monument',
+    city: 'Bangkok',
+    country: 'Thailand'
+  },
+  {
+    id: 'siam_paragon',
+    nameTh: 'สยามพารากอน',
+    nameEn: 'Siam Paragon',
+    nameZh: '暹罗百丽宫',
+    latitude: 13.7460,
+    longitude: 100.5348,
+    category: 'shopping',
+    city: 'Bangkok',
+    country: 'Thailand'
+  },
+  {
+    id: 'central_world',
+    nameTh: 'เซ็นทรัลเวิลด์',
+    nameEn: 'CentralWorld',
+    nameZh: '尚泰中央世界',
+    latitude: 13.7466,
+    longitude: 100.5393,
+    category: 'shopping',
+    city: 'Bangkok',
+    country: 'Thailand'
+  },
+  {
+    id: 'grand_palace',
+    nameTh: 'พระบรมมหาราชวัง / วัดพระแก้ว',
+    nameEn: 'Grand Palace / Temple of the Emerald Buddha',
+    nameZh: '大皇宫 / 玉佛寺',
+    latitude: 13.7500,
+    longitude: 100.4914,
+    category: 'temple',
+    city: 'Bangkok',
+    country: 'Thailand'
+  },
+  {
+    id: 'iconsiam',
+    nameTh: 'ไอคอนสยาม',
+    nameEn: 'ICONSIAM',
+    nameZh: '暹罗天地',
+    latitude: 13.7267,
+    longitude: 100.5105,
+    category: 'shopping',
+    city: 'Bangkok',
+    country: 'Thailand'
+  },
+  {
+    id: 'suvarnabhumi',
+    nameTh: 'ท่าอากาศยานสุวรรณภูมิ',
+    nameEn: 'Suvarnabhumi Airport',
+    nameZh: '素万那普国际机场',
+    latitude: 13.6900,
+    longitude: 100.7501,
+    category: 'airport',
+    city: 'Samut Prakan',
+    country: 'Thailand'
+  },
+  {
+    id: 'don_mueang',
+    nameTh: 'ท่าอากาศยานดอนเมือง',
+    nameEn: 'Don Mueang International Airport',
+    nameZh: '廊曼国际机场',
+    latitude: 13.9126,
+    longitude: 100.6067,
+    category: 'airport',
+    city: 'Bangkok',
+    country: 'Thailand'
+  },
+  {
+    id: 'chiang_mai_gate',
+    nameTh: 'ประตูท่าแพ เชียงใหม่',
+    nameEn: 'Tha Phae Gate Chiang Mai',
+    nameZh: '清迈塔佩门',
+    latitude: 18.7877,
+    longitude: 98.9931,
+    category: 'historic',
+    city: 'Chiang Mai',
+    country: 'Thailand'
+  },
+  {
+    id: 'phuket_old_town',
+    nameTh: 'ย่านเมืองเก่าภูเก็ต',
+    nameEn: 'Phuket Old Town',
+    nameZh: '普吉老街',
+    latitude: 7.8840,
+    longitude: 98.3887,
+    category: 'historic',
+    city: 'Phuket',
+    country: 'Thailand'
+  },
+  {
+    id: 'pattaya_beach',
+    nameTh: 'หาดพัทยา',
+    nameEn: 'Pattaya Beach',
+    nameZh: '芭提雅海滩',
+    latitude: 12.9354,
+    longitude: 100.8809,
+    category: 'beach',
+    city: 'Pattaya',
+    country: 'Thailand'
+  },
+  {
+    id: 'khon_kaen_city',
+    nameTh: 'บึงแก่นนคร ขอนแก่น',
+    nameEn: 'Kaen Nakhon Lake Khon Kaen',
+    nameZh: '孔敬孔敬湖',
+    latitude: 16.4172,
+    longitude: 102.8358,
+    category: 'lake',
+    city: 'Khon Kaen',
+    country: 'Thailand'
+  },
+  {
+    id: 'hengdian_studios',
+    nameTh: 'โรงถ่ายภาพยนตร์เหิงเตี้ยน',
+    nameEn: 'Hengdian World Studios',
+    nameZh: '横店影视城',
+    latitude: 29.1454,
+    longitude: 120.3104,
+    category: 'studio',
+    city: 'Jinhua',
+    province: 'Zhejiang',
+    country: 'China'
+  },
+  {
+    id: 'shanghai_mercedes',
+    nameTh: 'เมอร์เซเดส-เบนซ์ อารีน่า เซี่ยงไฮ้',
+    nameEn: 'Mercedes-Benz Arena Shanghai',
+    nameZh: '梅赛德斯-奔驰文化中心',
+    latitude: 31.1895,
+    longitude: 121.4938,
+    category: 'arena',
+    city: 'Shanghai',
+    country: 'China'
+  },
+  {
+    id: 'shanghai_grand_theatre',
+    nameTh: 'เซี่ยงไฮ้ แกรนด์ เธียเตอร์',
+    nameEn: 'Shanghai Grand Theatre',
+    nameZh: '上海大剧院',
+    latitude: 31.2312,
+    longitude: 121.4704,
+    category: 'theatre',
+    city: 'Shanghai',
+    country: 'China'
+  },
+  {
+    id: 'shanghai_hongqiao',
+    nameTh: 'ท่าอากาศยานนานาชาติเซี่ยงไฮ้ หงเฉียว',
+    nameEn: 'Shanghai Hongqiao International Airport',
+    nameZh: '上海虹桥国际机场',
+    latitude: 31.1979,
+    longitude: 121.3363,
+    category: 'airport',
+    city: 'Shanghai',
+    country: 'China'
+  },
+  {
+    id: 'beijing_forbidden_city',
+    nameTh: 'พระราชวังต้องห้าม ปักกิ่ง',
+    nameEn: 'Forbidden City Beijing',
+    nameZh: '故宫博物院',
+    latitude: 39.9163,
+    longitude: 116.3972,
+    category: 'historic',
+    city: 'Beijing',
+    country: 'China'
+  },
+  {
+    id: 'beijing_capital_airport',
+    nameTh: 'ท่าอากาศยานนานาชาติปักกิ่ง',
+    nameEn: 'Beijing Capital International Airport',
+    nameZh: '北京首都国际机场',
+    latitude: 40.0799,
+    longitude: 116.6031,
+    category: 'airport',
+    city: 'Beijing',
+    country: 'China'
+  },
+  {
+    id: 'chengdu_chunxi',
+    nameTh: 'ถนนคนเดินชุนซีลู่ เฉิงตู',
+    nameEn: 'Chunxi Road Chengdu',
+    nameZh: '成都春熙路',
+    latitude: 30.6558,
+    longitude: 104.0818,
+    category: 'shopping',
+    city: 'Chengdu',
+    country: 'China'
+  },
+  {
+    id: 'suining_city',
+    nameTh: 'ซุ่ยหนิง เสฉวน (บ้านเกิดจวีจิ้งอี)',
+    nameEn: 'Suining Sichuan (Ju Jingyi Birthplace)',
+    nameZh: '四川遂宁 (鞠婧祎出生地)',
+    latitude: 30.5328,
+    longitude: 105.5929,
+    category: 'city',
+    city: 'Suining',
+    country: 'China'
+  }
+]);
+
+export const CATEGORY_PROMINENCE_WEIGHTS = Object.freeze({
+  studio: 1.35,
+  transport: 1.25,
+  theatre: 1.20,
+  arena: 1.20,
+  monument: 1.15,
+  temple: 1.15,
+  shopping: 1.05,
+  park: 1.0,
+  city: 1.10,
+  other: 0.95
+});
+
+export function scoreLandmarkCandidate(landmark, lat, lon, context = {}) {
+  const dist = calculateHaversineDistance(lat, lon, landmark.latitude, landmark.longitude);
+  const distanceScore = 100 / (1 + (dist / 1500));
+  const categoryWeight = CATEGORY_PROMINENCE_WEIGHTS[landmark.category] || 1.0;
+  const prominenceScore = 80 * categoryWeight;
+
+  let contextScore = 0;
+  const queryText = String(context.query || '').toLowerCase().trim();
+  if (queryText) {
+    const targetTh = String(landmark.nameTh || '').toLowerCase();
+    const targetEn = String(landmark.nameEn || '').toLowerCase();
+    const targetZh = String(landmark.nameZh || '').toLowerCase();
+    if (targetTh.includes(queryText) || targetEn.includes(queryText) || targetZh.includes(queryText)) {
+      contextScore += 50;
+    }
+  }
+
+  let geographicMatchScore = 0;
+  if (context.city && landmark.city && String(context.city).toLowerCase() === String(landmark.city).toLowerCase()) {
+    geographicMatchScore += 25;
+  }
+  if (context.country && landmark.country && String(context.country).toLowerCase() === String(landmark.country).toLowerCase()) {
+    geographicMatchScore += 15;
+  }
+
+  const finalScore = Number((distanceScore * 0.55 + prominenceScore * 0.20 + contextScore * 0.15 + geographicMatchScore * 0.10).toFixed(2));
+
+  return {
+    landmark,
+    distanceMeters: Math.round(dist),
+    distanceScore: Number(distanceScore.toFixed(2)),
+    prominenceScore: Number(prominenceScore.toFixed(2)),
+    contextScore,
+    geographicMatchScore,
+    finalScore
+  };
+}
+
+export function rankLandmarksByScore(lat, lon, context = {}) {
+  if (!Number.isFinite(Number(lat)) || !Number.isFinite(Number(lon))) {
+    return [];
+  }
+  const scored = LANDMARK_REGISTRY.map(lm => scoreLandmarkCandidate(lm, lat, lon, context));
+  scored.sort((a, b) => b.finalScore - a.finalScore || a.distanceMeters - b.distanceMeters);
+  return scored;
+}
+
+export function findNearestLandmark(lat, lon, context = {}) {
+  const ranked = rankLandmarksByScore(lat, lon, context);
+  if (ranked.length === 0) return null;
+
+  const top = ranked[0];
+  const minDistance = top.distanceMeters;
+  const walkingMinutes = estimateWalkingTime(minDistance);
+  const drivingMinutes = estimateDrivingTime(minDistance);
+
+  return {
+    landmark: top.landmark,
+    score: top.finalScore,
+    distanceMeters: minDistance,
+    distanceKm: Number((minDistance / 1000).toFixed(2)),
+    formattedDistance: formatDistance(minDistance),
+    walkingMinutes,
+    drivingMinutes,
+    rankedCandidates: ranked.slice(0, 3).map(r => ({
+      id: r.landmark.id,
+      name: r.landmark.nameTh,
+      distance: formatDistance(r.distanceMeters),
+      score: r.finalScore
+    })),
+    summaryTh: `ใกล้${top.landmark.nameTh} (${formatDistance(minDistance)})`,
+    summaryEn: `Near ${top.landmark.nameEn} (${formatDistance(minDistance)})`,
+    summaryZh: `靠近${top.landmark.nameZh} (${formatDistance(minDistance)})`
+  };
+}
+
+export function buildOsmMapTag(lat, lon, name = 'Location') {
+  const safeLat = Number(lat).toFixed(4);
+  const safeLon = Number(lon).toFixed(4);
+  const safeName = String(name || 'Location').replace(/[\[\],]/g, ' ').trim();
+  return `[MAP_OSM:${safeLat},${safeLon},${safeName}]`;
+}
+
+export function buildOsmUrl(lat, lon, zoom = 16) {
+  const safeLat = Number(lat).toFixed(4);
+  const safeLon = Number(lon).toFixed(4);
+  return `https://www.openstreetmap.org/?mlat=${safeLat}&mlon=${safeLon}#map=${zoom}/${safeLat}/${safeLon}`;
+}
+
+export async function reverseGeocodeOsm(lat, lon, options = {}) {
+  const numLat = Number(lat);
+  const numLon = Number(lon);
+  if (!Number.isFinite(numLat) || !Number.isFinite(numLon)) {
+    return null;
+  }
+
+  const cacheKey = `rev:${numLat.toFixed(4)},${numLon.toFixed(4)}`;
+  const now = Date.now();
+  const cached = OSM_CACHE.get(cacheKey);
+  if (cached && now - cached.timestamp < CACHE_TTL_MS) {
+    return cached.data;
+  }
+
+  const timeoutMs = Number(options.timeoutMs) > 0 ? Number(options.timeoutMs) : 3500;
+  const queryUrl = new URL('https://nominatim.openstreetmap.org/reverse');
+  queryUrl.searchParams.set('lat', String(numLat));
+  queryUrl.searchParams.set('lon', String(numLon));
+  queryUrl.searchParams.set('format', 'json');
+  queryUrl.searchParams.set('addressdetails', '1');
+
+  try {
+    const res = await fetch(queryUrl.toString(), {
+      headers: {
+        'User-Agent': USER_AGENT_HEADER,
+        'Accept-Language': 'th-TH,th;q=0.9,zh-CN;q=0.8,en;q=0.7'
+      },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+
+    if (!res.ok) {
+      return null;
+    }
+
+    const data = await res.json().catch(() => null);
+    if (!data || !data.address) {
+      return null;
+    }
+
+    const addr = data.address || {};
+    const subdistrict = addr.quarter || addr.subdistrict || addr.neighbourhood || addr.village || '';
+    const district = addr.suburb || addr.district || addr.city_district || addr.county || '';
+    const city = addr.city || addr.town || addr.municipality || district;
+    const province = addr.state || addr.province || addr['ISO3166-2-lvl4'] || city;
+    const postcode = addr.postcode || '';
+    const country = addr.country || '';
+    const countryCode = (addr.country_code || '').toUpperCase();
+    const road = addr.road || '';
+    const displayName = data.display_name || '';
+
+    const resolved = {
+      displayName,
+      road,
+      subdistrict,
+      district,
+      city,
+      province,
+      postcode,
+      country,
+      countryCode,
+      latitude: numLat,
+      longitude: numLon,
+      mapUrl: buildOsmUrl(numLat, numLon),
+      mapTag: buildOsmMapTag(numLat, numLon, district || city || 'Location')
+    };
+
+    OSM_CACHE.set(cacheKey, { data: resolved, timestamp: now });
+    if (OSM_CACHE.size > 200) {
+      const firstKey = OSM_CACHE.keys().next().value;
+      OSM_CACHE.delete(firstKey);
+    }
+
+    return resolved;
+  } catch {
+    return null;
+  }
+}
+
+export function cleanLocationQuery(rawQuery) {
+  if (!rawQuery || typeof rawQuery !== 'string') return '';
+  return rawQuery
+    .replace(/(แผนที่ของ|แผนที่|ขอแผนที่|พิกัดของ|พิกัด|นำทางไป|นำทาง|ทางไป|อยู่ตรงไหน|อยู่ที่ไหน|ตรงไหน|แถว|พาไป|หา|ขอดู|เปิดแมพ|แมพ|\bmap of\b|\bmap\b|\bwhere is\b|\bhow to go to\b|\bnavigate to\b|\bdirections to\b|\bcoordinates of\b|\bcoords\b)/gi, '')
+    .trim();
+}
+
+export async function searchLocationOsm(query, options = {}) {
+  const cleaned = cleanLocationQuery(query);
+  const targetQuery = cleaned || query;
+  if (!targetQuery || !targetQuery.trim()) {
+    return [];
+  }
+
+  const cacheKey = `search:${targetQuery.toLowerCase().trim()}`;
+  const now = Date.now();
+  const cached = OSM_CACHE.get(cacheKey);
+  if (cached && now - cached.timestamp < CACHE_TTL_MS) {
+    return cached.data;
+  }
+
+  const timeoutMs = Number(options.timeoutMs) > 0 ? Number(options.timeoutMs) : 4000;
+  const limit = Math.min(Math.max(1, Number(options.limit || 5)), 10);
+  const cleanQ = targetQuery.toLowerCase().trim();
+
+  const matchedLandmarks = [];
+  for (const lm of LANDMARK_REGISTRY) {
+    const th = String(lm.nameTh || '').toLowerCase();
+    const en = String(lm.nameEn || '').toLowerCase();
+    const zh = String(lm.nameZh || '').toLowerCase();
+    if (th.includes(cleanQ) || en.includes(cleanQ) || zh.includes(cleanQ) || (cleanQ.length > 3 && (th.includes(cleanQ.slice(0, 4)) || en.includes(cleanQ.slice(0, 4))))) {
+      matchedLandmarks.push({
+        name: lm.nameTh,
+        displayName: `${lm.nameTh} (${lm.nameEn}), ${lm.city}, ${lm.country}`,
+        latitude: lm.latitude,
+        longitude: lm.longitude,
+        type: lm.category || 'landmark',
+        category: 'landmark',
+        importance: 0.98,
+        road: '',
+        subdistrict: '',
+        district: '',
+        city: lm.city,
+        province: lm.city,
+        country: lm.country,
+        postcode: '',
+        mapUrl: buildOsmUrl(lm.latitude, lm.longitude),
+        mapTag: buildOsmMapTag(lm.latitude, lm.longitude, lm.nameTh)
+      });
+    }
+  }
+
+  const queryUrl = new URL('https://nominatim.openstreetmap.org/search');
+  queryUrl.searchParams.set('q', targetQuery.trim());
+  queryUrl.searchParams.set('format', 'json');
+  queryUrl.searchParams.set('limit', String(limit));
+  queryUrl.searchParams.set('addressdetails', '1');
+
+  try {
+    const res = await fetch(queryUrl.toString(), {
+      headers: {
+        'User-Agent': USER_AGENT_HEADER,
+        'Accept-Language': 'th-TH,th;q=0.9,zh-CN;q=0.8,en;q=0.7'
+      },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+
+    let osmResults = [];
+    if (res.ok) {
+      const data = await res.json().catch(() => null);
+      if (Array.isArray(data)) {
+        osmResults = data.map((item) => {
+          const lat = parseFloat(item.lat);
+          const lon = parseFloat(item.lon);
+          const addr = item.address || {};
+          const primaryName = (item.display_name || '').split(',')[0].trim();
+
+          return {
+            name: primaryName,
+            displayName: item.display_name || '',
+            latitude: lat,
+            longitude: lon,
+            type: item.type || '',
+            category: item.class || '',
+            importance: Number(item.importance || 0),
+            road: addr.road || '',
+            subdistrict: addr.quarter || addr.subdistrict || addr.neighbourhood || '',
+            district: addr.suburb || addr.district || addr.county || '',
+            city: addr.city || addr.town || '',
+            province: addr.state || addr.province || '',
+            country: addr.country || '',
+            postcode: addr.postcode || '',
+            mapUrl: buildOsmUrl(lat, lon),
+            mapTag: buildOsmMapTag(lat, lon, primaryName)
+          };
+        });
+      }
+    }
+
+    const combined = [...matchedLandmarks];
+    for (const osm of osmResults) {
+      const isDuplicate = combined.some(existing =>
+        calculateHaversineDistance(existing.latitude, existing.longitude, osm.latitude, osm.longitude) < 200
+      );
+      if (!isDuplicate) {
+        combined.push(osm);
+      }
+    }
+
+    const rankedResults = rankLocationSearchResults(combined, targetQuery);
+
+    OSM_CACHE.set(cacheKey, { data: rankedResults, timestamp: now });
+    if (OSM_CACHE.size > 200) {
+      const firstKey = OSM_CACHE.keys().next().value;
+      OSM_CACHE.delete(firstKey);
+    }
+
+    return rankedResults;
+  } catch {
+    if (matchedLandmarks.length > 0) {
+      return rankLocationSearchResults(matchedLandmarks, targetQuery);
+    }
+    return [];
+  }
+}
+
+export function scoreLocationSearchResult(item, query = '') {
+  let score = 0;
+  const cleanQ = String(query).toLowerCase().trim();
+  const displayName = String(item.displayName || '').toLowerCase();
+  const primaryName = String(item.name || '').toLowerCase();
+
+  if (cleanQ) {
+    if (primaryName === cleanQ) {
+      score += 50;
+    } else if (primaryName.startsWith(cleanQ) || primaryName.includes(cleanQ)) {
+      score += 35;
+    } else if (displayName.includes(cleanQ)) {
+      score += 20;
+    }
+  }
+
+  const importance = Number(item.importance || 0);
+  score += Math.min(30, Math.max(0, importance * 35));
+
+  if (item.city) score += 8;
+  if (item.district) score += 6;
+  if (item.province) score += 6;
+  if (item.postcode) score += 4;
+
+  const type = String(item.type || '').toLowerCase();
+  const category = String(item.category || '').toLowerCase();
+  if (['city', 'administrative', 'town', 'municipality'].includes(type)) score += 15;
+  else if (['tourism', 'historic', 'amenity', 'landmark'].includes(category)) score += 12;
+  else if (['suburb', 'quarter', 'neighbourhood'].includes(type)) score += 8;
+  else if (['highway', 'road'].includes(category)) score += 4;
+
+  return Number(score.toFixed(2));
+}
+
+export function rankLocationSearchResults(results, query = '') {
+  if (!Array.isArray(results) || results.length === 0) return [];
+  const scored = results.map(item => ({
+    ...item,
+    relevanceScore: scoreLocationSearchResult(item, query)
+  }));
+  scored.sort((a, b) => b.relevanceScore - a.relevanceScore);
+  return scored;
+}
+
+export function scoreLocationConfidence(locationData = {}) {
+  let score = 0;
+  const source = locationData.source || '';
+  if (source === 'explicit_coordinates') score = 100;
+  else if (source === 'client_location') score = 95;
+  else if (source === 'osm_query_search') score = 88;
+  else if (source === 'ip_lookup') score = 75;
+  else if (source === 'system_timezone_estimate') score = 55;
+  else if (source === 'client_denied') score = 10;
+  else score = 40;
+
+  if (locationData.accuracy && typeof locationData.accuracy === 'number') {
+    if (locationData.accuracy <= 50) score = Math.min(100, score + 5);
+    else if (locationData.accuracy > 5000) score = Math.max(20, score - 15);
+  }
+
+  return {
+    score,
+    confidenceTier: score >= 90 ? 'high' : (score >= 65 ? 'medium' : 'low'),
+    isEstimated: score < 90
+  };
+}
+
+const WEATHER_CACHE = new Map();
+const WEATHER_CACHE_TTL_MS = 300_000;
+const IP_LOC_CACHE = new Map();
+const IP_LOC_CACHE_TTL_MS = 1_800_000;
+
+export const WMO_WEATHER_TABLE = Object.freeze({
+  0: { th: 'ท้องฟ้าแจ่มใส', en: 'Clear sky' },
+  1: { th: 'ท้องฟ้าโปร่งเกือบหมด', en: 'Mainly clear' },
+  2: { th: 'มีเมฆบางส่วน', en: 'Partly cloudy' },
+  3: { th: 'มีเมฆมาก', en: 'Overcast' },
+  45: { th: 'มีหมอก', en: 'Fog' },
+  48: { th: 'มีหมอกน้ำค้างแข็ง', en: 'Depositing rime fog' },
+  51: { th: 'ฝนละอองเบาบาง', en: 'Light drizzle' },
+  53: { th: 'ฝนละอองปานกลาง', en: 'Moderate drizzle' },
+  55: { th: 'ฝนละอองหนาแน่น', en: 'Dense drizzle' },
+  56: { th: 'ฝนละอองเยือกแข็งเบาบาง', en: 'Light freezing drizzle' },
+  57: { th: 'ฝนละอองเยือกแข็งหนาแน่น', en: 'Dense freezing drizzle' },
+  61: { th: 'ฝนตกเล็กน้อย', en: 'Slight rain' },
+  63: { th: 'ฝนตกปานกลาง', en: 'Moderate rain' },
+  65: { th: 'ฝนตกหนัก', en: 'Heavy rain' },
+  66: { th: 'ฝนเยือกแข็งเบาบาง', en: 'Light freezing rain' },
+  67: { th: 'ฝนเยือกแข็งหนัก', en: 'Heavy freezing rain' },
+  71: { th: 'หิมะตกเล็กน้อย', en: 'Slight snow fall' },
+  73: { th: 'หิมะตกปานกลาง', en: 'Moderate snow fall' },
+  75: { th: 'หิมะตกหนัก', en: 'Heavy snow fall' },
+  77: { th: 'ลูกเห็บเม็ดเล็ก', en: 'Snow grains' },
+  80: { th: 'ฝนซู่เล็กน้อย', en: 'Slight rain showers' },
+  81: { th: 'ฝนซู่ปานกลาง', en: 'Moderate rain showers' },
+  82: { th: 'ฝนซู่รุนแรง', en: 'Violent rain showers' },
+  85: { th: 'หิมะโปรยเบาบาง', en: 'Slight snow showers' },
+  86: { th: 'หิมะโปรยหนัก', en: 'Heavy snow showers' },
+  95: { th: 'พายุฝนฟ้าคะนอง', en: 'Thunderstorm' },
+  96: { th: 'พายุฝนฟ้าคะนองพร้อมลูกเห็บเล็กน้อย', en: 'Thunderstorm with slight hail' },
+  99: { th: 'พายุฝนฟ้าคะนองพร้อมลูกเห็บหนัก', en: 'Thunderstorm with heavy hail' }
+});
+
+export async function detectIpLocation(options = {}) {
+  const cached = IP_LOC_CACHE.get('client_ip_location');
+  if (cached && (Date.now() - cached.timestamp) < IP_LOC_CACHE_TTL_MS) {
+    return cached.data;
+  }
+
+  const timeoutMs = options.timeoutMs || 2500;
+  let detected = null;
+
+  try {
+    const res = await fetch('http://ip-api.com/json/?fields=status,country,regionName,city,lat,lon,timezone', {
+      headers: { 'User-Agent': USER_AGENT_HEADER },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (res.ok) {
+      const data = await res.json().catch(() => null);
+      if (data && data.status === 'success' && typeof data.lat === 'number' && typeof data.lon === 'number') {
+        detected = {
+          latitude: data.lat,
+          longitude: data.lon,
+          city: data.city || 'Bangkok',
+          region: data.regionName || data.city || 'Bangkok',
+          country: data.country || 'Thailand',
+          timezone: data.timezone || 'Asia/Bangkok',
+          source: 'ip_lookup',
+          isEstimated: true
+        };
+      }
+    }
+  } catch {}
+
+  if (!detected) {
+    let defaultTz = 'Asia/Bangkok';
+    try {
+      defaultTz = Intl.DateTimeFormat().resolvedOptions().timeZone || 'Asia/Bangkok';
+    } catch {}
+
+    const tzProfiles = {
+      'Asia/Bangkok': { city: 'Bangkok', region: 'Bangkok', country: 'Thailand', lat: 13.7563, lon: 100.5018 },
+      'Asia/Shanghai': { city: 'Shanghai', region: 'Shanghai', country: 'China', lat: 31.2304, lon: 121.4737 },
+      'Asia/Tokyo': { city: 'Tokyo', region: 'Kanto', country: 'Japan', lat: 35.6762, lon: 139.6503 },
+      'Asia/Seoul': { city: 'Seoul', region: 'Seoul', country: 'South Korea', lat: 37.5665, lon: 126.9780 },
+      'Asia/Singapore': { city: 'Singapore', region: 'Singapore', country: 'Singapore', lat: 1.3521, lon: 103.8198 },
+      'Europe/London': { city: 'London', region: 'England', country: 'United Kingdom', lat: 51.5074, lon: -0.1278 },
+      'America/New_York': { city: 'New York', region: 'New York', country: 'United States', lat: 40.7128, lon: -74.0060 },
+      'America/Los_Angeles': { city: 'Los Angeles', region: 'California', country: 'United States', lat: 34.0522, lon: -118.2437 }
+    };
+
+    const profile = tzProfiles[defaultTz] || {
+      city: 'Bangkok',
+      region: 'Bangkok',
+      country: 'Thailand',
+      lat: 13.7563,
+      lon: 100.5018
+    };
+
+    detected = {
+      latitude: profile.lat,
+      longitude: profile.lon,
+      city: profile.city,
+      region: profile.region,
+      country: profile.country,
+      timezone: defaultTz,
+      source: 'system_timezone_estimate',
+      isEstimated: true
+    };
+  }
+
+  IP_LOC_CACHE.set('client_ip_location', { data: detected, timestamp: Date.now() });
+  return detected;
+}
+
+export async function fetchRealtimeWeather(lat, lon, options = {}) {
+  const latitude = Number(Number(lat).toFixed(4));
+  const longitude = Number(Number(lon).toFixed(4));
+  const cacheKey = `${latitude},${longitude}`;
+  const now = Date.now();
+
+  const cached = WEATHER_CACHE.get(cacheKey);
+  if (cached && (now - cached.timestamp) < WEATHER_CACHE_TTL_MS) {
+    return cached.data;
+  }
+
+  const timeoutMs = options.timeoutMs || 4000;
+  const url = `https://api.open-meteo.com/v1/forecast?latitude=${latitude}&longitude=${longitude}&current=temperature_2m,relative_humidity_2m,apparent_temperature,precipitation,weather_code,wind_speed_10m&timezone=auto`;
+
+  try {
+    const res = await fetch(url, {
+      headers: { 'User-Agent': USER_AGENT_HEADER },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+
+    if (!res.ok) {
+      return null;
+    }
+
+    const data = await res.json().catch(() => null);
+    if (!data || !data.current) {
+      return null;
+    }
+
+    const cur = data.current;
+    const code = Number(cur.weather_code ?? 0);
+    const condition = WMO_WEATHER_TABLE[code] || { th: 'สภาพอากาศปกติ', en: 'Fair' };
+    const temp = Number(cur.temperature_2m ?? 0);
+    const apparent = Number(cur.apparent_temperature ?? temp);
+    const humidity = Number(cur.relative_humidity_2m ?? 0);
+    const precip = Number(cur.precipitation ?? 0);
+    const wind = Number(cur.wind_speed_10m ?? 0);
+
+    const summaryTh = `สภาพอากาศ: ${condition.th}, อุณหภูมิ ${temp}°C (รู้สึกเหมือน ${apparent}°C), ความชื้นสัมพัทธ์ ${humidity}%, ลม ${wind} กม./ชม.${precip > 0 ? `, ปริมาณฝน ${precip} มม.` : ''}`;
+    const summaryEn = `Weather: ${condition.en}, Temperature ${temp}°C (Feels like ${apparent}°C), Humidity ${humidity}%, Wind ${wind} km/h${precip > 0 ? `, Precipitation ${precip} mm` : ''}`;
+
+    const result = {
+      status: 'success',
+      latitude,
+      longitude,
+      timezone: data.timezone || 'Asia/Bangkok',
+      temperature: temp,
+      apparentTemperature: apparent,
+      humidity,
+      precipitation: precip,
+      windSpeed: wind,
+      weatherCode: code,
+      conditionTh: condition.th,
+      conditionEn: condition.en,
+      summaryTh,
+      summaryEn
+    };
+
+    WEATHER_CACHE.set(cacheKey, { data: result, timestamp: now });
+    if (WEATHER_CACHE.size > 200) {
+      const firstKey = WEATHER_CACHE.keys().next().value;
+      WEATHER_CACHE.delete(firstKey);
+    }
+
+    return result;
+  } catch {
+    return null;
+  }
+}