import { describe, expect, it, beforeEach, afterEach, vi } from 'vitest';
import { default as axios } from 'axios';
import { useArrayData } from 'composables/useArrayData';
import { useRouter } from 'vue-router';
import * as vueRouter from 'vue-router';
import { setActivePinia, createPinia } from 'pinia';
import { defineComponent, h } from 'vue';
import { mount } from '@vue/test-utils';

describe('useArrayData', () => {
    const filter = '{"limit":20,"skip":0}';
    const params = { supplierFk: 2 };

    beforeEach(() => {
        setActivePinia(createPinia());

        // Mock route
        vi.spyOn(vueRouter, 'useRoute').mockReturnValue({
            path: 'mockSection/list',
            matched: [],
            query: {},
            params: {},
            meta: { moduleName: 'mockName' },
        });

        // Mock router
        vi.spyOn(vueRouter, 'useRouter').mockReturnValue({
            push: vi.fn(),
            replace: vi.fn(),
            currentRoute: {
                value: {
                    path: 'mockSection/list',
                    params: { id: 1 },
                    meta: { moduleName: 'mockName' },
                    matched: [{ path: 'mockName/:id' }],
                },
            },
        });
    });

    afterEach(() => {
        vi.clearAllMocks();
    });

    it('should fetch and replace url with new params', async () => {
        vi.spyOn(axios, 'get').mockResolvedValueOnce({ data: [] });

        const arrayData = mountArrayData('ArrayData', {
            url: 'mockUrl',
            searchUrl: 'params',
        });

        arrayData.store.userParams = params;
        await arrayData.fetch({});

        const routerReplace = useRouter().replace.mock.calls[0][0];

        expect(axios.get).toHaveBeenCalledWith('mockUrl', {
            signal: expect.any(Object),
            params: {
                filter,
                supplierFk: 2,
            },
        });

        expect(routerReplace.path).toBe('mockSection/list');
        expect(JSON.parse(routerReplace.query.params)).toEqual(
            expect.objectContaining(params),
        );
    });

    it('should redirect to detail when single record is returned with navigation', async () => {
        vi.spyOn(axios, 'get').mockResolvedValueOnce({
            data: [{ id: 1 }],
        });

        const arrayData = mountArrayData('ArrayData', {
            url: 'mockUrl',
            navigate: {},
        });

        arrayData.store.userParams = params;
        await arrayData.fetch({});

        const routerPush = useRouter().push.mock.calls[0][0];

        expect(routerPush.path).toBe('mockName/1');
        expect(routerPush.query).toBeUndefined();
    });

    it('should return one record when oneRecord is true', async () => {
        vi.spyOn(axios, 'get').mockResolvedValueOnce({
            data: [
                { id: 1, name: 'Entity 1' },
                { id: 2, name: 'Entity 2' },
            ],
        });

        const arrayData = mountArrayData('ArrayData', {
            url: 'mockUrl',
            oneRecord: true,
        });

        await arrayData.fetch({});

        expect(arrayData.store.data).toEqual({
            id: 1,
            name: 'Entity 1',
        });
    });
});

function mountArrayData(...args) {
    let arrayData;

    const TestComponent = defineComponent({
        setup() {
            arrayData = useArrayData(...args);
            return () => h('div');
        },
    });

    const asd = mount(TestComponent);
    return arrayData;
}