const assert = require('assert');
const http = require('http');
const {
    HighlightValidationError,
    recordingTaskService
} = require('../services/recordingTaskService');
const app = require('../app');

function request(server, route, body) {
    return new Promise((resolve, reject) => {
        const address = server.address();
        const payload = JSON.stringify(body || {});
        const req = http.request({
            host: '127.0.0.1',
            port: address.port,
            path: route,
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Content-Length': Buffer.byteLength(payload)
            }
        }, response => {
            let data = '';
            response.setEncoding('utf8');
            response.on('data', chunk => { data += chunk; });
            response.on('end', () => resolve({ status: response.statusCode, body: JSON.parse(data) }));
        });
        req.on('error', reject);
        req.write(payload);
        req.end();
    });
}

async function run() {
    const server = http.createServer(app);
    await new Promise(resolve => server.listen(0, '127.0.0.1', resolve));
    const originalAcceptTasks = recordingTaskService.acceptTasks;
    const originalGetFileResult = recordingTaskService.getFileResult;
    const originalRunScheduledTaskPull = recordingTaskService.runScheduledTaskPull;
    let acceptedCalls = 0;
    let fileCalls = 0;
    const acceptedBodies = [];
    try {
        recordingTaskService.acceptTasks = async (body, handlers) => {
            acceptedCalls += 1;
            acceptedBodies.push(body);
            assert.strictEqual(typeof handlers.recordFullClass, 'function');
            return { accepted: 1, duplicates: 0, noMedia: 0 };
        };
        recordingTaskService.getFileResult = async body => {
            fileCalls += 1;
            assert.strictEqual(body.classId, '1001');
            return {
                code: 0,
                message: '文件已生成',
                fileExists: true,
                onlyHighlight: 1,
                files: [{ type: 'highlight', highlightId: 5, url: 'https://example/highlight.mp4' }]
            };
        };
        recordingTaskService.runScheduledTaskPull = async handlers => {
            assert.strictEqual(typeof handlers.recordFullClass, 'function');
            return {
                received: 3,
                taskCount: 3,
                pages: 1,
                inspected: 3,
                accepted: 2,
                duplicates: 1,
                noMedia: 0,
                invalid: 0,
                limited: false
            };
        };

        const oldTask = await request(server, '/recordingTask', {});
        assert.strictEqual(oldTask.status, 200);
        assert.strictEqual(oldTask.body.code, '1');
        assert.strictEqual(acceptedCalls, 0, '旧任务接口不得进入 V2 服务');

        const highTask = await request(server, '/recordingTaskV2', {
            list: [{
                id: 'task-high-1',
                siteId: 'doctest',
                meetingNumber: '1001',
                beginTime: '2026-08-05 10:00:00',
                endTime: '2026-08-05 11:00:00',
                onlyHighlight: 1
            }]
        });
        assert.strictEqual(highTask.status, 200);
        assert.deepStrictEqual(highTask.body, {
            code: '0',
            message: 'success',
            accepted: 1,
            duplicates: 0,
            noMedia: 0,
            v: 'v1.2.0.20251208'
        });
        assert.strictEqual(acceptedBodies[0].list[0].onlyHighlight, 1);

        const compatibleFullTask = await request(server, '/recordingTaskV2', {
            list: [{ siteId: 'doctest', classId: '1001', yymmdd: '20260805' }]
        });
        assert.strictEqual(compatibleFullTask.status, 200);
        assert.strictEqual(compatibleFullTask.body.code, '0');
        assert.strictEqual(acceptedCalls, 2);
        assert.strictEqual(acceptedBodies[1].list[0].onlyHighlight, undefined);

        const scheduledTask = await request(server, '/recordingTaskV2/scheduled', {});
        assert.strictEqual(scheduledTask.status, 200);
        assert.strictEqual(scheduledTask.body.code, '0');
        assert.strictEqual(scheduledTask.body.data.accepted, 2);
        assert.strictEqual(scheduledTask.body.data.duplicates, 1);

        const oldFile = await request(server, '/fileExists', {
            siteId: 'doctest', classId: '1001'
        });
        assert.strictEqual(oldFile.status, 200);
        assert.strictEqual(oldFile.body.code, 1);
        assert.match(oldFile.body.classUrl, /classId=1001/);
        assert.strictEqual(fileCalls, 0, '旧查询接口不得进入 V2 服务');

        const newFile = await request(server, '/fileExistsV2', {
            siteId: 'doctest', classId: '1001', onlyHighlight: 1
        });
        assert.strictEqual(newFile.status, 200);
        assert.strictEqual(newFile.body.fileExists, true);
        assert.strictEqual(newFile.body.onlyHighlight, 1);
        assert.strictEqual(newFile.body.files.length, 1);
        assert.strictEqual(fileCalls, 1);

        recordingTaskService.getFileResult = async () => {
            throw new HighlightValidationError('高光录制功能未启用');
        };
        const disabledHighlight = await request(server, '/fileExistsV2', {
            siteId: 'kiwikids', classId: '258178512', onlyHighlight: 1
        });
        assert.strictEqual(disabledHighlight.status, 400);
        assert.deepStrictEqual(disabledHighlight.body, {
            code: 2,
            message: 'siteId或classId不正确',
            fileExists: false,
            files: []
        });
    } finally {
        recordingTaskService.acceptTasks = originalAcceptTasks;
        recordingTaskService.getFileResult = originalGetFileResult;
        recordingTaskService.runScheduledTaskPull = originalRunScheduledTaskPull;
        await new Promise(resolve => server.close(resolve));
    }
    console.log('recording V2 routes tests passed');
}

run().catch(error => {
    console.error(error);
    process.exitCode = 1;
});