// expense-tracker/src/lib/types/recursive.ts
export type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue }
 
/** 객체면 모든 프로퍼티를 재귀적으로 선택적으로 만들고, 객체가 아니면 그대로 둡니다 */
export type DeepPartial<T> = T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T
 
/** 객체면 모든 프로퍼티를 재귀적으로 읽기 전용으로 만들고, 객체가 아니면 그대로 둡니다 */
export type DeepReadonly<T> = T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]> } : T
 
export function safeJsonParse(raw: string): JsonValue | null {
  try {
    return JSON.parse(raw) as JsonValue
  } catch {
    return null
  }
}

// expense-tracker/src/services/budgetRules.ts
import type { ExpenseCategory } from '../models'
import type { CategoryTotals } from './stats.ts'
import type { DeepPartial, DeepReadonly } from '../lib/types/recursive.ts'
import { safeJsonParse } from '../lib/types/recursive.ts'
 
export interface BudgetRule {
  readonly name: string
  evaluate(totals: CategoryTotals): string[]
}
 
export class LimitExceededRule implements BudgetRule {
  readonly name = 'limit-exceeded'
 
  constructor(private readonly limits: Partial<Record<ExpenseCategory, number>>) {}
 
  evaluate(totals: CategoryTotals): string[] {
    const warnings: string[] = []
    for (const [category, limit] of Object.entries(this.limits) as [ExpenseCategory, number][]) {
      const spent = totals[category]
      if (spent > limit) {
        warnings.push(`${category} 카테고리 지출이 한도 ${limit}원을 넘었습니다(현재 ${spent}원)`)
      }
    }
    return warnings
  }
}
 
export class ApproachingLimitRule implements BudgetRule {
  readonly name = 'approaching-limit'
 
  constructor(
    private readonly limits: Partial<Record<ExpenseCategory, number>>,
    private readonly warningRatio = 0.8,
  ) {}
 
  evaluate(totals: CategoryTotals): string[] {
    const warnings: string[] = []
    for (const [category, limit] of Object.entries(this.limits) as [ExpenseCategory, number][]) {
      const spent = totals[category]
      if (spent <= limit && spent >= limit * this.warningRatio) {
        warnings.push(`${category} 카테고리 지출이 한도의 ${this.warningRatio * 100}퍼센트를 넘었습니다`)
      }
    }
    return warnings
  }
}
 
export class BudgetEvaluator {
  constructor(private readonly rules: BudgetRule[]) {}
 
  evaluateAll(totals: CategoryTotals): string[] {
    return this.rules.flatMap((rule) => rule.evaluate(totals))
  }
}
 
export interface BudgetSettings {
  limits: Partial<Record<ExpenseCategory, number>>
  approachingRatio: number
}
 
export const DEFAULT_BUDGET_SETTINGS: DeepReadonly<BudgetSettings> = Object.freeze({
  limits: Object.freeze({ food: 150000, transport: 60000 }),
  approachingRatio: 0.8,
})
 
const BUDGET_SETTINGS_KEY = 'expense-tracker:budget-settings'
 
export function mergeBudgetSettings(overrides: DeepPartial<BudgetSettings>): BudgetSettings {
  return {
    limits: { ...DEFAULT_BUDGET_SETTINGS.limits, ...overrides.limits },
    approachingRatio: overrides.approachingRatio ?? DEFAULT_BUDGET_SETTINGS.approachingRatio,
  }
}
 
export function loadBudgetSettings(): BudgetSettings {
  const raw = localStorage.getItem(BUDGET_SETTINGS_KEY)
  if (raw === null) {
    return mergeBudgetSettings({})
  }
  const parsed = safeJsonParse(raw)
  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
    return mergeBudgetSettings({})
  }
  return mergeBudgetSettings(parsed as DeepPartial<BudgetSettings>)
}

// expense-tracker/src/services/index.ts
export { Storage } from './storage.ts'
export type { DataStore } from './storage.ts'
export { StatsCalculator, logAndCompute, fetchCategoryGroups } from './stats.ts'
export type { CategoryTotals, MonthlySummary, CategoryGroups } from './stats.ts'
export { BudgetEvaluator, LimitExceededRule, ApproachingLimitRule, loadBudgetSettings, mergeBudgetSettings } from './budgetRules.ts'
export type { BudgetRule, BudgetSettings } from './budgetRules.ts'

// expense-tracker/src/ui/statsPanel.ts (발췌 — 15편의 BUDGET_LIMITS 상수를 지우고 이 부분으로 교체)
import { StatsCalculator, BudgetEvaluator, LimitExceededRule, ApproachingLimitRule, loadBudgetSettings } from '../services'
 
const budgetSettings = loadBudgetSettings()
const budgetEvaluator = new BudgetEvaluator([
  new LimitExceededRule(budgetSettings.limits),
  new ApproachingLimitRule(budgetSettings.limits, budgetSettings.approachingRatio),
])

npm run dev

localStorage.setItem('expense-tracker:budget-settings', JSON.stringify({ limits: { food: 200000 } }))