import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { getUpdateInfo as checkUpdate } from '../src/update/check';

const getUpdateInfo = (force = false) =>
    checkUpdate(force, { mode: 'direct', mirror: '', mirrors: [] });

const LATEST_RELEASE_URL = 'https://api.github.com/repos/SnowLuma/SnowLuma/releases/latest';
const NOTES_MAX = 4_000;
const originalFetch = globalThis.fetch;
const savedUpdateCheck = process.env.SNOWLUMA_UPDATE_CHECK;

function deferred<T>() {
    let resolve!: (value: T) => void;
    const promise = new Promise<T>((res) => {
        resolve = res;
    });
    return { promise, resolve };
}

function jsonResponse(body: unknown, status = 200): Response {
    return new Response(JSON.stringify(body), {
        status,
        headers: { 'Content-Type': 'application/json' },
    });
}

function mockFetch(impl: (...args: Parameters<typeof fetch>) => ReturnType<typeof fetch>) {
    const fetchMock = vi.fn<(...args: Parameters<typeof fetch>) => ReturnType<typeof fetch>>(impl);
    globalThis.fetch = fetchMock as typeof fetch;
    return fetchMock;
}

beforeEach(() => {
    delete process.env.SNOWLUMA_UPDATE_CHECK;
    globalThis.fetch = vi.fn(async () => {
        throw new Error('unexpected fetch');
    }) as typeof fetch;
});

afterEach(() => {
    globalThis.fetch = originalFetch;

    if (savedUpdateCheck === undefined) {
        delete process.env.SNOWLUMA_UPDATE_CHECK;
    } else {
        process.env.SNOWLUMA_UPDATE_CHECK = savedUpdateCheck;
    }
});

vi.mock('@snowluma/common/version', () => ({ APP_VERSION: '0.0.0' }));

describe('getUpdateInfo', () => {
    it.each(['0', 'false', 'off', 'no', 'FALSE', ' Off ', 'No'] as const)(
        'skips the GitHub request when SNOWLUMA_UPDATE_CHECK=%j',
        async (value) => {
            process.env.SNOWLUMA_UPDATE_CHECK = value;
            const fetchMock = mockFetch(async () => jsonResponse({ tag_name: 'v9.9.9' }));
            const t0 = Date.now();
            const result = await getUpdateInfo(true);

            expect(fetchMock).not.toHaveBeenCalled();
            expect(result).toMatchObject({
                current: '0.0.0',
                latest: null,
                hasUpdate: false,
                htmlUrl: null,
                notes: null,
                publishedAt: null,
                error: 'disabled',
            });
            expect(result.checkedAt).toBeGreaterThanOrEqual(t0);
            expect(result.checkedAt).toBeLessThanOrEqual(Date.now());
        },
    );

    // Must run before any successful check: errors are not cached, but a prior
    // success stays in the module-level TTL cache and would hide this retry.
    it('retries after a failed check instead of caching the error', async () => {
        const fetchMock = mockFetch(async () => {
            throw new Error('ECONNRESET');
        });

        const failed = await getUpdateInfo();
        expect(failed).toMatchObject({
            current: '0.0.0',
            latest: null,
            hasUpdate: false,
            htmlUrl: null,
            notes: null,
            publishedAt: null,
            error: expect.stringContaining('ECONNRESET'),
        });

        fetchMock.mockImplementation(async () => jsonResponse({ tag_name: 'v1.0.0' }));
        const ok = await getUpdateInfo();
        expect(ok.latest).toBe('1.0.0');
        expect(ok.hasUpdate).toBe(true);
        expect(ok.error).toBeUndefined();
        expect(fetchMock).toHaveBeenCalledTimes(3);
    });

    it.each(['', '1', 'true', 'yes', 'on', '  '] as const)(
        'is enabled when SNOWLUMA_UPDATE_CHECK=%j',
        async (value) => {
            process.env.SNOWLUMA_UPDATE_CHECK = value;
            mockFetch(async () => jsonResponse({ tag_name: 'v1.0.0' }));
            const result = await getUpdateInfo(true);
            expect(result.error).toBeUndefined();
            expect(result.latest).toBe('1.0.0');
        },
    );

    it('GETs the latest stable release with the GitHub API headers', async () => {
        const fetchMock = mockFetch(async () => jsonResponse({ tag_name: 'v1.2.3' }));
        await getUpdateInfo(true);

        expect(fetchMock).toHaveBeenCalledTimes(1);
        expect(fetchMock.mock.calls[0]?.[0]).toBe(LATEST_RELEASE_URL);
        expect(fetchMock.mock.calls[0]?.[1]).toEqual({
            headers: {
                Accept: 'application/vnd.github+json',
                'User-Agent': 'SnowLuma/0.0.0',
                'X-GitHub-Api-Version': '2022-11-28',
            },
            signal: expect.any(AbortSignal),
        });
    });

    it('maps a newer release onto hasUpdate=true and strips the v prefix', async () => {
        const t0 = Date.now();
        mockFetch(async () =>
            jsonResponse({
                tag_name: '  v1.14.7  ',
                html_url: 'https://github.com/SnowLuma/SnowLuma/releases/tag/v1.14.7',
                body: 'hello',
                published_at: '2026-06-01T12:00:00Z',
            }),
        );

        const result = await getUpdateInfo(true);
        expect(result).toMatchObject({
            current: '0.0.0',
            latest: '1.14.7',
            hasUpdate: true,
            htmlUrl: 'https://github.com/SnowLuma/SnowLuma/releases/tag/v1.14.7',
            notes: 'hello',
            publishedAt: '2026-06-01T12:00:00Z',
        });
        expect(result.error).toBeUndefined();
        expect(result.checkedAt).toBeGreaterThanOrEqual(t0);
        expect(result.checkedAt).toBeLessThanOrEqual(Date.now());
    });

    it('sets hasUpdate=false when latest is not strictly newer than current', async () => {
        mockFetch(async () => jsonResponse({ tag_name: '0.0.0' }));
        const same = await getUpdateInfo(true);
        expect(same.latest).toBe('0.0.0');
        expect(same.hasUpdate).toBe(false);

        mockFetch(async () => jsonResponse({ tag_name: 'v0.0.0-rc.1' }));
        const older = await getUpdateInfo(true);
        expect(older.latest).toBe('0.0.0-rc.1');
        expect(older.hasUpdate).toBe(false);
    });

    it('treats a missing body / html_url / published_at as null', async () => {
        mockFetch(async () => jsonResponse({ tag_name: 'v5.0.0', body: '' }));
        const result = await getUpdateInfo(true);
        expect(result).toMatchObject({
            latest: '5.0.0',
            hasUpdate: true,
            htmlUrl: null,
            notes: null,
            publishedAt: null,
        });
    });

    it('truncates release notes to 4000 characters', async () => {
        mockFetch(async () =>
            jsonResponse({ tag_name: 'v6.0.0', body: 'n'.repeat(NOTES_MAX + 1) }),
        );
        const result = await getUpdateInfo(true);
        expect(result.notes).toBe('n'.repeat(NOTES_MAX));
    });

    it('returns github <status> when the API is not ok', async () => {
        mockFetch(async () => jsonResponse({ message: 'rate limited' }, 403));
        const result = await getUpdateInfo(true);
        expect(result).toMatchObject({
            current: '0.0.0',
            latest: null,
            hasUpdate: false,
            htmlUrl: null,
            notes: null,
            publishedAt: null,
            error: expect.stringContaining('GitHub 403'),
        });
    });

    it.each([{}, { tag_name: '   ' }, { tag_name: '' }] as const)(
        'returns no tag when tag_name is missing or blank: %j',
        async (body) => {
            mockFetch(async () => jsonResponse(body));
            const result = await getUpdateInfo(true);
            expect(result.error).toBe('no tag');
            expect(result.hasUpdate).toBe(false);
            expect(result.latest).toBeNull();
        },
    );

    it.each(['v01.2.3', 'v1.2.x', 'v1.2.3.4', 'v1.2.3-rc.01', 'v1.2.3+build..1'])(
        'reports an invalid release tag without offering an update: %s',
        async (tag) => {
            mockFetch(async () => jsonResponse({ tag_name: tag }));
            expect(await getUpdateInfo(true)).toMatchObject({
                latest: null,
                hasUpdate: false,
                error: 'invalid release version',
            });
        },
    );

    it('preserves build metadata in release tags', async () => {
        mockFetch(async () => jsonResponse({ tag_name: 'v1.2.3+build.01' }));
        expect(await getUpdateInfo(true)).toMatchObject({
            latest: '1.2.3+build.01',
            hasUpdate: true,
        });
    });

    it('uses the Error message when fetch throws an Error', async () => {
        mockFetch(async () => {
            throw new Error('getaddrinfo ENOTFOUND');
        });
        const result = await getUpdateInfo(true);
        expect(result.error).toContain('getaddrinfo ENOTFOUND');
        expect(result.hasUpdate).toBe(false);
    });

    it('uses network error when fetch throws a non-Error', async () => {
        mockFetch(async () => {
            throw 'timeout';
        });
        const result = await getUpdateInfo(true);
        expect(result.error).toContain('timeout');
        expect(result.hasUpdate).toBe(false);
    });

    it('degrades when the response body is not JSON', async () => {
        mockFetch(async () => new Response('not-json', { status: 200 }));
        const result = await getUpdateInfo(true);
        expect(result.hasUpdate).toBe(false);
        expect(result.latest).toBeNull();
        expect(result.error).toEqual(expect.any(String));
        expect(result.error).toBeTruthy();
    });

    it('never throws', async () => {
        mockFetch(async () => {
            throw new Error('boom');
        });
        await expect(getUpdateInfo(true)).resolves.toMatchObject({
            error: expect.stringContaining('boom'),
            hasUpdate: false,
        });
    });

    it('reuses a successful result until force=true', async () => {
        const fetchMock = mockFetch(async () =>
            jsonResponse({
                tag_name: 'v3.1.0',
                html_url: 'https://github.com/SnowLuma/SnowLuma/releases/tag/v3.1.0',
                body: 'cached',
                published_at: '2026-07-01T00:00:00Z',
            }),
        );

        const first = await getUpdateInfo(true);
        const second = await getUpdateInfo();
        const third = await getUpdateInfo(false);
        expect(second).toBe(first);
        expect(third).toBe(first);
        expect(fetchMock).toHaveBeenCalledTimes(1);

        const forced = await getUpdateInfo(true);
        expect(fetchMock).toHaveBeenCalledTimes(2);
        expect(forced).toMatchObject({
            latest: '3.1.0',
            hasUpdate: true,
            notes: 'cached',
        });
        expect(forced).not.toBe(first);
    });

    it('keeps a cached success after a forced failed check', async () => {
        const fetchMock = mockFetch(async () => jsonResponse({ tag_name: 'v4.0.0' }));
        const good = await getUpdateInfo(true);
        expect(good.latest).toBe('4.0.0');

        fetchMock.mockImplementation(async () => {
            throw new Error('boom');
        });
        const bad = await getUpdateInfo(true);
        expect(bad.error).toContain('boom');

        const cached = await getUpdateInfo();
        expect(cached).toBe(good);
        expect(cached.error).toBeUndefined();
        expect(fetchMock).toHaveBeenCalledTimes(3);
    });

    it('collapses concurrent checks onto one fetch', async () => {
        const pending = deferred<Response>();
        const fetchMock = mockFetch(() => pending.promise);
        const p1 = getUpdateInfo(true);
        const p2 = getUpdateInfo(true);
        expect(fetchMock).toHaveBeenCalledTimes(1);

        pending.resolve(
            jsonResponse({
                tag_name: 'v2.0.0',
                html_url: 'https://github.com/SnowLuma/SnowLuma/releases/tag/v2.0.0',
                body: 'two',
                published_at: '2026-07-01T00:00:00Z',
            }),
        );
        const [a, b] = await Promise.all([p1, p2]);
        expect(a).toEqual(b);
        expect(a).toMatchObject({
            latest: '2.0.0',
            hasUpdate: true,
            htmlUrl: 'https://github.com/SnowLuma/SnowLuma/releases/tag/v2.0.0',
            notes: 'two',
            publishedAt: '2026-07-01T00:00:00Z',
        });
        expect(fetchMock).toHaveBeenCalledTimes(1);
    });

    it('does not reuse the previous source configuration cache after a mirror change', async () => {
        const source = { mode: 'auto', mirror: '', mirrors: ['https://first.example'] } as const;
        const fetchMock = mockFetch(async () => jsonResponse({ tag_name: 'v3.0.0' }));
        const first = await checkUpdate(false, { ...source, mirrors: [...source.mirrors] });
        fetchMock.mockImplementation(async () => jsonResponse({ tag_name: 'v3.0.1' }));
        const second = await checkUpdate(false, { ...source, mirrors: ['https://second.example'] });
        expect(first.latest).toBe('3.0.0');
        expect(second.latest).toBe('3.0.1');
        expect(fetchMock).toHaveBeenCalledTimes(2);
    });
});