import fs from 'node:fs';
import path from 'node:path';

import { Hono } from 'hono';
import { afterEach, assert, describe, expect, it, vi } from 'vitest';

import app from '@/app';
import { config } from '@/config';
import registryApp, { collectNamespaceRoots, namespaces, resolveModuleNamespace, sortRoutes } from '@/registry';
import type { Data } from '@/types';

// The dev registry lists lib/routes at startup; expose the fixture directory names there
const fakeTopDirectories = vi.hoisted(() => {
    const names: string[] = [];
    return { names };
});

const fsReaddirSync = fs.readdirSync;
vi.spyOn(fs, 'readdirSync').mockImplementation(((...args: Parameters<typeof fs.readdirSync>) => {
    if (fakeTopDirectories.names.length > 0 && String(args[0]).endsWith(path.join('lib', 'routes'))) {
        return fakeTopDirectories.names.map((name) => ({ name, isDirectory: () => true }));
    }
    return fsReaddirSync(...args);
}) as typeof fs.readdirSync);

describe('registry', () => {
    // root
    it('/', async () => {
        const response = await app.request('/');
        expect(response.status).toBe(200);
        expect(response.headers.get('content-type')).toBe('text/html; charset=UTF-8');
        expect(response.headers.get('cache-control')).toBe('no-cache');
    });

    // robots.txt
    it('/robots.txt', async () => {
        config.disallowRobot = false;
        const response404 = await app.request('/robots.txt');
        expect(response404.status).toBe(404);

        config.disallowRobot = true;
        const response = await app.request('/robots.txt');
        expect(response.status).toBe(200);
        expect(await response.text()).toBe('User-agent: *\nDisallow: /');
        expect(response.headers.get('content-type')).toBe('text/plain; charset=UTF-8');
    });

    // favicon.ico
    it('/favicon.ico', async () => {
        const response = await app.request('/favicon.ico');
        expect(response.status).toBe(200);
    });

    // healthz
    it('/healthz', async () => {
        const response = await app.request('/healthz');
        expect(response.status).toBe(200);
        expect(response.headers.get('cache-control')).toBe('no-cache');
        expect(await response.text()).toBe('ok');
    });

    it('namespaces respects DISABLE_NSFW=true', async () => {
        vi.resetModules();
        vi.stubEnv('DISABLE_NSFW', 'true');

        const { namespaces } = await import('./registry');
        // @ts-ignore build artifact of pnpm build:routes
        const routesModule = await import('../assets/build/routes.json');
        const rawNamespaces = (routesModule.default ?? routesModule) as Record<string, { routes?: Record<string, { features?: { nsfw?: boolean } }> }>;
        const nsfwNamespaces = Object.entries(rawNamespaces).filter(([, namespace]) => Object.values(namespace.routes ?? {}).some((route) => route.features?.nsfw));

        // All routes in all namespaces should not have nsfw features
        for (const ns of Object.values(namespaces)) {
            for (const route of Object.values(ns.routes)) {
                expect(route.features?.nsfw).not.toBe(true);
            }
        }
        expect(nsfwNamespaces.length).toBeGreaterThan(0);
        for (const [key] of nsfwNamespaces) {
            expect(namespaces[key]).toBeUndefined();
        }
    });

    it('namespaces includes NSFW routes when DISABLE_NSFW=false', async () => {
        vi.resetModules();
        vi.stubEnv('DISABLE_NSFW', 'false');

        const { namespaces } = await import('./registry');
        expect(namespaces['2048']).toBeDefined();
    });
});

describe('namespace-resolution', () => {
    const keys = [
        '/github/namespace.ts',
        '/github/issue.ts',
        '/example/sub/namespace.ts',
        '/example/sub/news.ts',
        '/example/flat/typical.ts',
        '/example/nested/namespace.ts',
        '/example/nested/zzb.ts',
        '/example/nested/deep/namespace.ts',
        '/example/nested/deep/zwfw.ts',
    ];
    const roots = collectNamespaceRoots(keys);

    it('collects directories containing namespace.ts', () => {
        expect(roots).toEqual(new Set(['github', 'example/sub', 'example/nested', 'example/nested/deep']));
    });

    it('resolves a flat module to its top directory', () => {
        expect(resolveModuleNamespace('/github/issue.ts', roots)).toEqual({ namespace: 'github', location: 'issue.ts' });
    });

    it('resolves a nested module to its namespace root', () => {
        expect(resolveModuleNamespace('/example/sub/news.ts', roots)).toEqual({ namespace: 'example/sub', location: 'news.ts' });
    });

    it('prefers the deepest matching root', () => {
        expect(resolveModuleNamespace('/example/nested/deep/zwfw.ts', roots)).toEqual({ namespace: 'example/nested/deep', location: 'zwfw.ts' });
        expect(resolveModuleNamespace('/example/nested/zzb.ts', roots)).toEqual({ namespace: 'example/nested', location: 'zzb.ts' });
    });

    it('falls back to the first segment when no root matches', () => {
        expect(resolveModuleNamespace('/example/flat/typical.ts', roots)).toEqual({ namespace: 'example', location: 'flat/typical.ts' });
    });

    it('resolves namespace.ts itself to its own root', () => {
        expect(resolveModuleNamespace('/example/sub/namespace.ts', roots)).toEqual({ namespace: 'example/sub', location: 'namespace.ts' });
    });
});

describe('nested namespace mounting', () => {
    it('registers deeper namespaces before shallower ones', () => {
        const keys = Object.keys(namespaces).filter((key) => Object.keys(namespaces[key].routes ?? {}).length > 0);
        const byDepth = keys.toSorted((a, b) => b.split('/').length - a.split('/').length);
        const deep = byDepth[0];
        const shallow = byDepth.at(-1);
        assert(shallow);
        expect(deep.split('/').length).toBeGreaterThan(shallow.split('/').length);

        const paths = registryApp.routes.map((r) => r.path);
        const deepIndex = paths.indexOf(`/${deep}${Object.keys(namespaces[deep].routes)[0]}`);
        const shallowIndex = paths.indexOf(`/${shallow}${Object.keys(namespaces[shallow].routes)[0]}`);
        expect(deepIndex).toBeGreaterThanOrEqual(0);
        expect(shallowIndex).toBeGreaterThanOrEqual(0);
        expect(deepIndex).toBeLessThan(shallowIndex);
    });
});

const sortPaths = (paths: string[]) => sortRoutes(Object.fromEntries(paths.map((path) => [path, { path, name: path, maintainers: [], example: path, handler: () => null, location: path }]))).map(([path]) => path);
const permutations = (items: string[]): string[][] => (items.length <= 1 ? [items] : items.flatMap((item, i) => permutations(items.toSpliced(i, 1)).map((rest) => [item, ...rest])));

describe('sortRoutes', () => {
    it('sorts regex-constrained params before plain params', () => {
        expect(sortPaths(['/:category?', '/:id{[0-9]+}', '/static'])).toEqual(['/static', '/:id{[0-9]+}', '/:category?']);
    });

    // sehuatang, https://github.com/DIYgod/RSSHub/issues/18335
    it('sorts literal segments before params when an empty path is present', () => {
        expect(sortPaths(['/bt/:subforumid?', '/picture/:subforumid', '/:subforumid?/:type?', '/:subforumid?', '', '/user/:uid'])).toEqual([
            '',
            '/bt/:subforumid?',
            '/picture/:subforumid',
            '/user/:uid',
            '/:subforumid?',
            '/:subforumid?/:type?',
        ]);
    });

    // gcores
    it('sorts literal segments before params among unrelated literal routes', () => {
        expect(
            sortPaths([
                '/radios/:category?',
                '/users/:id/radios',
                '/users/:id/talks',
                '/articles',
                '/categories/:id/:tab?',
                '/collections/:id/:tab?',
                '/news',
                '/radios/preview',
                '/tags/:id/:tab?',
                '/topics/:id/recommend',
                '/topics/recommend',
                '/videos',
            ])
        ).toEqual([
            '/articles',
            '/news',
            '/videos',
            '/radios/preview',
            '/topics/recommend',
            '/radios/:category?',
            '/users/:id/radios',
            '/users/:id/talks',
            '/topics/:id/recommend',
            '/categories/:id/:tab?',
            '/collections/:id/:tab?',
            '/tags/:id/:tab?',
        ]);
    });

    it('sorts the path that runs out of segments first unless it ends with a regex param', () => {
        expect(sortPaths(['/news/:category?', '/news'])).toEqual(['/news', '/news/:category?']);
        // discuz: `.+` spans segments, so `/:link{.+}` would shadow the longer paths
        expect(sortPaths(['/:link{.+}', '/:ver{[7x]}/:link{.+}', '/:ver{[7x]}/:cid{[0-9]{2}}/:link{.+}'])).toEqual(['/:ver{[7x]}/:cid{[0-9]{2}}/:link{.+}', '/:ver{[7x]}/:link{.+}', '/:link{.+}']);
    });

    it('does not depend on the input order', () => {
        const expected = ['', '/radios/preview', '/user/:uid', '/:subforumid?', '/:subforumid?/:type?'];
        for (const paths of permutations(expected)) {
            expect(sortPaths(paths)).toEqual(expected);
        }
    });
});

type FakeRouteModule = {
    route: {
        path: string | string[];
        name: string;
        handler?: () => Data;
        module?: () => Promise<{ route: { handler: () => Response } }>;
    };
};

type FakeApiRouteModule = {
    apiRoute: {
        path: string;
        name: string;
        handler?: () => { ok: boolean };
        module?: () => Promise<{ apiRoute: { handler: () => { ok: boolean } } }>;
    };
};

const perDirectoryMock = (fakeDirectories: Record<string, Record<string, FakeRouteModule | FakeApiRouteModule>>) => {
    fakeTopDirectories.names = Object.keys(fakeDirectories);
    return vi.fn(({ targetDirectoryPath }: { targetDirectoryPath: string }) => {
        const name = path.basename(targetDirectoryPath);
        return Promise.resolve(fakeDirectories[name]);
    });
};

const wrap = (registry: Hono) => {
    const app = new Hono<{ Variables: { data: Data; apiData: { ok: boolean } | { code: number } } }>();
    app.use(async (ctx, next) => {
        const response = await next();
        const apiData = ctx.get('apiData');
        if (apiData) {
            return ctx.json(apiData);
        }
        const data = ctx.get('data');
        if (data) {
            return ctx.json(data);
        }
        return response;
    });
    app.route('/', registry);
    return app;
};

describe('registry dynamic loading', () => {
    afterEach(() => {
        fakeTopDirectories.names = [];
    });

    it('loads production namespaces from build', async () => {
        const originalEnv = process.env.NODE_ENV;
        process.env.NODE_ENV = 'production';
        vi.resetModules();

        const { namespaces } = await import('@/registry');
        expect(Object.keys(namespaces).length).toBeGreaterThan(0);

        process.env.NODE_ENV = originalEnv;
    });

    it('lazily builds namespaces from directory import on first request', async () => {
        const originalEnv = process.env.NODE_ENV;
        process.env.NODE_ENV = 'development';

        const directoryImportMock = perDirectoryMock({
            nsRoute: {
                '/route-array.ts': {
                    route: {
                        path: ['/a', '/b'],
                        name: 'Array',
                        handler: () => ({ title: 'array', link: 'https://example.com', item: [], allowEmpty: true }),
                    },
                },
                '/route-single.ts': {
                    route: {
                        path: '/single',
                        name: 'Single',
                        handler: () => ({ title: 'ok', link: 'https://example.com', item: [], allowEmpty: true }),
                    },
                },
            },
            nsModule: {
                '/route-module.ts': {
                    route: {
                        path: '/module',
                        name: 'Module',
                        module: () =>
                            Promise.resolve({
                                route: {
                                    handler: () => new Response('module'),
                                },
                            }),
                    },
                },
            },
            nsApi: {
                '/api-single.ts': {
                    apiRoute: {
                        path: '/single',
                        name: 'ApiSingle',
                        handler: () => ({ ok: true }),
                    },
                },
                '/api-module.ts': {
                    apiRoute: {
                        path: '/module',
                        name: 'ApiModule',
                        module: () =>
                            Promise.resolve({
                                apiRoute: {
                                    handler: () => ({ ok: true }),
                                },
                            }),
                    },
                },
            },
            test: {
                '/api-index.ts': {
                    apiRoute: {
                        path: '/',
                        name: 'ApiIndex',
                    },
                },
            },
        });
        vi.doMock('@/utils/directory-import', () => ({
            directoryImport: directoryImportMock,
        }));
        vi.resetModules();
        const { namespaces, default: registry } = await import('@/registry');

        // The cold-start guarantee: importing the registry imports no route modules
        expect(directoryImportMock).not.toHaveBeenCalled();

        const app = wrap(registry);

        const routeResponse = await app.request('/nsModule/module');
        expect(await routeResponse.text()).toBe('module');
        expect(directoryImportMock).toHaveBeenCalledTimes(1);

        const singleResponse = await app.request('/nsRoute/single');
        const singleBody = await singleResponse.json();
        expect(singleBody.title).toBe('ok');
        expect(namespaces.nsRoute.routes['/single']).toBeDefined();
        expect(namespaces.nsRoute.routes['/a']).toBeDefined();

        const apiResponse = await app.request('/api/nsApi/module');
        const apiBody = await apiResponse.json();
        expect(apiBody).toEqual({ ok: true });
        expect(namespaces.nsApi.apiRoutes['/single']).toBeDefined();

        // Handler resolution from disk in test env (real file lib/routes/test/api-index.ts)
        process.env.NODE_ENV = 'test';
        const apiTestResponse = await app.request('/api/test');
        expect(await apiTestResponse.json()).toEqual({ code: 0 });

        process.env.NODE_ENV = originalEnv;
        vi.doUnmock('@/utils/directory-import');
    });

    // https://github.com/DIYgod/RSSHub/pull/18002
    it('prioritizes literal segments over parameter segments in route matching', async () => {
        const originalEnv = process.env.NODE_ENV;
        process.env.NODE_ENV = 'development';

        const directoryImportMock = perDirectoryMock({
            specificity: {
                '/param-route.ts': {
                    route: {
                        path: '/:category',
                        name: 'ParamRoute',
                        handler: () => ({ title: 'param', link: 'https://example.com', item: [], allowEmpty: true }),
                    },
                },
                '/literal-route.ts': {
                    route: {
                        path: '/news/:channel',
                        name: 'LiteralRoute',
                        handler: () => ({ title: 'literal', link: 'https://example.com', item: [], allowEmpty: true }),
                    },
                },
                '/news-route.ts': {
                    route: {
                        path: '/news',
                        name: 'NewsRoute',
                        handler: () => ({ title: 'news', link: 'https://example.com', item: [], allowEmpty: true }),
                    },
                },
            },
        });
        vi.doMock('@/utils/directory-import', () => ({
            directoryImport: directoryImportMock,
        }));
        vi.resetModules();
        const { default: registry } = await import('@/registry');

        const app = wrap(registry);

        // /news/sports should match /news/:channel (literal "news" wins over :category)
        const literalResponse = await app.request('/specificity/news/sports');
        expect((await literalResponse.json()).title).toBe('literal');

        // /news should match /news (literal wins over :category)
        const newsResponse = await app.request('/specificity/news');
        expect((await newsResponse.json()).title).toBe('news');

        // /products should match /:category
        const paramResponse = await app.request('/specificity/products');
        expect((await paramResponse.json()).title).toBe('param');

        process.env.NODE_ENV = originalEnv;
        vi.doUnmock('@/utils/directory-import');
    });
});