/**
 * BaseAdapter 单元测试（v0.4.1 测试补齐）
 * 覆盖：错误映射（mapError）、HTTP 错误识别（throwHttpError）、
 *       ContentFilterError、上下文窗口读取、fetchWithTimeout 超时与清理
 */

import { describe, it, expect, vi, afterEach } from 'vitest';
import { BaseAdapter, ContentFilterError } from '../base-adapter';
import { MetonaErrorCode, MetonaStreamEventType } from '../../types';
import type {
  IMetonaProviderAdapter,
  AdapterConfig,
  MetonaRequest,
  MetonaResponse,
  MetonaStreamEvent,
} from '../../types';

/** 测试用具体 Adapter 实现（暴露 protected 方法供测试） */
class TestAdapter extends BaseAdapter {
  readonly providerId = 'test';
  readonly supportedModels = ['test-model-a', 'test-model-b'];
  readonly supportsToolCalling = true;
  readonly supportsThinking = false;

  async send(_request: MetonaRequest): Promise<MetonaResponse> {
    throw new Error('not implemented');
  }

  async *sendStream(_request: MetonaRequest): AsyncIterable<MetonaStreamEvent> {
    // 空实现
  }

  /** 测试辅助: 暴露 protected mapError */
  mapErrorPublic(error: unknown) {
    return this.mapError(error);
  }

  /** 测试辅助: 暴露 protected throwHttpError */
  async throwHttpErrorPublic(response: Response, context: string) {
    return this.throwHttpError(response, context);
  }

  /** 测试辅助: 暴露 protected fetchWithTimeout */
  async fetchWithTimeoutPublic(url: string, init: RequestInit, timeoutMs: number) {
    return this.fetchWithTimeout(url, init, timeoutMs);
  }
}

function makeAdapter(config: Partial<AdapterConfig> = {}): TestAdapter {
  return new TestAdapter({
    provider: 'test',
    baseURL: 'https://api.test.com',
    apiKey: 'sk-test',
    defaultModel: 'test-model-a',
    ...config,
  });
}

describe('BaseAdapter — mapError 错误映射', () => {
  it('timeout 消息映射为 NETWORK_TIMEOUT 且可重试', () => {
    const adapter = makeAdapter();
    const err = adapter.mapErrorPublic(new Error('Request timeout after 30s'));
    expect(err.code).toBe(MetonaErrorCode.NETWORK_TIMEOUT);
    expect(err.retryable).toBe(true);
    expect(err.provider).toBe('test');
  });

  it('ECONNREFUSED 映射为 NETWORK_ERROR 且可重试', () => {
    const adapter = makeAdapter();
    const err = adapter.mapErrorPublic(new Error('fetch failed: ECONNREFUSED 127.0.0.1:11434'));
    expect(err.code).toBe(MetonaErrorCode.NETWORK_ERROR);
    expect(err.retryable).toBe(true);
  });

  it('HTTP 401 优先按 status code 映射为 AUTH_INVALID 且不可重试', () => {
    const adapter = makeAdapter();
    const e = new Error('API error: 401 Unauthorized');
    (e as Error & { status: number }).status = 401;
    const err = adapter.mapErrorPublic(e);
    expect(err.code).toBe(MetonaErrorCode.AUTH_INVALID);
    expect(err.retryable).toBe(false);
  });

  it('HTTP 429 映射为 RATE_LIMITED 且可重试', () => {
    const adapter = makeAdapter();
    const e = new Error('429 Too Many Requests');
    (e as Error & { status: number }).status = 429;
    const err = adapter.mapErrorPublic(e);
    expect(err.code).toBe(MetonaErrorCode.RATE_LIMITED);
    expect(err.retryable).toBe(true);
    expect(err.retryAfterMs).toBe(5000);
  });

  it('ContentFilterError 优先映射为 CONTENT_FILTERED', () => {
    const adapter = makeAdapter();
    const cf = new ContentFilterError('high risk content', 'MiMo');
    const err = adapter.mapErrorPublic(cf);
    expect(err.code).toBe(MetonaErrorCode.CONTENT_FILTERED);
    expect(err.retryable).toBe(false);
  });

  it('普通 Error 映射为 UNKNOWN 且不可重试', () => {
    const adapter = makeAdapter();
    const err = adapter.mapErrorPublic(new Error('whatever'));
    expect(err.code).toBe(MetonaErrorCode.UNKNOWN);
    expect(err.retryable).toBe(false);
  });
});

describe('BaseAdapter — throwHttpError', () => {
  function makeResponse(status: number, body: string): Response {
    return new Response(body, { status, statusText: 'Status' });
  }

  it('content_filter 错误体抛出 ContentFilterError（含 status）', async () => {
    const adapter = makeAdapter();
    const body = JSON.stringify({ error: { code: 'content_filter', message: 'high risk' } });
    await expect(
      adapter.throwHttpErrorPublic(makeResponse(400, body), 'MiMo'),
    ).rejects.toBeInstanceOf(ContentFilterError);
    try {
      await adapter.throwHttpErrorPublic(makeResponse(400, body), 'MiMo');
    } catch (e) {
      expect((e as ContentFilterError & { status: number }).status).toBe(400);
      expect((e as ContentFilterError).message).toContain('安全审核拦截');
    }
  });

  it('普通错误体抛出带 status 属性的 Error（供 isRetryableError 判断）', async () => {
    const adapter = makeAdapter();
    await expect(
      adapter.throwHttpErrorPublic(makeResponse(503, 'Service Unavailable'), 'DeepSeek'),
    ).rejects.toThrow('DeepSeek: 503');
    try {
      await adapter.throwHttpErrorPublic(makeResponse(503, ''), 'DeepSeek');
    } catch (e) {
      expect((e as Error & { status: number }).status).toBe(503);
    }
  });
});

describe('BaseAdapter — getContextWindow', () => {
  it('配置了 contextWindow 时返回配置值', () => {
    const adapter = makeAdapter({ contextWindow: 128_000 });
    expect(adapter.getContextWindow()).toBe(128_000);
  });

  it('未配置时返回保守默认值 1M', () => {
    const adapter = makeAdapter();
    expect(adapter.getContextWindow()).toBe(1_000_000);
  });
});

describe('BaseAdapter — listModels / healthCheck', () => {
  it('listModels 将 supportedModels 映射为 MetonaModelInfo', async () => {
    const adapter = makeAdapter();
    const models = await adapter.listModels();
    expect(models.map((m) => m.id)).toEqual(['test-model-a', 'test-model-b']);
  });

  it('healthCheck 成功返回 true', async () => {
    const adapter = makeAdapter();
    expect(await adapter.healthCheck()).toBe(true);
  });
});

describe('BaseAdapter — fetchWithTimeout', () => {
  afterEach(() => {
    vi.unstubAllGlobals();
    vi.restoreAllMocks();
  });

  it('正常请求返回 Response 并清理 timer', async () => {
    const adapter = makeAdapter();
    const mockResponse = new Response('{"ok":true}');
    const fetchMock = vi.fn().mockResolvedValue(mockResponse);
    vi.stubGlobal('fetch', fetchMock);

    const result = await adapter.fetchWithTimeoutPublic('https://api.test.com/v1/chat', {}, 5_000);
    expect(result).toBe(mockResponse);
    expect(fetchMock).toHaveBeenCalledOnce();
  });

  it('超时后 abort 请求（AbortError）', async () => {
    const adapter = makeAdapter();
    vi.useFakeTimers();
    const fetchMock = vi.fn(
      (_url: string, init: RequestInit) =>
        new Promise<Response>((_resolve, reject) => {
          init.signal?.addEventListener('abort', () =>
            reject(new DOMException('Aborted', 'AbortError')),
          );
        }),
    );
    vi.stubGlobal('fetch', fetchMock);

    const promise = adapter.fetchWithTimeoutPublic('https://api.test.com/v1/chat', {}, 100);
    const expectation = expect(promise).rejects.toThrow('Aborted');
    vi.advanceTimersByTime(150);
    await expectation;
    vi.useRealTimers();
  });

  it('外部 abort 信号触发请求中断', async () => {
    const adapter = makeAdapter();
    const controller = new AbortController();
    adapter.setAbortSignal(controller.signal);

    const fetchMock = vi.fn(
      (_url: string, init: RequestInit) =>
        new Promise<Response>((_resolve, reject) => {
          init.signal?.addEventListener('abort', () =>
            reject(new DOMException('Aborted', 'AbortError')),
          );
        }),
    );
    vi.stubGlobal('fetch', fetchMock);

    const promise = adapter.fetchWithTimeoutPublic('https://api.test.com/v1/chat', {}, 30_000);
    const expectation = expect(promise).rejects.toThrow('Aborted');
    controller.abort();
    await expectation;
  });
});

describe('BaseAdapter — 接口契约', () => {
  it('providerId / 能力声明符合 IMetonaProviderAdapter 契约', () => {
    const adapter: IMetonaProviderAdapter = makeAdapter();
    expect(adapter.providerId).toBe('test');
    expect(typeof adapter.send).toBe('function');
    expect(typeof adapter.sendStream).toBe('function');
    expect(typeof adapter.getContextWindow).toBe('function');
    expect(typeof adapter.setAbortSignal).toBe('function');
  });

  it('sendStream 是 AsyncGenerator（可迭代）', async () => {
    const adapter = makeAdapter();
    const events: MetonaStreamEvent[] = [];
    for await (const ev of adapter.sendStream({} as MetonaRequest)) {
      events.push(ev);
    }
    expect(events).toHaveLength(0);
    expect(MetonaStreamEventType.TEXT_DELTA).toBe('text_delta');
  });
});