import { act } from 'react-test-renderer';

import { fallbackCreditsContent } from '../src/data';
import {
  readToolkitContent,
  saveToolkitContent,
} from '../src/socket/toolkitSocketClient';
import { useToolkitContentStore } from '../src/state/toolkitContentStore';

jest.mock('../src/socket/toolkitSocketClient', () => ({
  readToolkitContent: jest.fn(),
  saveToolkitContent: jest.fn(),
}));

const mockedReadToolkitContent = jest.mocked(readToolkitContent);
const mockedSaveToolkitContent = jest.mocked(saveToolkitContent);

const changedCredits = {
  ...fallbackCreditsContent,
  mainLogo: {
    image: null,
    subtitle: 'Changed subtitle',
    title: 'Changed Credits',
  },
};

describe('useToolkitContentStore', () => {
  beforeEach(() => {
    mockedReadToolkitContent.mockReset();
    mockedSaveToolkitContent.mockReset();
    useToolkitContentStore.setState({
      credits: fallbackCreditsContent,
      error: null,
      lastLoadedAt: null,
      revision: null,
      status: 'idle',
    });
  });

  it('loads credits from the socket client', async () => {
    mockedReadToolkitContent.mockResolvedValue({
      content: changedCredits,
      resource: 'credits',
      revision: '123',
    });

    await act(async () => {
      await useToolkitContentStore.getState().refreshCredits();
    });

    expect(mockedReadToolkitContent).toHaveBeenCalledWith('credits');
    expect(useToolkitContentStore.getState()).toMatchObject({
      credits: changedCredits,
      error: null,
      revision: '123',
      status: 'ready',
    });
    expect(useToolkitContentStore.getState().lastLoadedAt).not.toBeNull();
  });

  it('saves credits through the socket client', async () => {
    mockedSaveToolkitContent.mockResolvedValue({
      content: changedCredits,
      resource: 'credits',
      revision: '456',
    });

    await act(async () => {
      await useToolkitContentStore.getState().saveCredits(changedCredits);
    });

    expect(mockedSaveToolkitContent).toHaveBeenCalledWith(
      'credits',
      changedCredits,
    );
    expect(useToolkitContentStore.getState()).toMatchObject({
      credits: changedCredits,
      error: null,
      revision: '456',
      status: 'ready',
    });
  });

  it('replaces credits from a socket change event', () => {
    act(() => {
      useToolkitContentStore
        .getState()
        .setCreditsFromSocket(changedCredits, '789');
    });

    expect(useToolkitContentStore.getState()).toMatchObject({
      credits: changedCredits,
      error: null,
      revision: '789',
      status: 'ready',
    });
  });

  it('tracks content request errors without losing fallback credits', async () => {
    mockedReadToolkitContent.mockRejectedValue(new Error('socket unavailable'));

    await act(async () => {
      await useToolkitContentStore.getState().refreshCredits();
    });

    expect(useToolkitContentStore.getState()).toMatchObject({
      credits: fallbackCreditsContent,
      error: 'socket unavailable',
      status: 'error',
    });
  });
});