gmTouringMiniApp/src/services/travel-assistant/storage.ts

import { getPoiRepository } from '@/data/poi'
import {
  clonePlanResponse,
  cloneTravelPreferences,
  normalizePlanResponse,
  normalizeTravelPreferences,
  type PlanResponse,
  type TravelPreferences,
} from '@/domain/travel'

export const PLAN_STORAGE_KEY = 'guangming:last-plan'
export const PREFERENCES_STORAGE_KEY = 'guangming:last-preferences'

const STORAGE_SCHEMA_VERSION = 1

interface StorageEnvelope<T> {
  schemaVersion: typeof STORAGE_SCHEMA_VERSION
  datasetVersion: string
  savedAt: string
  payload: T
}

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === 'object' && value !== null && !Array.isArray(value)
}

function createEnvelope<T>(payload: T): StorageEnvelope<T> {
  return {
    schemaVersion: STORAGE_SCHEMA_VERSION,
    datasetVersion: getPoiRepository().getDatasetMeta().datasetVersion,
    savedAt: new Date().toISOString(),
    payload,
  }
}

function readEnvelope(value: unknown): StorageEnvelope<unknown> | null {
  if (!isRecord(value) || value.schemaVersion !== STORAGE_SCHEMA_VERSION)
    return null
  if (typeof value.datasetVersion !== 'string' || !value.datasetVersion.trim())
    return null
  if (typeof value.savedAt !== 'string' || !Number.isFinite(Date.parse(value.savedAt)))
    return null
  if (!('payload' in value))
    return null
  return value as unknown as StorageEnvelope<unknown>
}

function readStorage(key: string): unknown {
  try {
    return uni.getStorageSync(key)
  }
  catch {
    return null
  }
}

function writeStorage(key: string, value: unknown): void {
  try {
    uni.setStorageSync(key, value)
  }
  catch (error) {
    const reason = error instanceof Error && error.message ? `：${error.message}` : ''
    throw new Error(`无法保存本机行程数据${reason}`)
  }
}

export function savePlan(plan: PlanResponse): void {
  const repository = getPoiRepository()
  const normalized = normalizePlanResponse(plan, repository)
  writeStorage(PLAN_STORAGE_KEY, createEnvelope(clonePlanResponse(normalized, repository)))
}

export function loadPlan(): PlanResponse | null {
  const repository = getPoiRepository()
  const envelope = readEnvelope(readStorage(PLAN_STORAGE_KEY))
  if (!envelope || envelope.datasetVersion !== repository.getDatasetMeta().datasetVersion)
    return null
  try {
    return normalizePlanResponse(envelope.payload, repository)
  }
  catch {
    return null
  }
}

export function savePreferences(preferences: TravelPreferences): void {
  const normalized = normalizeTravelPreferences(preferences)
  writeStorage(PREFERENCES_STORAGE_KEY, createEnvelope(cloneTravelPreferences(normalized)))
}

export function loadPreferences(): TravelPreferences | null {
  const envelope = readEnvelope(readStorage(PREFERENCES_STORAGE_KEY))
  if (!envelope)
    return null
  try {
    return normalizeTravelPreferences(envelope.payload)
  }
  catch {
    return null
  }
}