import { TieredStore, StorageTier } from '@db4/storage'

const store = new TieredStore({
  hot: {
    type: 'memory',
    maxSize: 50 * 1024 * 1024, // 50MB
  },
  warm: {
    type: 'cache',
    cache: caches.default,
    ttl: 3600,
    staleWhileRevalidate: 300,
  },
  cold: {
    type: 'r2',
    bucket: env.R2_BUCKET,
    prefix: 'data/',
    compression: 'gzip',
  },
  tiering: {
    hotThresholdMs: 60 * 60 * 1000,      // 1 hour
    warmThresholdMs: 24 * 60 * 60 * 1000, // 24 hours
    accessCountThreshold: 5,
    promoteOnRead: true,
  },
})

// Write to hot tier
await store.write('users', 'user-123', {
  name: 'Alice',
  email: 'alice@example.com',
})

// Read with automatic tier traversal: hot -> warm -> cold
const user = await store.read('users', 'user-123')
// Promotes to hot if promoteOnRead is enabled

// Force cold placement for archives
await store.write('archives', 'report-2024', data, {
  tier: StorageTier.COLD,
})

const result = await store.runTiering({ maxOperations: 100 })
// Demotes inactive data, promotes accessed cold data

console.log(`Promoted: ${result.promoted}, Demoted: ${result.demoted}`)

import { classifyTier } from '@db4/storage'

const tier = classifyTier(document, {
  hotThresholdMs: 3600000,      // Hot for 1 hour
  warmThresholdMs: 86400000,    // Warm for 24 hours
  accessCountThreshold: 5,      // 5+ accesses = stay hot
  accessWindowMs: 3600000,
})

import { AccessPatternTracker } from '@db4/storage'

const tracker = new AccessPatternTracker({
  historyWindow: 7 * 24 * 60 * 60 * 1000,
  coldPredictionThreshold: 3,
  coldAgeThreshold: 7 * 24 * 60 * 60 * 1000,
})

tracker.recordAccess('users/user-123')

const coldCandidates = tracker.predictColdDocuments()
const score = tracker.getTieringScore('users/user-123')
// Higher score = keep hotter

// Promote cold data to hot
await store.promote('reports', 'dashboard-summary', StorageTier.HOT)

// Demote old data (deletes from source by default)
await store.demote('logs', 'log-2023-01', StorageTier.COLD)

// Keep a copy in source tier
await store.demote('logs', 'log-2023-02', StorageTier.WARM, {
  keepInSource: true,
})

// Check current tier
const tier = await store.getTier('users', 'user-123')

import {
  CacheInvalidationManager,
  InMemoryBroadcastChannel,
  StorageTier,
} from '@db4/storage'

const cache = new CacheInvalidationManager({
  invalidateOnWrite: true,
  versionBasedInvalidation: true,
  defaultTtlMs: 3600000,
  broadcastEnabled: true,
  nodeId: 'worker-1',
})

cache.setBroadcastChannel(new InMemoryBroadcastChannel('my-app'))

cache.set('users', 'user-123', document, 3600000)
const result = cache.get('users', 'user-123', expectedVersion)

if (result.versionMismatch) {
  await cache.invalidate('users', 'user-123', StorageTier.HOT)
}

cache.subscribe((event) => {
  console.log(`${event.type}: ${event.collection}/${event.id}`)
})

import { MultipartUploadState } from '@db4/storage'

const coldStorage = store.getColdStorage()

const result = await coldStorage.writeLarge('videos', 'video-123', largeBuffer, {
  partSize: 100 * 1024 * 1024,
  concurrency: 4,
  onProgress: (p) => console.log(`${p.percentComplete}%`),
  abortSignal: controller.signal,
})

// Resume interrupted uploads
const session = await coldStorage.getUploadStatus(uploadId)
if (session?.state === MultipartUploadState.FAILED) {
  await coldStorage.resumeUpload(uploadId, largeBuffer)
}

await coldStorage.cleanupExpiredUploads(24 * 60 * 60 * 1000)

import {
  EncryptionManager,
  EncryptedStorageWrapper,
  generateMasterKey,
} from '@db4/storage'

const masterKey = await generateMasterKey()

const encryption = new EncryptionManager({
  masterKey,
  defaultKeyExpirationMs: 90 * 24 * 60 * 60 * 1000,
  destructionGracePeriodMs: 7 * 24 * 60 * 60 * 1000,
})
await encryption.initialize()

const wrapper = new EncryptedStorageWrapper({
  encryptionManager: encryption,
  includeIdInAad: true,
  includeCollectionInAad: true,
})

const encrypted = await wrapper.encryptDocument('users', 'user-123', userData)
const decrypted = await wrapper.decryptDocument('users', 'user-123', encrypted)

// Key rotation
const rotation = await encryption.rotateKey({ keepOldKey: true })

if (await wrapper.needsReencryption(encrypted)) {
  await wrapper.reencryptDocument('users', 'user-123', encrypted)
}

enum StorageTier { HOT = 'hot', WARM = 'warm', COLD = 'cold' }

enum MultipartUploadState {
  PENDING = 'pending',
  IN_PROGRESS = 'in_progress',
  COMPLETED = 'completed',
  ABORTED = 'aborted',
  FAILED = 'failed',
}

enum KeyState {
  ACTIVE = 'active',
  DECRYPT_ONLY = 'decrypt_only',
  PENDING_DESTRUCTION = 'pending_destruction',
  DESTROYED = 'destroyed',
}

interface TieredDocument {
  id: string
  tier?: StorageTier
  _meta: TieredDocumentMeta
  [key: string]: unknown
}

interface TieredStoreConfig {
  hot: HotStorageConfig
  warm: WarmStorageConfig
  cold: ColdStorageConfig
  tiering: TieringConfig
}