import expandTask from '../../../scripts/modules/task-manager/expand-task.js';
import { readJSON, writeJSON } from '../../../scripts/modules/utils.js';
import fs from 'fs';
import path from 'path';

describe('expand-task with generateObject', () => {
    const testTasksFile = path.join(process.cwd(), 'test-tasks.json');
    
    beforeEach(() => {
        // Create a test tasks file
        const testTasks = {
            projectName: "Test Project",
            tasks: [
                {
                    id: 1,
                    title: "Setup project structure",
                    description: "Initialize the project with proper folder structure",
                    status: "done",
                    dependencies: [],
                    priority: "high",
                    details: "Create folders for src, tests, docs",
                    testStrategy: "Manual verification",
                    subtasks: []
                },
                {
                    id: 2,
                    title: "Implement authentication",
                    description: "Add user authentication with JWT tokens",
                    status: "pending",
                    dependencies: [1],
                    priority: "high",
                    details: "Need to support OAuth2 and traditional login",
                    testStrategy: null,
                    subtasks: []
                },
                {
                    id: 3,
                    title: "Build API endpoints",
                    description: "Create RESTful API endpoints",
                    status: "pending", 
                    dependencies: [2],
                    priority: "medium",
                    details: null,
                    testStrategy: null,
                    subtasks: [
                        {
                            id: 1,
                            title: "Design API schema",
                            description: "Create OpenAPI specification",
                            dependencies: [],
                            details: "Use OpenAPI 3.0 specification",
                            status: "done"
                        }
                    ]
                }
            ]
        };
        fs.writeFileSync(testTasksFile, JSON.stringify(testTasks, null, 2));
    });
    
    afterEach(() => {
        // Clean up test files
        if (fs.existsSync(testTasksFile)) {
            fs.unlinkSync(testTasksFile);
        }
    });
    
    test('should expand task with structured subtasks', async () => {
        const result = await expandTask(
            testTasksFile,
            '2', // taskId as string
            3,   // numSubtasks
            false, // force
            'Break down authentication into implementation steps' // additionalContext
        );

        expect(result).toHaveProperty('task');
        expect(result).toHaveProperty('telemetryData');
        
        const { task } = result;
        
        // Verify task was expanded
        expect(task.id).toBe(2);
        expect(task.subtasks).toBeDefined();
        expect(Array.isArray(task.subtasks)).toBe(true);
        expect(task.subtasks.length).toBeGreaterThan(0);
        
        // Verify subtask structure
        const subtask = task.subtasks[0];
        expect(subtask).toHaveProperty('id');
        expect(subtask).toHaveProperty('title');
        expect(subtask).toHaveProperty('description');
        expect(subtask).toHaveProperty('dependencies');
        expect(subtask).toHaveProperty('details');
        expect(subtask).toHaveProperty('status', 'pending');
        
        // Verify task was written back to file
        const savedData = JSON.parse(fs.readFileSync(testTasksFile, 'utf8'));
        const savedTask = savedData.tasks.find(t => t.id === 2);
        expect(savedTask.subtasks.length).toBe(task.subtasks.length);
    }, 30000); // Increase timeout for AI call
    
    test('should append subtasks when force=false', async () => {
        // First expansion
        await expandTask(testTasksFile, '3', 2, false);
        
        const dataAfterFirst = JSON.parse(fs.readFileSync(testTasksFile, 'utf8'));
        const taskAfterFirst = dataAfterFirst.tasks.find(t => t.id === 3);
        const initialSubtaskCount = taskAfterFirst.subtasks.length;
        
        // Second expansion (append)
        await expandTask(testTasksFile, '3', 2, false, 'Add more implementation details');
        
        const dataAfterSecond = JSON.parse(fs.readFileSync(testTasksFile, 'utf8'));
        const taskAfterSecond = dataAfterSecond.tasks.find(t => t.id === 3);
        
        // Should have more subtasks than before
        expect(taskAfterSecond.subtasks.length).toBeGreaterThan(initialSubtaskCount);
    }, 60000);
    
    test('should replace subtasks when force=true', async () => {
        // First expansion
        await expandTask(testTasksFile, '3', 2, false);
        
        // Second expansion with force=true
        const result = await expandTask(testTasksFile, '3', 3, true, 'Complete redesign needed');
        
        const savedData = JSON.parse(fs.readFileSync(testTasksFile, 'utf8'));
        const savedTask = savedData.tasks.find(t => t.id === 3);
        
        // Should have exactly 3 subtasks (replaced, not appended)
        expect(savedTask.subtasks.length).toBe(3);
    }, 60000);
});