export const getHookTestTemplate = (domainName: string): string => {
  const capitalizedName =
    domainName.charAt(0).toUpperCase() + domainName.slice(1);

  return `import { describe, it, expect, vi } from 'vitest';
import { renderHook, act } from '@testing-library/react';
import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
import { use${capitalizedName}List, use${capitalizedName}Detail, use${capitalizedName}Create, use${capitalizedName}Update, use${capitalizedName}Delete } from './use${capitalizedName}';
import type { ${capitalizedName}Port } from '../ports/${capitalizedName}Port';

const createWrapper = () => {
  const queryClient = new QueryClient({
    defaultOptions: {
      queries: {
        retry: false,
      },
    },
  });
  return ({ children }: { children: React.ReactNode }) => (
    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
  );
};

describe('${capitalizedName} Hooks', () => {
  const mockPort: ${capitalizedName}Port = {
    getAll: vi.fn(),
    getById: vi.fn(),
    create: vi.fn(),
    update: vi.fn(),
    delete: vi.fn(),
  };

  describe('use${capitalizedName}List', () => {
    it('should fetch all entities', async () => {
      const mockEntities = [{ id: '1' }];
      mockPort.getAll.mockResolvedValueOnce(mockEntities);

      const { result } = renderHook(() => use${capitalizedName}List(mockPort), {
        wrapper: createWrapper(),
      });

      expect(result.current.isLoading).toBe(true);
      await act(async () => {
        await result.current.refetch();
      });
      expect(result.current.data).toEqual(mockEntities);
    });
  });

  describe('use${capitalizedName}Detail', () => {
    it('should fetch entity by id', async () => {
      const mockEntity = { id: '1' };
      mockPort.getById.mockResolvedValueOnce(mockEntity);

      const { result } = renderHook(() => use${capitalizedName}Detail(mockPort, '1'), {
        wrapper: createWrapper(),
      });

      expect(result.current.isLoading).toBe(true);
      await act(async () => {
        await result.current.refetch();
      });
      expect(result.current.data).toEqual(mockEntity);
    });
  });

  describe('use${capitalizedName}Create', () => {
    it('should create entity', async () => {
      const mockEntity = { id: '1' };
      mockPort.create.mockResolvedValueOnce(mockEntity);

      const { result } = renderHook(() => use${capitalizedName}Create(mockPort), {
        wrapper: createWrapper(),
      });

      await act(async () => {
        await result.current.mutateAsync({ id: '1' });
      });

      expect(mockPort.create).toHaveBeenCalledWith({ id: '1' });
    });
  });

  describe('use${capitalizedName}Update', () => {
    it('should update entity', async () => {
      const mockEntity = { id: '1' };
      mockPort.update.mockResolvedValueOnce(mockEntity);

      const { result } = renderHook(() => use${capitalizedName}Update(mockPort), {
        wrapper: createWrapper(),
      });

      await act(async () => {
        await result.current.mutateAsync({ id: '1', data: { id: '1' } });
      });

      expect(mockPort.update).toHaveBeenCalledWith('1', { id: '1' });
    });
  });

  describe('use${capitalizedName}Delete', () => {
    it('should delete entity', async () => {
      mockPort.delete.mockResolvedValueOnce();

      const { result } = renderHook(() => use${capitalizedName}Delete(mockPort), {
        wrapper: createWrapper(),
      });

      await act(async () => {
        await result.current.mutateAsync('1');
      });

      expect(mockPort.delete).toHaveBeenCalledWith('1');
    });
  });
});`;
};