managarten/memoro/apps/mobile/features/spaces/hooks/useSpaces.ts

import { useState, useCallback } from 'react';
import spaceService, { 
  Space,
  CreateSpaceRequest, 
  UpdateSpaceRequest 
} from '../services/spaceService';

export default function useSpaces() {
  const [spaces, setSpaces] = useState<Space[]>([]);
  const [isLoading, setIsLoading] = useState<boolean>(false);
  const [error, setError] = useState<string | null>(null);

  // Fetch all spaces
  const fetchSpaces = useCallback(async () => {
    setIsLoading(true);
    setError(null);
    try {
      const spacesData = await spaceService.getSpaces();
      setSpaces(spacesData);
    } catch (err) {
      setError('Failed to fetch spaces');
      console.error(err);
    } finally {
      setIsLoading(false);
    }
  }, []);

  // Create a new space
  const createSpace = useCallback(async (spaceData: CreateSpaceRequest) => {
    setIsLoading(true);
    setError(null);
    try {
      const newSpace = await spaceService.createSpace(spaceData);
      setSpaces(prevSpaces => [...prevSpaces, newSpace]);
      return newSpace;
    } catch (err) {
      setError('Failed to create space');
      console.error(err);
      throw err;
    } finally {
      setIsLoading(false);
    }
  }, []);

  // Update an existing space
  const updateSpace = useCallback(async (spaceId: string, spaceData: UpdateSpaceRequest) => {
    setIsLoading(true);
    setError(null);
    try {
      const updatedSpace = await spaceService.updateSpace(spaceId, spaceData);
      setSpaces(prevSpaces => 
        prevSpaces.map(space => 
          space.id === spaceId ? updatedSpace : space
        )
      );
      return updatedSpace;
    } catch (err) {
      setError('Failed to update space');
      console.error(err);
      throw err;
    } finally {
      setIsLoading(false);
    }
  }, []);

  // Delete a space
  const deleteSpace = useCallback(async (spaceId: string) => {
    setIsLoading(true);
    setError(null);
    try {
      await spaceService.deleteSpace(spaceId);
      setSpaces(prevSpaces => 
        prevSpaces.filter(space => space.id !== spaceId)
      );
      return true;
    } catch (err) {
      setError('Failed to delete space');
      console.error(err);
      throw err;
    } finally {
      setIsLoading(false);
    }
  }, []);

  // Get a specific space by ID
  const getSpace = useCallback(async (spaceId: string) => {
    setIsLoading(true);
    setError(null);
    try {
      const space = await spaceService.getSpace(spaceId);
      return space;
    } catch (err) {
      setError('Failed to fetch space details');
      console.error(err);
      throw err;
    } finally {
      setIsLoading(false);
    }
  }, []);

  // Get memos for a specific space
  const getSpaceMemos = useCallback(async (spaceId: string) => {
    setIsLoading(true);
    setError(null);
    try {
      const memos = await spaceService.getSpaceMemos(spaceId);
      return memos;
    } catch (err) {
      setError('Failed to fetch space memos');
      console.error(err);
      throw err;
    } finally {
      setIsLoading(false);
    }
  }, []);

  // Link a memo to a space
  const linkMemoToSpace = useCallback(async (memoId: string, spaceId: string) => {
    setIsLoading(true);
    setError(null);
    try {
      const success = await spaceService.linkMemoToSpace(memoId, spaceId);
      return success;
    } catch (err) {
      setError('Failed to link memo to space');
      console.error(err);
      throw err;
    } finally {
      setIsLoading(false);
    }
  }, []);

  // Unlink a memo from a space
  const unlinkMemoFromSpace = useCallback(async (memoId: string, spaceId: string) => {
    setIsLoading(true);
    setError(null);
    try {
      const success = await spaceService.unlinkMemoFromSpace(memoId, spaceId);
      return success;
    } catch (err) {
      setError('Failed to unlink memo from space');
      console.error(err);
      throw err;
    } finally {
      setIsLoading(false);
    }
  }, []);
  
  // Leave a space (for non-owners)
  const leaveSpace = useCallback(async (spaceId: string) => {
    setIsLoading(true);
    setError(null);
    try {
      const success = await spaceService.leaveSpace(spaceId);
      // If successful, remove the space from the state
      if (success) {
        setSpaces(prevSpaces => 
          prevSpaces.filter(space => space.id !== spaceId)
        );
      }
      return success;
    } catch (err) {
      setError('Failed to leave space');
      console.error(err);
      throw err;
    } finally {
      setIsLoading(false);
    }
  }, []);

  // Load spaces when component mounts
  // TODO: Temporarily disabled until spaces feature is fully implemented
  // useEffect(() => {
  //   fetchSpaces();
  // }, [fetchSpaces]);

  return {
    spaces,
    isLoading,
    error,
    fetchSpaces,
    createSpace,
    updateSpace,
    deleteSpace,
    leaveSpace,
    getSpace,
    getSpaceMemos,
    linkMemoToSpace,
    unlinkMemoFromSpace
  };
}