/**
 * OpenAIAdapter 独立测试（v0.6.4 P3-1 收敛后差异点）
 *
 * OpenAIAdapter 继承 OpenAICompatibleAdapter，本文件锁定 OpenAI 独有契约：
 * - 推理模型（o 系列 / gpt-5）字段路由：reasoning_effort / max_completion_tokens
 * - 推理模型拒图：ModelCapabilityError（status=400）
 * - 非推理模型 temperature / max_tokens 路由
 * - gpt-4.1 1M 上下文窗口（getContextWindow 回退链）
 * - listModels 动态 /models 合并与降级
 */

import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';

vi.mock('electron-log', () => ({
  default: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
}));

import { OpenAIAdapter } from '../openai.adapter';
import { ModelCapabilityError } from '../shared/openai-compatible-base';
import type { MetonaRequest } from '../../types';

const mockFetch = vi.fn();

function makeAdapter(model: string, overrides: Record<string, unknown> = {}): OpenAIAdapter {
  return new OpenAIAdapter({
    provider: 'openai',
    baseURL: 'https://api.openai.com/v1',
    apiKey: 'sk-test',
    defaultModel: model,
    ...overrides,
  });
}

function makeRequest(overrides?: Partial<MetonaRequest>): MetonaRequest {
  return {
    meta: {
      sessionId: 's1',
      iteration: 1,
      requestId: 'r1',
      timestamp: Date.now(),
      agentVersion: 'test',
    },
    systemPrompt: {
      roleDefinition: 'You are Metona.',
      outputConstraints: '',
      safetyGuidelines: '',
    },
    messages: [{ role: 'user', content: 'hi', timestamp: Date.now() }],
    params: { maxTokens: 4096, temperature: 0, stream: false },
    ...overrides,
  };
}

function okResponse(
  body: Record<string, unknown> = { choices: [{ message: { content: 'ok' } }] },
): Response {
  return {
    ok: true,
    status: 200,
    json: async () => body,
  } as unknown as Response;
}

function lastBody(): Record<string, unknown> {
  const call = mockFetch.mock.calls[mockFetch.mock.calls.length - 1] as [string, RequestInit];
  return JSON.parse(String(call[1].body));
}

beforeEach(() => {
  mockFetch.mockReset();
  vi.stubGlobal('fetch', mockFetch);
});

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

// ===== reasoning_effort 映射 =====

describe('OpenAIAdapter — 推理模型 reasoning_effort', () => {
  it.each([
    ['low', 'low'],
    ['medium', 'medium'],
    ['high', 'high'],
    ['max', 'high'], // max 归一 high
  ] as const)('o3-mini effort=%s → reasoning_effort=%s', async (effort, expected) => {
    const adapter = makeAdapter('o3-mini');
    mockFetch.mockResolvedValue(okResponse());
    await adapter.send(
      makeRequest({
        params: {
          maxTokens: 4096,
          temperature: 0,
          stream: false,
          thinkingEnabled: true,
          thinkingEffort: effort,
        },
      }),
    );
    expect(lastBody().reasoning_effort).toBe(expected);
  });

  it('o3-mini thinking 关闭 → 不传 reasoning_effort（可关闭服务端默认思考）', async () => {
    const adapter = makeAdapter('o3-mini');
    mockFetch.mockResolvedValue(okResponse());
    await adapter.send(
      makeRequest({
        params: { maxTokens: 4096, temperature: 0, stream: false, thinkingEnabled: false },
      }),
    );
    expect(lastBody().reasoning_effort).toBeUndefined();
  });

  it('o3-mini thinking 未配置 → 不传 reasoning_effort', async () => {
    const adapter = makeAdapter('o3-mini');
    mockFetch.mockResolvedValue(okResponse());
    await adapter.send(makeRequest({ params: { maxTokens: 4096, temperature: 0, stream: false } }));
    expect(lastBody().reasoning_effort).toBeUndefined();
  });

  it('o3-mini thinking 未配置 effort → 缺省 high', async () => {
    const adapter = makeAdapter('o3-mini');
    mockFetch.mockResolvedValue(okResponse());
    await adapter.send(
      makeRequest({
        params: { maxTokens: 4096, temperature: 0, stream: false, thinkingEnabled: true },
      }),
    );
    expect(lastBody().reasoning_effort).toBe('high');
  });

  it('非推理模型 gpt-4o 即使 thinkingEnabled=true 也不传 reasoning_effort（忽略思考参数）', async () => {
    const adapter = makeAdapter('gpt-4o');
    mockFetch.mockResolvedValue(okResponse());
    await adapter.send(
      makeRequest({
        params: { maxTokens: 4096, temperature: 0.3, stream: false, thinkingEnabled: true },
      }),
    );
    expect(lastBody().reasoning_effort).toBeUndefined();
    // 非推理模型仍传 temperature
    expect(lastBody().temperature).toBe(0.3);
  });
});

// ===== 推理模型拒图 =====

describe('OpenAIAdapter — 推理模型拒图（ModelCapabilityError）', () => {
  it.each(['o3-mini', 'o1', 'gpt-5.1'])(
    '%s 带图片 → 抛 ModelCapabilityError(status=400)',
    async (model) => {
      const adapter = makeAdapter(model);
      mockFetch.mockResolvedValue(okResponse());
      const request = makeRequest({
        messages: [
          {
            role: 'user',
            content: '看图',
            images: [{ url: 'data:image/png;base64,AAA' }],
            timestamp: Date.now(),
          },
        ],
      });
      const err = await adapter.send(request).catch((e: unknown) => e);
      expect(err).toBeInstanceOf(ModelCapabilityError);
      expect((err as ModelCapabilityError).status).toBe(400);
      expect((err as Error).message).toContain('does not support');
      // 拒图不发出网络请求
      expect(mockFetch).not.toHaveBeenCalled();
    },
  );

  it('o3-mini 无图片 → 正常发送（不误拒）', async () => {
    const adapter = makeAdapter('o3-mini');
    mockFetch.mockResolvedValue(okResponse());
    await adapter.send(makeRequest());
    expect(mockFetch).toHaveBeenCalledTimes(1);
  });

  it('非推理模型 gpt-4o 带图片 → 正常发送（多模态允许）', async () => {
    const adapter = makeAdapter('gpt-4o');
    mockFetch.mockResolvedValue(okResponse());
    await adapter.send(
      makeRequest({
        messages: [
          {
            role: 'user',
            content: '看图',
            images: [{ url: 'data:image/png;base64,AAA' }],
            timestamp: Date.now(),
          },
        ],
      }),
    );
    expect(mockFetch).toHaveBeenCalledTimes(1);
    const body = lastBody();
    // 图片转为 image_url parts
    const userMsg = (body.messages as Array<Record<string, unknown>>)[1];
    expect(userMsg.content).toEqual([
      { type: 'text', text: '看图' },
      { type: 'image_url', image_url: { url: 'data:image/png;base64,AAA' } },
    ]);
  });
});

// ===== max_completion_tokens / max_tokens 路由 =====

describe('OpenAIAdapter — token 参数路由', () => {
  it.each([
    ['o3-mini', 63_488, 63_488, 'max_completion_tokens'],
    ['o3-mini', 200_000, 100_000, 'max_completion_tokens'], // 上限 100000
    ['gpt-4o', 63_488, 16_384, 'max_tokens'],
    ['gpt-4.1', 63_488, 32_768, 'max_tokens'],
  ] as const)('%s maxTokens=%d → %s=%d', async (model, requested, expected, field) => {
    const adapter = makeAdapter(model);
    mockFetch.mockResolvedValue(okResponse());
    await adapter.send(
      makeRequest({ params: { maxTokens: requested, temperature: 0, stream: false } }),
    );
    const body = lastBody();
    expect(body[field]).toBe(expected);
    // 另一个字段不出现
    const other = field === 'max_completion_tokens' ? 'max_tokens' : 'max_completion_tokens';
    expect(body[other]).toBeUndefined();
  });

  it('o3-mini 未配置 maxTokens → 默认 32768（thinking 场景安全值）', async () => {
    const adapter = makeAdapter('o3-mini');
    mockFetch.mockResolvedValue(okResponse());
    await adapter.send(makeRequest({ params: { temperature: 0, stream: false } }));
    expect(lastBody().max_completion_tokens).toBe(32_768);
  });

  it('非推理模型未配置 maxTokens → 默认模型上限', async () => {
    const adapter = makeAdapter('gpt-4o');
    mockFetch.mockResolvedValue(okResponse());
    await adapter.send(makeRequest({ params: { temperature: 0, stream: false } }));
    expect(lastBody().max_tokens).toBe(16_384);
  });
});

// ===== temperature 传递 =====

describe('OpenAIAdapter — temperature 路由', () => {
  it('非推理模型 temperature 逐值透传', async () => {
    const adapter = makeAdapter('gpt-4o');
    mockFetch.mockResolvedValue(okResponse());
    for (const t of [0, 0.7, 1.0]) {
      await adapter.send(
        makeRequest({ params: { maxTokens: 4096, temperature: t, stream: false } }),
      );
    }
    expect(lastBody().temperature).toBe(1.0);
    const bodies = mockFetch.mock.calls.map((c) => JSON.parse(String((c[1] as RequestInit).body)));
    expect(bodies.map((b) => b.temperature)).toEqual([0, 0.7, 1.0]);
  });

  it('推理模型 o3-mini 不传 temperature（o 系列不支持）', async () => {
    const adapter = makeAdapter('o3-mini');
    mockFetch.mockResolvedValue(okResponse());
    await adapter.send(
      makeRequest({ params: { maxTokens: 4096, temperature: 0.7, stream: false } }),
    );
    expect(lastBody().temperature).toBeUndefined();
  });

  it('gpt-5 系列同样不传 temperature（推理家族）', async () => {
    const adapter = makeAdapter('gpt-5');
    mockFetch.mockResolvedValue(okResponse());
    await adapter.send(
      makeRequest({ params: { maxTokens: 4096, temperature: 0.5, stream: false } }),
    );
    expect(lastBody().temperature).toBeUndefined();
    expect(lastBody().max_completion_tokens).toBe(4096);
  });
});

// ===== getContextWindow 回退链 =====

describe('OpenAIAdapter — getContextWindow 回退链', () => {
  it('gpt-4.1 返回 1M 上下文', () => {
    expect(makeAdapter('gpt-4.1').getContextWindow()).toBe(1_000_000);
  });

  it('o3-mini 返回 200K', () => {
    expect(makeAdapter('o3-mini').getContextWindow()).toBe(200_000);
  });

  it('未知模型 → 兜底 128K（v0.7.4 P4-5 从 1M 降级）', () => {
    expect(makeAdapter('unknown-model-x').getContextWindow()).toBe(128_000);
  });

  it('config.contextWindow 显式配置优先', () => {
    const adapter = makeAdapter('gpt-4o', { contextWindow: 64_000 });
    expect(adapter.getContextWindow()).toBe(64_000);
  });
});

// ===== listModels =====

describe('OpenAIAdapter — listModels 动态发现与降级', () => {
  it('API 成功 → 合并本地元信息（已知模型带 name，未知模型裸 id）', async () => {
    mockFetch.mockResolvedValue(okResponse({ data: [{ id: 'gpt-4o' }, { id: 'custom-model' }] }));
    const models = await makeAdapter('gpt-4o').listModels();
    expect(models).toHaveLength(2);
    expect(models[0]).toMatchObject({ id: 'gpt-4o', contextWindow: 128_000 });
    expect(models[1]).toEqual({ id: 'custom-model' });
    // /models 请求头携带 Bearer
    const [, init] = mockFetch.mock.calls[0] as [string, RequestInit];
    expect((init.headers as Record<string, string>).Authorization).toBe('Bearer sk-test');
  });

  it('API 失败 → 降级到 supportedModels（带元信息）', async () => {
    mockFetch.mockRejectedValue(new Error('network'));
    const models = await makeAdapter('gpt-4o').listModels();
    expect(models.map((m) => m.id)).toEqual(['gpt-4o', 'gpt-4o-mini', 'gpt-4.1', 'o3-mini']);
  });

  it('API 返回空 data → 降级到 supportedModels', async () => {
    mockFetch.mockResolvedValue(okResponse({ data: [] }));
    const models = await makeAdapter('gpt-4o').listModels();
    expect(models).toHaveLength(4);
  });

  it('healthCheck 基于 listModels 成功返回 true', async () => {
    mockFetch.mockResolvedValue(okResponse({ data: [{ id: 'gpt-4o' }] }));
    expect(await makeAdapter('gpt-4o').healthCheck()).toBe(true);
  });
});

// ===== 非流式响应组装 =====

describe('OpenAIAdapter — 非流式响应组装', () => {
  it('send 返回 MetonaResponse（content/usage/finishReason 映射）', async () => {
    const adapter = makeAdapter('gpt-4o');
    mockFetch.mockResolvedValue(
      okResponse({
        id: 'cmpl-1',
        model: 'gpt-4o',
        choices: [{ message: { content: 'hello' }, finish_reason: 'stop' }],
        usage: { prompt_tokens: 10, completion_tokens: 5, total_tokens: 15 },
      }),
    );
    const res = await adapter.send(makeRequest());
    expect(res.content).toBe('hello');
    expect(res.finishReason).toBe('stop');
    expect(res.usage.totalTokens).toBe(15);
    expect(res.meta.provider).toBe('openai');
  });

  it('HTTP 非 2xx → 抛出带 status 的 Error', async () => {
    const adapter = makeAdapter('gpt-4o');
    mockFetch.mockResolvedValue({
      ok: false,
      status: 429,
      statusText: 'Too Many Requests',
      text: async () => '{"error":{"message":"rate limited"}}',
    } as unknown as Response);
    const err = await adapter.send(makeRequest()).catch((e: unknown) => e);
    expect((err as Error & { status?: number }).status).toBe(429);
  });

  it('content_filter 错误体 → ContentFilterError 实例', async () => {
    const adapter = makeAdapter('gpt-4o');
    mockFetch.mockResolvedValue({
      ok: false,
      status: 400,
      statusText: 'Bad Request',
      text: async () => '{"error":{"code":"content_filter","message":"blocked"}}',
    } as unknown as Response);
    const err = await adapter.send(makeRequest()).catch((e: unknown) => e);
    expect((err as { name: string }).name).toBe('ContentFilterError');
  });

  it('sendStream 走 SSE 解析（[DONE] 结束）', async () => {
    const adapter = makeAdapter('gpt-4o');
    const payload =
      'data: {"choices":[{"delta":{"content":"hi"}}]}\n\n' +
      'data: {"choices":[{"delta":{"content":""},"finish_reason":"stop"}]}\n\n' +
      'data: [DONE]\n\n';
    const body = new ReadableStream<Uint8Array>({
      start(controller) {
        controller.enqueue(new TextEncoder().encode(payload));
        controller.close();
      },
    });
    mockFetch.mockResolvedValue(new Response(body, { status: 200 }));
    const events: string[] = [];
    for await (const ev of adapter.sendStream(makeRequest({ params: { stream: true } }))) {
      events.push(ev.type);
    }
    expect(events[0]).toBe('text_delta');
    expect(events[events.length - 1]).toBe('done');
  });
});

// ===== stop 序列 =====

describe('OpenAIAdapter — stop 序列透传', () => {
  it('stopSequences 透传为 stop 数组（o 系列已知边界透传）', async () => {
    const adapter = makeAdapter('gpt-4o');
    mockFetch.mockResolvedValue(okResponse());
    await adapter.send(
      makeRequest({
        params: { maxTokens: 4096, temperature: 0, stream: false, stopSequences: ['END'] },
      }),
    );
    expect(lastBody().stop).toEqual(['END']);
  });

  it('未配置 stopSequences 不发送 stop', async () => {
    const adapter = makeAdapter('gpt-4o');
    mockFetch.mockResolvedValue(okResponse());
    await adapter.send(makeRequest());
    expect(lastBody().stop).toBeUndefined();
  });
});