fintrack/lib/store.ts

"use client"

import type { BankingData, Account, Transaction, Folder, Category } from "./types"
import { defaultCategories, defaultRootFolder } from "./defaults"

const STORAGE_KEY = "banking-app-data"

// Convertir les CategoryDefinition en Category pour le localStorage
function buildCategoriesFromDefaults(): Category[] {
  const slugToId = new Map<string, string>()
  const categories: Category[] = []

  // D'abord les parents
  const parents = defaultCategories.filter((c) => c.parentSlug === null)
  parents.forEach((cat, index) => {
    const id = `cat-${index + 1}`
    slugToId.set(cat.slug, id)
    categories.push({
      id,
      name: cat.name,
      color: cat.color,
      icon: cat.icon,
      keywords: cat.keywords,
      parentId: null,
    })
  })

  // Puis les enfants
  const children = defaultCategories.filter((c) => c.parentSlug !== null)
  children.forEach((cat, index) => {
    const id = `cat-${parents.length + index + 1}`
    slugToId.set(cat.slug, id)
    categories.push({
      id,
      name: cat.name,
      color: cat.color,
      icon: cat.icon,
      keywords: cat.keywords,
      parentId: cat.parentSlug ? slugToId.get(cat.parentSlug) || null : null,
    })
  })

  return categories
}

const defaultData: BankingData = {
  accounts: [],
  transactions: [],
  folders: [defaultRootFolder],
  categories: buildCategoriesFromDefaults(),
}

export function loadData(): BankingData {
  if (typeof window === "undefined") return defaultData

  const stored = localStorage.getItem(STORAGE_KEY)
  if (!stored) {
    saveData(defaultData)
    return defaultData
  }

  try {
    return JSON.parse(stored)
  } catch {
    return defaultData
  }
}

export function saveData(data: BankingData): void {
  if (typeof window === "undefined") return
  localStorage.setItem(STORAGE_KEY, JSON.stringify(data))
}

export function addAccount(account: Account): BankingData {
  const data = loadData()
  data.accounts.push(account)
  saveData(data)
  return data
}

export function updateAccount(account: Account): BankingData {
  const data = loadData()
  const index = data.accounts.findIndex((a) => a.id === account.id)
  if (index !== -1) {
    data.accounts[index] = account
    saveData(data)
  }
  return data
}

export function deleteAccount(accountId: string): BankingData {
  const data = loadData()
  data.accounts = data.accounts.filter((a) => a.id !== accountId)
  data.transactions = data.transactions.filter((t) => t.accountId !== accountId)
  saveData(data)
  return data
}

export function addTransactions(transactions: Transaction[]): BankingData {
  const data = loadData()

  // Filter out duplicates based on fitId
  const existingFitIds = new Set(data.transactions.map((t) => `${t.accountId}-${t.fitId}`))
  const newTransactions = transactions.filter((t) => !existingFitIds.has(`${t.accountId}-${t.fitId}`))

  data.transactions.push(...newTransactions)
  saveData(data)
  return data
}

export function updateTransaction(transaction: Transaction): BankingData {
  const data = loadData()
  const index = data.transactions.findIndex((t) => t.id === transaction.id)
  if (index !== -1) {
    data.transactions[index] = transaction
    saveData(data)
  }
  return data
}

export function addFolder(folder: Folder): BankingData {
  const data = loadData()
  data.folders.push(folder)
  saveData(data)
  return data
}

export function updateFolder(folder: Folder): BankingData {
  const data = loadData()
  const index = data.folders.findIndex((f) => f.id === folder.id)
  if (index !== -1) {
    data.folders[index] = folder
    saveData(data)
  }
  return data
}

export function deleteFolder(folderId: string): BankingData {
  const data = loadData()
  // Move accounts to root
  data.accounts = data.accounts.map((a) => (a.folderId === folderId ? { ...a, folderId: "folder-root" } : a))
  // Move subfolders to parent
  const folder = data.folders.find((f) => f.id === folderId)
  if (folder) {
    data.folders = data.folders.map((f) => (f.parentId === folderId ? { ...f, parentId: folder.parentId } : f))
  }
  data.folders = data.folders.filter((f) => f.id !== folderId)
  saveData(data)
  return data
}

export function addCategory(category: Category): BankingData {
  const data = loadData()
  data.categories.push(category)
  saveData(data)
  return data
}

export function updateCategory(category: Category): BankingData {
  const data = loadData()
  const index = data.categories.findIndex((c) => c.id === category.id)
  if (index !== -1) {
    data.categories[index] = category
    saveData(data)
  }
  return data
}

export function deleteCategory(categoryId: string): BankingData {
  const data = loadData()
  data.categories = data.categories.filter((c) => c.id !== categoryId)
  // Remove category from transactions
  data.transactions = data.transactions.map((t) => (t.categoryId === categoryId ? { ...t, categoryId: null } : t))
  saveData(data)
  return data
}

// Auto-categorize a transaction based on keywords
export function autoCategorize(description: string, categories: Category[]): string | null {
  const lowerDesc = description.toLowerCase()

  for (const category of categories) {
    for (const keyword of category.keywords) {
      if (lowerDesc.includes(keyword.toLowerCase())) {
        return category.id
      }
    }
  }

  return null
}

export function generateId(): string {
  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
}