import { Measurement } from '../types'
import { initDatabase, getAllMeasurements, getLatestMeasurements, getMeasurementsSince } from '../database/db'

let cachedMeasurements: Measurement[] = []
let initialized = false

export async function loadFromDb(): Promise<Measurement[]> {
  await initDatabase()
  cachedMeasurements = await getAllMeasurements()
  initialized = true
  return cachedMeasurements
}

export async function loadLatest(count: number): Promise<Measurement[]> {
  await initDatabase()
  const latest = await getLatestMeasurements(count)
  cachedMeasurements = latest
  initialized = true
  return latest
}

export async function loadSince(date: string): Promise<Measurement[]> {
  await initDatabase()
  const since = await getMeasurementsSince(date)
  // Merge with existing cache (keep newer measurements)
  const existingIds = new Set(cachedMeasurements.map(m => m.id))
  const newOnes = since.filter(m => !existingIds.has(m.id))
  cachedMeasurements = [...cachedMeasurements, ...newOnes]
  cachedMeasurements.sort((a, b) => new Date(b.measuredAt).getTime() - new Date(a.measuredAt).getTime())
  return cachedMeasurements
}

export function getCached(): Measurement[] {
  return cachedMeasurements
}

export function updateCache(m: Measurement): void {
  const idx = cachedMeasurements.findIndex(x => x.id === m.id)
  if (idx >= 0) {
    cachedMeasurements[idx] = m
  } else {
    cachedMeasurements.unshift(m)
  }
  // Re-sort by measuredAt descending
  cachedMeasurements.sort((a, b) => new Date(b.measuredAt).getTime() - new Date(a.measuredAt).getTime())
}

export function removeFromCache(id: string): void {
  cachedMeasurements = cachedMeasurements.filter(m => m.id !== id)
}

export async function refreshCache(): Promise<Measurement[]> {
  await loadFromDb()
  return cachedMeasurements
}

export function isInitialized(): boolean {
  return initialized
}