import { Test, TestingModule } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import request from 'supertest';
import { AppModule } from '../../../src/app.module';
import { Broker } from '../../../src/modules/broker/broker.entity';
import { Response } from '../../../src/common/interceptors/transform.interceptor';

describe('BrokerController (e2e)', () => {
    let app: INestApplication;

    beforeAll(async () => {
        jest.setTimeout(30000);
        const moduleFixture: TestingModule = await Test.createTestingModule({
            imports: [AppModule], // 导入整个应用模块
        }).compile();

        app = moduleFixture.createNestApplication();
        await app.init(); // 初始化应用（包括所有中间件、管道、拦截器等）
    });

    afterAll(async () => {
        await app.close();
    });

    describe('POST /api/broker', () => {
        it('应该成功创建券商（完整流程）', () => {
            return request(app.getHttpServer())
                .post('/api/broker')
                .send({
                    brokerCode: 'E2E_TEST',
                    brokerName: 'E2E测试券商',
                    region: 'CN',
                    sortOrder: 1,
                    isActive: true,
                })
                .expect(201)
                .expect((res) => {
                    // 验证响应格式（经过 TransformInterceptor 处理）
                    expect(res.body).toHaveProperty('code', 0);
                    expect(res.body).toHaveProperty('message', 'success');
                    expect(res.body).toHaveProperty('data');
                    expect(res.body.data).toHaveProperty(
                        'brokerCode',
                        'E2E_TEST',
                    );
                    expect(res.body.data).toHaveProperty(
                        'brokerName',
                        'E2E测试券商',
                    );
                    expect(res.body.data).toHaveProperty('brokerId');
                });
        });

        it('应该返回 400 当数据验证失败时', () => {
            return request(app.getHttpServer())
                .post('/api/broker')
                .send({
                    // 缺少必需字段
                    brokerCode: 'TEST',
                })
                .expect(400)
                .expect((res) => {
                    // 验证错误响应格式（经过 HttpExceptionFilter 处理）
                    expect(res.body).toHaveProperty('code');
                    expect(res.body).toHaveProperty('message');
                    expect(res.body.code).not.toBe(0);
                });
        });

        it('应该返回 409 当券商代码已存在时', async () => {
            // 先创建一个券商
            await request(app.getHttpServer())
                .post('/api/broker')
                .send({
                    brokerCode: 'DUPLICATE_TEST',
                    brokerName: '重复测试',
                    region: 'CN',
                })
                .expect(201);

            // 尝试创建重复的券商
            return request(app.getHttpServer())
                .post('/api/broker')
                .send({
                    brokerCode: 'DUPLICATE_TEST',
                    brokerName: '重复测试2',
                    region: 'CN',
                })
                .expect(409)
                .expect((res) => {
                    expect(res.body.code).toBe(409);
                    expect(res.body.message).toContain('already exists');
                });
        });
    });

    describe('GET /api/broker', () => {
        it('应该返回券商列表', async () => {
            // 先创建一个券商
            const createResponse = await request(app.getHttpServer())
                .post('/api/broker')
                .send({
                    brokerCode: 'GET_TEST',
                    brokerName: '查询测试',
                    region: 'CN',
                })
                .expect(201);

            // 查询券商列表
            return request(app.getHttpServer())
                .get('/api/broker')
                .expect(200)
                .expect((res) => {
                    expect(res.body).toHaveProperty('code', 0);
                    expect(res.body).toHaveProperty('data');
                    expect(Array.isArray(res.body.data)).toBe(true);
                    // 验证创建的券商在列表中
                    const found = res.body.data.find(
                        (b: { brokerCode: string }) =>
                            b.brokerCode === 'GET_TEST',
                    );
                    expect(found).toBeDefined();
                });
        });

        it('应该支持按条件查询', async () => {
            // 先创建一个券商
            await request(app.getHttpServer())
                .post('/api/broker')
                .send({
                    brokerCode: 'QUERY_TEST',
                    brokerName: '条件查询测试',
                    region: 'CN',
                })
                .expect(201);

            // 按 brokerCode 查询
            return request(app.getHttpServer())
                .get('/api/broker?brokerCode=QUERY_TEST')
                .expect(200)
                .expect((res) => {
                    expect(res.body.code).toBe(0);
                    expect(res.body.data).toHaveLength(1);
                    expect(res.body.data[0].brokerCode).toBe('QUERY_TEST');
                });
        });
    });

    describe('GET /api/broker/:id', () => {
        it('应该返回单个券商', async () => {
            // 先创建一个券商
            const createResponse = await request(app.getHttpServer())
                .post('/api/broker')
                .send({
                    brokerCode: 'GET_ONE_TEST',
                    brokerName: '单个查询测试',
                    region: 'CN',
                })
                .expect(201);

            const brokerId = (createResponse.body as Response<Broker>).data
                .brokerId;

            // 查询单个券商
            return request(app.getHttpServer())
                .get(`/api/broker/${brokerId}`)
                .expect(200)
                .expect((res) => {
                    expect(res.body.code).toBe(0);
                    expect(res.body.data.brokerId).toBe(brokerId);
                    expect(res.body.data.brokerCode).toBe('GET_ONE_TEST');
                });
        });

        it('应该返回 404 当券商不存在时', () => {
            return request(app.getHttpServer())
                .get('/api/broker/99999')
                .expect(404)
                .expect((res) => {
                    expect(res.body.code).toBe(404);
                });
        });
    });

    describe('PATCH /api/broker/:id', () => {
        it('应该成功更新券商', async () => {
            // 先创建一个券商
            const createResponse = await request(app.getHttpServer())
                .post('/api/broker')
                .send({
                    brokerCode: 'UPDATE_TEST',
                    brokerName: '更新测试',
                    region: 'CN',
                })
                .expect(201);

            const brokerId = (createResponse.body as Response<Broker>).data
                .brokerId;

            // 更新券商
            return request(app.getHttpServer())
                .patch(`/api/broker/${brokerId}`)
                .send({
                    brokerName: '更新后的名称',
                })
                .expect(200)
                .expect((res) => {
                    expect(res.body.code).toBe(0);
                    expect(res.body.data.brokerName).toBe('更新后的名称');
                });
        });
    });

    describe('DELETE /api/broker/:id', () => {
        it('应该成功删除券商', async () => {
            // 先创建一个券商
            const createResponse = await request(app.getHttpServer())
                .post('/api/broker')
                .send({
                    brokerCode: 'DELETE_TEST',
                    brokerName: '删除测试',
                    region: 'CN',
                })
                .expect(201);

            const brokerId = (createResponse.body as Response<Broker>).data
                .brokerId;

            // 删除券商
            await request(app.getHttpServer())
                .delete(`/api/broker/${brokerId}`)
                .expect(204);

            // 验证已删除
            await request(app.getHttpServer())
                .get(`/api/broker/${brokerId}`)
                .expect(404);
        });
    });
});