import axios from 'axios';
import { HostexApiClient } from '../client/index.js';

jest.mock('axios');
const mockedAxios = axios as jest.Mocked<typeof axios>;

function makeClient() {
  const mockInstance = {
    request: jest.fn(),
    post: jest.fn(),
    patch: jest.fn(),
    delete: jest.fn(),
    interceptors: { request: { use: jest.fn() }, response: { use: jest.fn() } },
  };
  mockedAxios.create.mockReturnValue(mockInstance as any);
  return { client: new HostexApiClient({ accessToken: 'test-token' }), mockInstance };
}

const validBody = {
  scope_property: { type: 'all' as const, ids: [-1] },
  scope_channel: { type: 'all' as const, channels: ['unlimited'] },
  contents: [{ text: 'SSID: foo', sub_title: 'WiFi' }],
  is_enable: true,
};

describe('HostexApiClient knowledge bases CRUD', () => {
  it('getKnowledgeBases sends GET /knowledge_bases and unwraps data', async () => {
    const { client, mockInstance } = makeClient();
    const payload = { total: 0, knowledge_bases: [] };
    mockInstance.request.mockResolvedValue({ data: { error_code: 200, data: payload } });

    const res = await client.getKnowledgeBases({ property_ids: '1,2' });

    expect(mockInstance.request).toHaveBeenCalledWith({
      method: 'GET',
      url: '/knowledge_bases',
      params: { property_ids: '1,2' },
    });
    expect(res).toEqual(payload);
  });

  it('getKnowledgeBaseDetail sends GET /knowledge_bases/:id', async () => {
    const { client, mockInstance } = makeClient();
    const payload = { id: 3, ...validBody, title: 'WiFi info', process_status: 'done' };
    mockInstance.request.mockResolvedValue({ data: { error_code: 200, data: payload } });

    const res = await client.getKnowledgeBaseDetail(3);

    expect(mockInstance.request).toHaveBeenCalledWith({
      method: 'GET',
      url: '/knowledge_bases/3',
    });
    expect(res).toEqual(payload);
  });

  it('createKnowledgeBase sends POST /knowledge_bases', async () => {
    const { client, mockInstance } = makeClient();
    mockInstance.post.mockResolvedValue({ data: { error_code: 200 } });

    await client.createKnowledgeBase(validBody);

    expect(mockInstance.post).toHaveBeenCalledWith('/knowledge_bases', validBody);
  });

  it('createKnowledgeBase allows is_enable false', async () => {
    const { client, mockInstance } = makeClient();
    mockInstance.post.mockResolvedValue({ data: { error_code: 200 } });

    await client.createKnowledgeBase({ ...validBody, is_enable: false });

    expect(mockInstance.post).toHaveBeenCalledWith('/knowledge_bases', {
      ...validBody,
      is_enable: false,
    });
  });

  it('createKnowledgeBase rejects empty contents', async () => {
    const { client } = makeClient();
    await expect(
      client.createKnowledgeBase({ ...validBody, contents: [] })
    ).rejects.toThrow('contents must be a non-empty array');
  });

  it('updateKnowledgeBase sends PATCH /knowledge_bases/:id without id in body', async () => {
    const { client, mockInstance } = makeClient();
    mockInstance.patch.mockResolvedValue({ data: { error_code: 200 } });

    await client.updateKnowledgeBase({ id: 3, ...validBody });

    expect(mockInstance.patch).toHaveBeenCalledWith('/knowledge_bases/3', validBody);
  });

  it('deleteKnowledgeBase sends DELETE /knowledge_bases/:id', async () => {
    const { client, mockInstance } = makeClient();
    mockInstance.delete.mockResolvedValue({ data: { error_code: 200 } });

    await client.deleteKnowledgeBase(3);

    expect(mockInstance.delete).toHaveBeenCalledWith('/knowledge_bases/3');
  });
});