import { useState, useEffect, useCallback } from "react";
import {
  type DirectiveMemory,
  type MemoryCategory,
  type CreateDirectiveMemoryRequest,
  listDirectiveMemories,
  createDirectiveMemory,
  deleteDirectiveMemory,
} from "../lib/api";

export function useDirectiveMemories(directiveId: string | undefined) {
  const [memories, setMemories] = useState<DirectiveMemory[]>([]);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);

  const refreshMemories = useCallback(async () => {
    if (!directiveId) return;
    try {
      setLoading(true);
      setError(null);
      const response = await listDirectiveMemories(directiveId);
      setMemories(response.memories);
    } catch (e) {
      setError(e instanceof Error ? e.message : "Failed to load memories");
    } finally {
      setLoading(false);
    }
  }, [directiveId]);

  useEffect(() => {
    refreshMemories();
  }, [refreshMemories]);

  const add = useCallback(async (req: CreateDirectiveMemoryRequest) => {
    if (!directiveId) return;
    try {
      setError(null);
      await createDirectiveMemory(directiveId, req);
      await refreshMemories();
    } catch (e) {
      setError(e instanceof Error ? e.message : "Failed to add memory");
    }
  }, [directiveId, refreshMemories]);

  const remove = useCallback(async (memoryId: string) => {
    if (!directiveId) return;
    try {
      setError(null);
      await deleteDirectiveMemory(directiveId, memoryId);
      await refreshMemories();
    } catch (e) {
      setError(e instanceof Error ? e.message : "Failed to delete memory");
    }
  }, [directiveId, refreshMemories]);

  const clearAll = useCallback(async () => {
    if (!directiveId) return;
    try {
      setError(null);
      await Promise.all(memories.map((m) => deleteDirectiveMemory(directiveId, m.id)));
      setMemories([]);
    } catch (e) {
      setError(e instanceof Error ? e.message : "Failed to clear memories");
    }
  }, [directiveId, memories]);

  /** Group entries by category */
  const grouped = memories.reduce<Record<MemoryCategory, DirectiveMemory[]>>(
    (acc, entry) => {
      acc[entry.category].push(entry);
      return acc;
    },
    { decision: [], context: [], preference: [], learning: [], issue: [], progress: [], other: [] },
  );

  return {
    memories,
    grouped,
    loading,
    error,
    refresh: refreshMemories,
    add,
    remove,
    clearAll,
  };
}