function discoverSessionStoragePaths(extensionContext: vscode.ExtensionContext): string[] {
    const myExtensionPath = extensionContext.storageUri.fsPath;
    
    // Navigate up to find the common AppData root
    // Path: workspaceStorage/{hash}/extension-name -> AppData/Roaming/
    const appDataRoot = path.dirname(path.dirname(path.dirname(path.dirname(path.dirname(myExtensionPath)))));
    
    // Construct both edition paths
    const stablePath = path.join(appDataRoot, 'Code', 'User', 'workspaceStorage');
    const insidersPath = path.join(appDataRoot, 'Code - Insiders', 'User', 'workspaceStorage');
    
    return [stablePath, insidersPath];
}

async function scanForSessionFiles(storagePaths: string[]): Promise<string[]> {
    const sessionFiles: string[] = [];
    const sessionPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.json$/i;
    
    for (const storagePath of storagePaths) {
        try {
            await fs.access(storagePath);
            const workspaceDirs = await fs.readdir(storagePath, { withFileTypes: true });
            
            for (const workspaceDir of workspaceDirs) {
                if (!workspaceDir.isDirectory()) continue;
                
                const chatSessionsPath = path.join(storagePath, workspaceDir.name, 'chatSessions');
                
                try {
                    await fs.access(chatSessionsPath);
                    const files = await fs.readdir(chatSessionsPath);
                    
                    for (const fileName of files) {
                        if (sessionPattern.test(fileName)) {
                            sessionFiles.push(path.join(chatSessionsPath, fileName));
                        }
                    }
                } catch {
                    // chatSessions directory doesn't exist
                    continue;
                }
            }
        } catch (error) {
            console.warn(`Could not scan ${storagePath}: ${error}`);
        }
    }
    
    return sessionFiles;
}

interface CopilotChatSession {
    sessionId: string;
    creationDate: number;
    version: number;
    requests: CopilotRequest[];
}

interface CopilotRequest {
    requestId: string;
    timestamp: number;
    modelId?: string;
    message: {
        text: string;
        attachments?: any[];
    };
    agent?: {
        id: string;
        name?: string;
    };
    response?: any;
}

function validateSession(obj: any): obj is CopilotChatSession {
    return (
        typeof obj?.sessionId === 'string' &&
        typeof obj?.creationDate === 'number' &&
        typeof obj?.version === 'number' &&
        Array.isArray(obj?.requests)
    );
}

function validateRequest(req: any): req is CopilotRequest {
    return (
        typeof req?.requestId === 'string' &&
        typeof req?.timestamp === 'number' &&
        typeof req?.message?.text === 'string'
    );
}

function setupSessionWatcher(sessionDirectories: string[], callback: (filePath: string) => void) {
    const pattern = new vscode.RelativePattern(
        vscode.workspace.workspaceFolders?.[0] || vscode.Uri.file(os.homedir()),
        '**/chatSessions/*.json'
    );
    
    const watcher = vscode.workspace.createFileSystemWatcher(pattern);
    
    // Debounce file changes (sessions update in bursts)
    let debounceTimer: NodeJS.Timeout;
    const debounceMs = 3000;
    
    const handleChange = (uri: vscode.Uri) => {
        clearTimeout(debounceTimer);
        debounceTimer = setTimeout(() => {
            callback(uri.fsPath);
        }, debounceMs);
    };
    
    watcher.onDidCreate(handleChange);
    watcher.onDidChange(handleChange);
    
    return watcher;
}

const MAX_FILE_SIZE_MB = 100;

async function shouldProcessFile(filePath: string): Promise<boolean> {
    try {
        const stats = await fs.stat(filePath);
        const sizeMB = stats.size / (1024 * 1024);
        
        if (sizeMB > MAX_FILE_SIZE_MB) {
            console.warn(`Skipping large session file: ${filePath} (${sizeMB.toFixed(1)}MB)`);
            return false;
        }
        
        return true;
    } catch {
        return false;
    }
}

async function processSessionsBatch(filePaths: string[], batchSize = 50): Promise<CopilotChatSession[]> {
    const results: CopilotChatSession[] = [];
    
    for (let i = 0; i < filePaths.length; i += batchSize) {
        const batch = filePaths.slice(i, i + batchSize);
        
        const batchPromises = batch.map(async (filePath) => {
            try {
                if (!(await shouldProcessFile(filePath))) return null;
                
                const content = await fs.readFile(filePath, 'utf-8');
                const session = JSON.parse(content);
                
                return validateSession(session) ? session : null;
            } catch {
                return null;
            }
        });
        
        const batchResults = await Promise.all(batchPromises);
        results.push(...batchResults.filter(s => s !== null) as CopilotChatSession[]);
        
        // Progress reporting for large datasets
        if (filePaths.length > 100 && i % 100 === 0) {
            console.log(`Processed ${i + batchSize}/${filePaths.length} session files...`);
        }
    }
    
    return results;
}

// Verify paths exist
async function diagnosePaths(paths: string[]) {
    for (const path of paths) {
        try {
            await fs.access(path);
            console.log(`✅ Path exists: ${path}`);
            
            const dirs = await fs.readdir(path);
            console.log(`   Found ${dirs.length} workspace directories`);
        } catch {
            console.log(`❌ Path not accessible: ${path}`);
        }
    }
}

async function debugSessionFile(filePath: string) {
    try {
        const stats = await fs.stat(filePath);
        console.log(`File: ${path.basename(filePath)}`);
        console.log(`Size: ${(stats.size / 1024).toFixed(1)}KB`);
        console.log(`Modified: ${stats.mtime.toISOString()}`);
        
        const content = await fs.readFile(filePath, 'utf-8');
        const session = JSON.parse(content);
        
        console.log(`Session ID: ${session.sessionId}`);
        console.log(`Created: ${new Date(session.creationDate).toISOString()}`);
        console.log(`Requests: ${session.requests.length}`);
        console.log(`Version: ${session.version}`);
        
        // Check for recent activity
        if (session.requests.length > 0) {
            const lastRequest = session.requests[session.requests.length - 1];
            console.log(`Last activity: ${new Date(lastRequest.timestamp).toISOString()}`);
        }
    } catch (error) {
        console.error(`Error analyzing ${filePath}: ${error}`);
    }
}

export class ChatSessionScanner {
    private readonly logger: ILogger;
    
    constructor(logger: ILogger) {
        this.logger = logger;
    }
    
    async scanAllSessions(storagePaths: string[]): Promise<{
        sessions: CopilotChatSession[];
        stats: {
            totalFiles: number;
            totalRequests: number;
            totalSessions: number;
            scanDuration: number;
            oldestSession?: string;
            newestSession?: string;
        };
    }> {
        const startTime = Date.now();
        
        this.logger.info(`Scanning ${storagePaths.length} storage locations...`);
        
        const allFiles = await this.findAllSessionFiles(storagePaths);
        const sessions = await this.processSessionFiles(allFiles);
        
        const stats = this.calculateStats(sessions, allFiles.length, Date.now() - startTime);
        
        return { sessions, stats };
    }
    
    private async findAllSessionFiles(storagePaths: string[]): Promise<string[]> {
        // Implementation from earlier examples
    }
    
    private async processSessionFiles(filePaths: string[]): Promise<CopilotChatSession[]> {
        // Implementation from earlier examples
    }
    
    private calculateStats(sessions: CopilotChatSession[], totalFiles: number, duration: number) {
        const totalRequests = sessions.reduce((sum, s) => sum + s.requests.length, 0);
        
        let oldestSession: string | undefined;
        let newestSession: string | undefined;
        
        for (const session of sessions) {
            const dateStr = new Date(session.creationDate).toISOString();
            if (!oldestSession || dateStr < oldestSession) {
                oldestSession = dateStr;
            }
            if (!newestSession || dateStr > newestSession) {
                newestSession = dateStr;
            }
        }
        
        return {
            totalFiles,
            totalRequests,
            totalSessions: sessions.length,
            scanDuration: duration,
            oldestSession,
            newestSession
        };
    }
}

// Initialize scanner with Extension API for path discovery
const logger = new ConsoleLogger();
const scanner = new ChatSessionScanner(logger);

// Discover storage paths using Extension API
const storagePaths = discoverSessionStoragePaths(context);

// Scan all sessions  
const { sessions, stats } = await scanner.scanAllSessions(storagePaths);

console.log(`Found ${stats.totalSessions} sessions with ${stats.totalRequests} total requests`);
console.log(`Scan completed in ${stats.scanDuration}ms`);

// Analyze recent activity
const recentSessions = sessions.filter(s => 
    Date.now() - s.creationDate < 24 * 60 * 60 * 1000 // Last 24 hours
);

console.log(`${recentSessions.length} sessions in the last 24 hours`);