import { provideHttpClient } from '@angular/common/http';
import { HttpTestingController, provideHttpClientTesting } from '@angular/common/http/testing';
import { TestBed } from '@angular/core/testing';
import { API_CONFIG } from './app.constants';
import { ApiError, ApiService } from './api.service';

describe('ApiService', () => {
  let api: ApiService;
  let http: HttpTestingController;

  beforeEach(() => {
    TestBed.configureTestingModule({ providers: [provideHttpClient(), provideHttpClientTesting()] });
    api = TestBed.inject(ApiService);
    http = TestBed.inject(HttpTestingController);
  });

  afterEach(() => http.verify());

  it('routes migrated actions through the cloud gateway and parses JSON result strings', () => {
    let actual: unknown;
    api.get('node_list', { cpage: 1 }).subscribe((response) => actual = response.result);
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.method).toBe('POST');
    expect(request.request.headers.get('X-Parse-Application-Id')).toBe(API_CONFIG.parseAppId);
    expect(request.request.body).toEqual({ params: { action: 'node_list', cpage: 1 } });
    request.flush({ retcode: 0, result: '[{"ID":1}]' });
    expect(actual).toEqual([{ ID: 1 }]);
  });

  it('keeps not-yet-migrated actions on the legacy gateway', () => {
    api.get('order_list', { cpage: 2 }).subscribe();
    const request = http.expectOne((candidate) => candidate.url.includes(API_CONFIG.endpoint) && candidate.urlWithParams.includes('action=order_list'));
    expect(request.request.method).toBe('GET');
    expect(request.request.params.get('cpage')).toBe('2');
    request.flush({ retcode: 0, result: [] });
  });

  it('nests reserved id parameters inside params', () => {
    api.get('node_get', { id: 81 }).subscribe();
    const request = http.expectOne(API_CONFIG.cloudFunctionUrl);
    expect(request.request.body).toEqual({ params: { action: 'node_get', id: 81 } });
    request.flush({ retcode: 0, result: { id: 81 } });
  });

  it('keeps addon-dependent content and product queries on the legacy gateway', () => {
    api.get('content_list', { modelId: 56, myfield2: 'UserId=42' }).subscribe();
    api.get('product_list', { cpage: 1 }).subscribe();
    const content = http.expectOne((candidate) => candidate.urlWithParams.includes('action=content_list'));
    const products = http.expectOne((candidate) => candidate.urlWithParams.includes('action=product_list'));
    expect(content.request.url).toContain(API_CONFIG.endpoint);
    expect(products.request.url).toContain(API_CONFIG.endpoint);
    content.flush({ retcode: 0, result: [] });
    products.flush({ retcode: 0, result: [] });
  });

  it('turns retcode -1 responses into ApiError', () => {
    let actual: unknown;
    api.post('user_login_passwd', {}).subscribe({ error: (error) => actual = error });
    http.expectOne(API_CONFIG.cloudFunctionUrl).flush({ retcode: -1, retmsg: '账号或密码错误', result: null }, { status: 401, statusText: 'Unauthorized' });
    http.expectOne((candidate) => candidate.urlWithParams.includes('action=user_login_passwd')).flush({ retcode: -1, retmsg: '登录失败', result: null });
    expect(actual instanceof ApiError).toBeTrue();
    expect((actual as ApiError).message).toBe('登录失败');
  });

  it('keeps a successful password login on the cloud response', () => {
    let actual: unknown;
    api.post('user_login_passwd', { name: 'tree', passwd: 'password' }).subscribe((response) => actual = response.result);
    http.expectOne(API_CONFIG.cloudFunctionUrl).flush({ retcode: 0, result: { userId: 42, sessionToken: 'r:token' } });
    http.expectNone((candidate) => candidate.url.includes(API_CONFIG.endpoint));
    expect(actual).toEqual({ userId: 42, sessionToken: 'r:token' });
  });
});