import axios, { AxiosResponseHeaders } from 'axios';
import { initAjaxHandlersParseDates } from '../ajax-handlers-parse-dates';

jest.mock('axios', () => ({ defaults: {} }));

describe(`[ajax-handlers] ${initAjaxHandlersParseDates.name}`, () => {
    const subject = () => initAjaxHandlersParseDates();

    describe('transformResponse', () => {
        beforeEach(() => delete axios.defaults.transformResponse);

        test('registers handler', () => {
            subject();

            expect(axios.defaults.transformResponse).toEqual([expect.any(Function)]);
        });

        function itAppendsHandler() {
            test('appends handler', () => {
                const { transformResponse = [] } = axios.defaults;
                const previous = Array.isArray(transformResponse)
                    ? [...transformResponse]
                    : [transformResponse];

                subject();

                expect(axios.defaults.transformResponse).toEqual([
                    ...previous,
                    expect.any(Function),
                ]);
            });
        }

        describe('with existing transformResponse', () => {
            beforeEach(() => (axios.defaults.transformResponse = jest.fn()));

            itAppendsHandler();
        });

        describe('with existing transformResponse array', () => {
            beforeEach(() => (axios.defaults.transformResponse = [jest.fn()]));

            itAppendsHandler();
        });

        describe('transformResponse handler', () => {
            let data: any;

            beforeEach(() => initAjaxHandlersParseDates());

            const subject = () => {
                const { transformResponse } = axios.defaults;
                const transformer = Array.isArray(transformResponse)
                    ? transformResponse[0]
                    : transformResponse;
                return transformer?.bind({} as any)(data, {} as AxiosResponseHeaders);
            };

            function itReturnsDate() {
                test('returns Date', () => expect(subject()).toEqual(new Date(data)));
            }

            function itReturnsInput() {
                test('returns input', () => expect(subject()).toBe(data));
            }

            describe('with ISO date string', () => {
                beforeEach(() => (data = '2023-11-01T13:44:30.914Z'));

                itReturnsDate();
            });

            describe('with ISO date string sans milliseconds and TZ', () => {
                beforeEach(() => (data = '2023-11-01T13:44:30'));

                itReturnsDate();
            });

            describe('with .NET date string', () => {
                const date = new Date('2023-11-01T13:44:30');

                beforeEach(() => (data = `/Date(${date.getTime()})/`));

                test('returns Date', () => {
                    expect(subject()).toEqual(date);
                });
            });

            describe('with object containing date string', () => {
                const date = new Date('2023-11-01T13:44:30');
                const dotNetDate = `/Date(${date.getTime()})/`;

                beforeEach(() => {
                    data = {
                        date: date.toISOString(),
                        foo: [dotNetDate],
                        bar: [{ date: date.toISOString(), dotNetDate }],
                        baz: 'qux',
                    };
                });

                test('transforms embedded dates', () => {
                    expect(subject()).toEqual({
                        date,
                        foo: [date],
                        bar: [{ date, dotNetDate: date }],
                        baz: 'qux',
                    });
                });
            });

            describe('with Blob', () => {
                beforeEach(() => (data = new Blob()));

                itReturnsInput();
            });

            describe('with Date', () => {
                beforeEach(() => (data = new Date()));

                itReturnsInput();
            });

            ['foo', true, 3.14].forEach((value: any) => {
                describe(`with ${typeof value}`, () => {
                    beforeEach(() => (data = value));

                    itReturnsInput();
                });
            });
        });
    });
});