import { mkdtemp, rm, writeFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join } from 'node:path';

import {
  IConfigService,
  IModelCatalog,
  IOAuthService,
  IProviderDiscoveryService,
  type IModelCatalog as IModelCatalogType,
  type IOAuthService as IOAuthServiceType,
  type IProviderDiscoveryService as IProviderDiscoveryServiceType,
  type ModelCatalogConfig,
  type ScopeSeed,
} from '@moonshot-ai/agent-core-v2';
import { afterAll, afterEach, beforeAll, describe, expect, it, vi } from 'vitest';

import { type RunningServer, startServer } from '../src/start';
import { TEST_HOST_IDENTITY } from './helpers/hostIdentity';
import { authHeaders } from './helpers/auth';

interface Envelope<T> {
  code: number;
  msg: string;
  data: T;
  request_id: string;
}

const CATALOG_TOML = [
  'default_model = "k2"',
  '',
  '[providers.kimi]',
  'type = "kimi"',
  'api_key = "sk-test"',
  'base_url = "https://api.example.test/v1"',
  '',
  '[providers.openai]',
  'type = "openai"',
  '',
  '[models.k2]',
  'provider = "kimi"',
  'model = "kimi-k2"',
  'max_context_size = 131072',
  'display_name = "Kimi K2"',
  'capabilities = ["thinking"]',
  '',
  '[models.turbo]',
  'provider = "kimi"',
  'model = "kimi-turbo"',
  'max_context_size = 32768',
  'display_name = "Kimi Turbo"',
  '',
  '[models.gpt4o]',
  'provider = "openai"',
  'model = "gpt-4o"',
  'max_context_size = 128000',
  '',
].join('\n');

describe('server-v2 /api/v1 model/provider catalog', () => {
  let server: RunningServer | undefined;
  let active: RunningServer | undefined;
  const alts: RunningServer[] = [];
  let home: string | undefined;
  let base: string;

  beforeAll(async () => {
    home = await mkdtemp(join(tmpdir(), 'kimi-server-v2-model-catalog-'));
    process.env['KIMI_CODE_MODEL_CATALOG_REFRESH_ON_START'] = '0';
    process.env['KIMI_CODE_MODEL_CATALOG_REFRESH_INTERVAL_MS'] = '0';
    server = await startServer({
      hostIdentity: TEST_HOST_IDENTITY,
      host: '127.0.0.1',
      port: 0,
      homeDir: home,
      logLevel: 'silent',
    });
    active = server;
    base = `http://127.0.0.1:${server.port}`;
  });

  afterEach(async () => {
    for (const alt of alts.splice(0)) {
      await alt.close();
    }
    active = server;
    base = `http://127.0.0.1:${(server as RunningServer).port}`;
  });

  afterAll(async () => {
    if (server !== undefined) {
      await server.close();
      server = undefined;
      active = undefined;
    }
    if (home !== undefined) {
      await rm(home, { recursive: true, force: true });
      home = undefined;
    }
    delete process.env['KIMI_CODE_MODEL_CATALOG_REFRESH_ON_START'];
    delete process.env['KIMI_CODE_MODEL_CATALOG_REFRESH_INTERVAL_MS'];
  });

  async function boot(toml?: string, seeds?: ScopeSeed): Promise<void> {
    if (toml !== undefined) {
      await writeFile(join(home as string, 'config.toml'), toml, 'utf-8');
    }
    if (seeds !== undefined) {
      const alt = await startServer({
        hostIdentity: TEST_HOST_IDENTITY,
        host: '127.0.0.1',
        port: 0,
        homeDir: home,
        logLevel: 'silent',
        seeds,
      });
      alts.push(alt);
      active = alt;
    } else {
      await (server as RunningServer).core.accessor.get(IConfigService).reload();
      active = server;
    }
    base = `http://127.0.0.1:${(active as RunningServer).port}`;
  }

  async function getJson<T>(path: string): Promise<{ status: number; body: Envelope<T> }> {
    const res = await fetch(`${base}${path}`, {
      headers: authHeaders(active as RunningServer),
    } as never);
    return { status: res.status, body: (await res.json()) as Envelope<T> };
  }

  async function postJson<T>(
    path: string,
    body?: unknown,
  ): Promise<{ status: number; body: Envelope<T> }> {
    const res = await fetch(`${base}${path}`, {
      method: 'POST',
      headers: authHeaders(
        active as RunningServer,
        body === undefined ? {} : { 'content-type': 'application/json' },
      ),
      body: body === undefined ? undefined : JSON.stringify(body),
    } as never);
    return { status: res.status, body: (await res.json()) as Envelope<T> };
  }

  it('lists configured models as selectable aliases', async () => {
    await boot(CATALOG_TOML);
    const { status, body } = await getJson<{ items: unknown[] }>('/api/v1/models');
    expect(status).toBe(200);
    expect(body.code).toBe(0);
    expect(body.data.items).toEqual([
      {
        provider: 'kimi',
        model: 'k2',
        display_name: 'Kimi K2',
        max_context_size: 131072,
        capabilities: ['thinking'],
      },
      {
        provider: 'kimi',
        model: 'turbo',
        display_name: 'Kimi Turbo',
        max_context_size: 32768,
      },
      {
        provider: 'openai',
        model: 'gpt4o',
        display_name: 'gpt-4o',
        max_context_size: 128000,
      },
    ]);
  });

  it('lists models without refreshing providers', async () => {
    const refreshProviderModels = vi.fn(async () => ({
      changed: [],
      unchanged: [],
      failed: [],
    }));
    const seeds = [
      [IModelCatalog, catalogStub()],
      [IProviderDiscoveryService, discoveryStub(refreshProviderModels)],
    ] as unknown as ScopeSeed;
    await boot(CATALOG_TOML, seeds);

    const { status, body } = await getJson<{ items: unknown[] }>('/api/v1/models');
    expect(status).toBe(200);
    expect(body.code).toBe(0);
    expect(body.data.items).toEqual([]);
    expect(refreshProviderModels).not.toHaveBeenCalled();
  });

  it('lists providers and returns a single provider by id', async () => {
    await boot(CATALOG_TOML);
    const list = await getJson<{ items: unknown[] }>('/api/v1/providers');
    expect(list.body.code).toBe(0);
    expect(list.body.data.items).toEqual([
      {
        id: 'kimi',
        type: 'kimi',
        base_url: 'https://api.example.test/v1',
        default_model: 'k2',
        has_api_key: true,
        status: 'connected',
        models: ['k2', 'turbo'],
      },
      {
        id: 'openai',
        type: 'openai',
        has_api_key: false,
        status: 'unconfigured',
        models: ['gpt4o'],
      },
    ]);

    const single = await getJson<unknown>('/api/v1/providers/kimi');
    expect(single.body.code).toBe(0);
    expect(single.body.data).toEqual({
      id: 'kimi',
      type: 'kimi',
      base_url: 'https://api.example.test/v1',
      default_model: 'k2',
      has_api_key: true,
      status: 'connected',
      models: ['k2', 'turbo'],
      api_key: 'sk-test',
    });

    const noKey = await getJson<Record<string, unknown>>('/api/v1/providers/openai');
    expect(noKey.body.code).toBe(0);
    expect(noKey.body.data).not.toHaveProperty('api_key');
  });

  it('sets the global default model and reflects it in /config', async () => {
    await boot(CATALOG_TOML);
    const { body } = await postJson<unknown>('/api/v1/models/turbo:set_default', {});
    expect(body.code).toBe(0);
    expect(body.data).toEqual({
      default_model: 'turbo',
      model: {
        provider: 'kimi',
        model: 'turbo',
        display_name: 'Kimi Turbo',
        max_context_size: 32768,
      },
    });

    const config = await getJson<{ default_model: string | null }>('/api/v1/config');
    expect(config.body.code).toBe(0);
    expect(config.body.data.default_model).toBe('turbo');
  });

  it('maps unknown provider and model ids to catalog not-found codes', async () => {
    await boot(CATALOG_TOML);
    const provider = await getJson<unknown>('/api/v1/providers/missing');
    expect(provider.body.code).toBe(40412);

    const model = await postJson<unknown>('/api/v1/models/missing:set_default', {});
    expect(model.body.code).toBe(40413);
  });

  it('returns an empty refresh result through the catalog route', async () => {
    await boot(CATALOG_TOML);
    const { status, body } = await postJson<{
      changed: unknown[];
      unchanged: unknown[];
      failed: unknown[];
    }>('/api/v1/providers:refresh_oauth', {});
    expect(status).toBe(200);
    expect(body.code).toBe(0);
    expect(body.data).toEqual({ changed: [], unchanged: [], failed: [] });
  });

  it('returns an empty refresh result through the providers:refresh route', async () => {
    await boot(CATALOG_TOML);
    const { status, body } = await postJson<{
      changed: unknown[];
      unchanged: unknown[];
      failed: unknown[];
    }>('/api/v1/providers:refresh', {});
    expect(status).toBe(200);
    expect(body.code).toBe(0);
    expect(body.data).toEqual({ changed: [], unchanged: [], failed: [] });
  });

  function catalogStub(): IModelCatalogType {
    return {
      _serviceBrand: undefined,
      get: () => {
        throw new Error('unused');
      },
      getRequester: () => {
        throw new Error('unused');
      },
      generate: () => {
        throw new Error('unused');
      },
      ping: async () => {
        throw new Error('unused');
      },
      findByName: () => [],
      listModels: async () => [],
      listProviders: async () => [],
      getProvider: async () => {
        throw new Error('unused');
      },
      setDefaultModel: async () => {
        throw new Error('unused');
      },
    };
  }

  function discoveryStub(
    refreshProviderModels: IProviderDiscoveryServiceType['refreshProviderModels'],
  ): IProviderDiscoveryServiceType {
    return { _serviceBrand: undefined, refreshProviderModels };
  }

  function oauthStub(
    refreshOAuthProviderModels: IOAuthServiceType['refreshOAuthProviderModels'],
  ): IOAuthServiceType {
    return {
      _serviceBrand: undefined,
      startLogin: async () => {
        throw new Error('unused');
      },
      getFlow: () => undefined,
      cancelLogin: async () => {
        throw new Error('unused');
      },
      logout: async () => {
        throw new Error('unused');
      },
      status: async () => ({ loggedIn: false }),
      refreshOAuthProviderModels,
      getManagedUsage: async () => ({ kind: 'error' as const, message: 'unused' }),
      getManagedUserInfo: async () => ({ kind: 'error' as const, message: 'unused' }),
      resolveTokenProvider: () => undefined,
      getCachedAccessToken: async () => undefined,
      getRegion: () => 'mainland-cn',
    };
  }

  it('refreshes OAuth provider models through POST /providers:refresh_oauth', async () => {
    const refreshOAuthProviderModels = vi.fn(async () => ({
      changed: [
        { provider_id: 'managed:kimi-code', provider_name: 'Kimi Code', added: 1, removed: 0 },
      ],
      unchanged: [],
      failed: [],
    }));
    const seeds = [[IOAuthService, oauthStub(refreshOAuthProviderModels)]] as unknown as ScopeSeed;
    await boot(CATALOG_TOML, seeds);

    const { status, body } = await postJson<{
      changed: unknown[];
      unchanged: unknown[];
      failed: unknown[];
    }>('/api/v1/providers:refresh_oauth', {});

    expect(status).toBe(200);
    expect(body.code).toBe(0);
    expect(body.data).toEqual({
      changed: [
        { provider_id: 'managed:kimi-code', provider_name: 'Kimi Code', added: 1, removed: 0 },
      ],
      unchanged: [],
      failed: [],
    });
    expect(refreshOAuthProviderModels).toHaveBeenCalledTimes(1);
  });

  it('refreshes all provider models through POST /providers:refresh', async () => {
    const refreshProviderModels = vi.fn(async () => ({
      changed: [
        { provider_id: 'managed:kimi-code', provider_name: 'Kimi Code', added: 2, removed: 1 },
      ],
      unchanged: ['moonshot-cn'],
      failed: [],
    }));
    const seeds = [[IProviderDiscoveryService, discoveryStub(refreshProviderModels)]] as unknown as ScopeSeed;
    await boot(CATALOG_TOML, seeds);

    const { status, body } = await postJson('/api/v1/providers:refresh', {});
    expect(status).toBe(200);
    expect(body.code).toBe(0);
    expect(refreshProviderModels).toHaveBeenCalledWith({ scope: 'all' });
  });

  it('refreshes a single provider through POST /providers/{id}:refresh', async () => {
    const refreshProviderModels = vi.fn(async () => ({
      changed: [],
      unchanged: [],
      failed: [],
    }));
    const seeds = [[IProviderDiscoveryService, discoveryStub(refreshProviderModels)]] as unknown as ScopeSeed;
    await boot(CATALOG_TOML, seeds);

    const { status, body } = await postJson('/api/v1/providers/managed%3Akimi-code:refresh', {});
    expect(status).toBe(200);
    expect(body.code).toBe(0);
    expect(refreshProviderModels).toHaveBeenCalledWith({ providerId: 'managed:kimi-code' });
  });

  it('rejects unsupported provider actions with 40001', async () => {
    const refreshProviderModels = vi.fn(async () => ({
      changed: [],
      unchanged: [],
      failed: [],
    }));
    const seeds = [[IProviderDiscoveryService, discoveryStub(refreshProviderModels)]] as unknown as ScopeSeed;
    await boot(CATALOG_TOML, seeds);

    const { body } = await postJson('/api/v1/providers/foo:bogus', {});
    expect(body.code).toBe(40001);
    expect(refreshProviderModels).not.toHaveBeenCalled();
  });

  it('loads the [model_catalog] config section from TOML', async () => {
    await boot(
      ['[model_catalog]', 'refresh_interval_ms = 1000', 'refresh_on_start = false', ''].join('\n'),
    );
    const cfg = server!.core.accessor.get(IConfigService);
    await cfg.ready;
    const value = cfg.get<ModelCatalogConfig | undefined>('modelCatalog');
    expect(value).toEqual({ refreshIntervalMs: 1000, refreshOnStart: false });
  });
});