const express = require('express');
const Queue = require('bull');
const { spawn, exec } = require('child_process');
const fs = require('fs');
const path = require('path');
const cors = require('cors');
const EventEmitter = require('events');
const axios = require('axios');
const mpdParser = require('mpd-parser');
const softwareService = require('./services/softwares');
const ffprobe = require('ffprobe');
const ffprobeStatic = require('ffprobe-static');
const { stringify } = require('querystring');
const xml2js = require('xml2js');
const { promisify } = require('util');
const execAsync = promisify(exec);

const BASE_PATH = process.env.DATA_PATH || `./data`;
const OUTPUT_PATH = process.env.OUTPUT_PATH || `${BASE_PATH}/output`;
const TMP_PATH = `${BASE_PATH}/tmp`;

const app = express();
const port = 3000;

app.use(cors());
app.use(express.json());

const videoQueue = new Queue('crawlflix_queue', 'redis://192.168.1.230:6379');

videoQueue.on('error', (e) => {
	console.log('An error occured', e);
});

const runCommand = (command) => {
	console.log('⚙️  Will execute: ' + command);
	return new Promise((resolve, reject) => {
		const cmd = spawn(command, { shell: true });
		let lastLog = '';

		cmd.stdout.on('data', (data) => {
			lastLog = data.toString();
			process.stdout.write(data.toString());
		});

		cmd.stderr.on('data', (data) => {
			lastLog = data.toString();
			process.stderr.write(`stderr: ${data.toString()}`);
		});

		cmd.on('close', (code) => {
			if (code === 0) {
				resolve('Command executed successfully.');
			} else {
				reject(lastLog || 'Command failed with status code ' + code);
			}
		});
	});
};

const runProgressCommand = (command) => {
	console.log('⚙️  Will execute: ' + command);
	const emitter = new EventEmitter();

	const executeCommand = new Promise((resolve, reject) => {
		const cmd = spawn(command, { shell: true });
		let lastLog = '';

		cmd.stdout.on('data', (data) => {
			lastLog = data.toString();
			const perc = extractPercentage(data.toString());
			if (!perc) {
				process.stdout.write(data.toString());
			} else {
				emitter.emit('percentage', perc);
			}
		});

		cmd.stderr.on('data', (data) => {
			lastLog = data.toString();
			process.stderr.write(`stderr: ${data.toString()}`);
		});

		cmd.on('close', (code) => {
			if (code === 0) {
				resolve('Command executed successfully.');
			} else {
				reject(lastLog || 'Command failed with status code ' + code);
			}
		});
	});

	return { executeCommand, emitter };
};

app.use((req, res, next) => {
	const timestamp = new Date().toISOString();
	console.log(`[${timestamp}] ${req.method} ${req.url} - ${req.ip}`);
	next();
});

app.post('/start-process', async (req, res, next) => {
	try {
		const { mp4Filename, mpdUrl, keys, wantedResolution, wantedAudioTracks, wantedSubtitles, wantedRemux, wantToUpscale } = req.body;
		console.log(JSON.stringify(req.body, null, 2));
		const job = await videoQueue.add({
			mp4Filename,
			mpdUrl,
			keys,
			wantedResolution,
			wantedAudioTracks,
			wantedSubtitles,
			wantedRemux,
			wantToUpscale
		});
		res.json({ jobId: job.id });
	} catch(e) {
		console.log(e);
		next();
	}
});

app.get('/job-status/:jobId', async (req, res) => {
	const job = await videoQueue.getJob(req.params.jobId);
	if (job === null) {
		res.status(404).json({ error: 'Job not found' });
	} else {
		const state = await job.getState();
		const progress = job._progress;
		res.json({ jobId: job.id, state, progress });
	}
});

app.delete('/job/:jobId', async (req, res) => {
	try {
		const job = await videoQueue.getJob(req.params.jobId);
		
		if (job === null) {
			return res.status(404).json({ error: 'Job not found' });
		}
		
		const state = await job.getState();
		
		if (state === 'active' || state === 'waiting') {
			const { mp4Filename } = job.data;
			const workdir = path.join(TMP_PATH, mp4Filename);
			
			if (fs.existsSync(workdir)) {
				await runCommand(`rm -rf ${workdir}`);
				console.log(`Cleaned up temp files for cancelled job: ${workdir}`);
			}
		}
		
		await job.remove();
		res.json({ 
			message: 'Job deleted successfully', 
			jobId: req.params.jobId,
			previousState: state 
		});
		
	} catch (error) {
		console.error('Error deleting job:', error);
		res.status(500).json({ error: error.message || 'Failed to delete job' });
	}
});

app.delete('/jobs/completed', async (req, res) => {
	try {
		const completedJobs = await videoQueue.getJobs(['completed', 'failed'], 0, -1);
		
		if (completedJobs.length === 0) {
			return res.json({ 
				message: 'No completed jobs to delete', 
				deletedCount: 0 
			});
		}
		
		const deletePromises = completedJobs.map(job => job.remove());
		await Promise.all(deletePromises);
		
		res.json({ 
			message: `Successfully deleted ${completedJobs.length} completed jobs`,
			deletedCount: completedJobs.length
		});
		
	} catch (error) {
		console.error('Error deleting completed jobs:', error);
		res.status(500).json({ error: error.message || 'Failed to delete completed jobs' });
	}
});

app.delete('/jobs/all', async (req, res) => {
	try {
		const allJobs = await videoQueue.getJobs(['waiting', 'active', 'completed', 'failed', 'delayed'], 0, -1);
		
		if (allJobs.length === 0) {
			return res.json({ 
				message: 'Queue is already empty', 
				deletedCount: 0 
			});
		}
		
		let cleanedDirs = 0;
		
		for (const job of allJobs) {
			const state = await job.getState();
			if (state === 'active' || state === 'waiting') {
				const { mp4Filename } = job.data;
				const workdir = path.join(TMP_PATH, mp4Filename);
				
				if (fs.existsSync(workdir)) {
					await runCommand(`rm -rf ${workdir}`);
					cleanedDirs++;
				}
			}
		}
		
		const deletePromises = allJobs.map(job => job.remove());
		await Promise.all(deletePromises);
		
		res.json({ 
			message: `Successfully deleted all ${allJobs.length} jobs`,
			deletedCount: allJobs.length,
			cleanedTempDirs: cleanedDirs
		});
		
	} catch (error) {
		console.error('Error deleting all jobs:', error);
		res.status(500).json({ error: error.message || 'Failed to delete all jobs' });
	}
});

app.get('/jobs/stats', async (req, res) => {
	try {
		const waiting = await videoQueue.getWaiting();
		const active = await videoQueue.getActive();
		const completed = await videoQueue.getCompleted();
		const failed = await videoQueue.getFailed();
		
		res.json({
			waiting: waiting.length,
			active: active.length,
			completed: completed.length,
			failed: failed.length,
			total: waiting.length + active.length + completed.length + failed.length
		});
		
	} catch (error) {
		console.error('Error getting queue stats:', error);
		res.status(500).json({ error: error.message || 'Failed to get queue stats' });
	}
});

app.get('/jobs-status', async (req, res) => {
	const jobs = await videoQueue.getJobs();
	res.json(await Promise.all(jobs.splice(0, 25).map(async job => ({
		id: job.id,
		state: await job.getState(),
		progress: job._progress,
		addedOn: job.timestamp,
		processedOn: job.processedOn,
		finishedOn: job.finishedOn,
		returnValue: job.returnvalue,
		failedReason: job.failedReason,
		data: job.data
	}))));
});

app.get('/download', async (req, res) => {
	try {
		const { filename } = req.query;
		
		if (filename.includes('..') || filename.includes('\\')) {
			return res.status(400).json({ error: 'Invalid filename' });
		}
		
		const filePath = path.join(OUTPUT_PATH, filename);
		
		if (!fs.existsSync(filePath)) {
			return res.status(404).json({ error: 'File not found' });
		}
		
		const stat = fs.statSync(filePath);
		if (!stat.isFile()) {
			return res.status(400).json({ error: 'Not a file' });
		}
		
		const allowedExtensions = ['.mp4', '.mkv', '.srt', '.m4a'];
		const fileExt = path.extname(filename).toLowerCase();
		
		if (!allowedExtensions.includes(fileExt)) {
			return res.status(403).json({ error: 'File type not allowed' });
		}
		
		console.log(`📥 Download requested: ${filename} (${stat.size} bytes)`);
		
		res.download(filePath, filename, (err) => {
			if (err) {
				console.error('Download error:', err);
				if (!res.headersSent) {
					res.status(500).json({ error: 'Download failed' });
				}
			} else {
				console.log(`✅ Download completed: ${filename}`);
			}
		});
		
	} catch (error) {
		console.error('Download route error:', error);
		if (!res.headersSent) {
			res.status(500).json({ error: 'Internal server error' });
		}
	}
});

app.get('/hello', async (req, res, next) => {
	try {
		res.json({
			downloader: await softwareService.checkDownloaderUpdate(),
			mp4decrypt: await softwareService.checkMp4decryptUpdate()
		})
	} catch(e) {
		console.log(e);
		next(e);
	}
});

app.post('/processUpdate', async (req, res, next) => {
	try {
		console.log(req.body);
		await softwareService.processUpdate(req.body);
		res.end();
	} catch(e) {
		console.log(e);
		next(e);
	}
});

const checkFilesExistance = (pattern, path) => {
	return new Promise(async (resolve, reject) => {
		try {
			const files = fs.readdirSync(path);
			resolve(files.filter(file => file.includes(pattern)));
		} catch(e) {
			reject(e);
		}
	});
};

const extractPercentage = (line) => {
	const s = line.split('%');
	const percentages = [];

	for (let i = 0; i < s.length; i++) {
		if (s[i].length === 0) continue;
		const ss = s[i].split(' ');
		if (ss.length > 0 && !isNaN(ss[ss.length - 1]))
			percentages.push(parseFloat(ss[ss.length - 1]));
	}
	if (percentages.length === 0) return null;
	return Math.max(...percentages.filter((p) => p < 100));
}

const formatDuration = (seconds) => {
	if (isNaN(seconds) || seconds < 0) {
		return 'Invalid input';
	}

	const hours = Math.floor(seconds / 3600);
	const minutes = Math.floor((seconds % 3600) / 60);
	const secs = seconds % 60;

	const parts = [];
	if (hours > 0) {
		parts.push(`${hours}h`);
	}
	if (minutes > 0) {
		parts.push(`${minutes}m`);
	}
	if (secs > 0) {
		parts.push(`${secs}s`);
	}

	return parts.join(', ') || '0 secondes';
}

const parseMPDStream = async (mpdUrl) => {
	// Télécharger le manifest d'abord
	await downloadMPDManifest(mpdUrl, `./data/tmp/manifest.mpd`);
	
	// 1. Parser le XML pour récupérer les KID
	const mpdContent = fs.readFileSync('./data/tmp/manifest.mpd', 'utf8');
	const parser = new xml2js.Parser({ explicitArray: false, mergeAttrs: true });
	const parsedXML = await parser.parseStringPromise(mpdContent);
	
	// Extraire les KID du XML par contentType et bandwidth
	const kidMapping = {};
	if (parsedXML.MPD?.Period) {
		const periods = Array.isArray(parsedXML.MPD.Period) ? parsedXML.MPD.Period : [parsedXML.MPD.Period];
		
		periods.forEach(period => {
			if (period.AdaptationSet) {
				const adaptationSets = Array.isArray(period.AdaptationSet) ? period.AdaptationSet : [period.AdaptationSet];
				
				adaptationSets.forEach(adaptSet => {
					let defaultKID = null;
					
					// Chercher ContentProtection
					if (adaptSet.ContentProtection) {
						if (Array.isArray(adaptSet.ContentProtection)) {
							defaultKID = adaptSet.ContentProtection[0]['cenc:default_KID'];
						} else {
							defaultKID = adaptSet.ContentProtection['cenc:default_KID'];
						}
					}
										
					if (defaultKID && adaptSet.Representation) {
						const representations = Array.isArray(adaptSet.Representation) ? adaptSet.Representation : [adaptSet.Representation];
						
						representations.forEach(rep => {
							const key = `${adaptSet.contentType}_${rep.bandwidth}`;
							kidMapping[key] = defaultKID.replace(/-/g, '');
						});
					}
				});
			}
		});
	}
	
	
	// 2. Parser avec N_m3u8DL-RE pour avoir les bonnes données
	const baseUrl = mpdUrl.substring(0, mpdUrl.lastIndexOf('/') + 1);
	const downloaderPath = softwareService.getLocalBinFileInfo('downloader').path;
	const parseCommand = `${downloaderPath} "./data/tmp/manifest.mpd" --base-url "${baseUrl}" --skip-download -H "User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:142.0) Gecko/20100101 Firefox/142.0"`;
	
	let stdout;
	try {
		const result = await execAsync(parseCommand);
		stdout = result.stdout;
	} catch (error) {
		if (error.stdout) {
			stdout = error.stdout;
		} else {
			throw error;
		}
	}
	
	// 3. Parser N_m3u8DL-RE et associer les KID
	const isValidDuration = (durationStr) => {
		const timeMatch = durationStr.match(/~(?:(\d+)h)?(?:(\d+)m)?(?:(\d+)s)?/);
		if (!timeMatch) return false;
		
		const hours = parseInt(timeMatch[1]) || 0;
		const minutes = parseInt(timeMatch[2]) || 0;
		const totalMinutes = hours * 60 + minutes;
		
		return totalMinutes >= 10 && totalMinutes <= 240;
	};
	
	const obj = {
		audioTracks: [],
		videoTracks: [],
		subtitles: []
	};
	
	const lines = stdout.split('\n');
	lines.forEach(line => {
		if (line.includes('INFO : Vid')) {
			if (!/\d+x\d+/.test(line)) {
				console.log('Skipping non-video line:', line);
				return;
			}

			const parts = line.split(' | ');
			if (parts.length >= 7) {
				const encrypted = parts[0].includes('*CENC');
				const resolution = parts[0].match(/(\d+x\d+)/)[1];
				const [width, height] = resolution.split('x').map(Number);
				const kbps = parseInt(parts[1].match(/(\d+) Kbps/)[1]);
				const videoId = parts[2].trim();
				const fps = parseFloat(parts[3]);
				const codec = parts[4].trim();
				const duration = parts[7].trim();

				if (!isValidDuration(duration)) {
					console.log(`Skipping video track with suspicious duration (${duration}):`, line);
					return;
				}

				const bandwidth = kbps * 1000;
				const mappingKey1 = `video_${bandwidth}`;
				const mappingKey2 = videoId.startsWith('video=') ? videoId : `video=${bandwidth}`;
				const defaultKID = kidMapping[mappingKey1] || kidMapping[mappingKey2] || null;

				obj.videoTracks.push({
					id: videoId,
					name: resolution,
					resolution: { width, height },
					bandwidth,
					fps,
					codec,
					encrypted,
					formatedDuration: duration,
					defaultKID
				});
			}
		} else if (line.includes('INFO : Aud')) {
			const audioMatch = line.match(/Aud (\*CENC )?(.+?) \| (\d+) Kbps \| ([^|]+) \| ([^|]+) \| ([^|]+) \| \d+ Segments? \| [^|]+ \| (~.+)$/);
			if (audioMatch) {
				const [, encrypted, audioId, kbps, codec, lang, channels, duration] = audioMatch;
				
				if (!isValidDuration(duration)) return;
				
				const bandwidth = parseInt(kbps) * 1000;
				
				// Chercher le KID correspondant
				const kidKey = `audio_${bandwidth}`;
				const defaultKID = kidMapping[kidKey] || null;
								
				obj.audioTracks.push({
					id: audioId.trim(),
					name: audioId.trim(),
					language: lang.trim(),
					bandwidth,
					codec: codec.trim(),
					channels: channels.trim(),
					encrypted: !!encrypted,
					formatedDuration: duration.trim(),
					defaultKID
				});
			}
		} else if (line.includes('INFO : Sub')) {
			const parts = line.split(' | ');
			if (parts.length >= 6) {
				const subId = parts[0].replace(/.*INFO : Sub /, '').trim();
				const lang = parts[1].trim();
				const codec = parts[2].trim();
				const duration = parts[5].trim();

				if (!isValidDuration(duration)) return;

				const defaultKID = kidMapping[subId] || kidMapping[`text_${subId}`] || null;

				obj.subtitles.push({
					id: subId,
					name: subId,
					language: lang,
					codec,
					encrypted: false,
					formatedDuration: duration,
					defaultKID
				});
			}
		}
	});
	
	// Déduplication et tri
	obj.videoTracks = obj.videoTracks
		.filter((track, index, self) => index === self.findIndex(t => t.id === track.id))
		.sort((a, b) => b.resolution.width - a.resolution.width);
		
	obj.audioTracks = obj.audioTracks
		.filter((track, index, self) => index === self.findIndex(t => t.id === track.id))
		.sort((a, b) => b.bandwidth - a.bandwidth);
	
	console.log(`Parsed ${obj.videoTracks.length} video tracks, ${obj.audioTracks.length} audio tracks`);
	
	return obj;
};

// const parseMPDStream = async (mpdUrl) => {
// 	const mpdResponse = await axios({
// 		url: mpdUrl,
// 		method: 'GET',
// 		responseType: 'text'
// 	});
	
// 	const parser = new xml2js.Parser({ explicitArray: false, mergeAttrs: true });
// 	const parsedXML = await parser.parseStringPromise(mpdResponse.data);
	
// 	const obj = {
// 		audioTracks: [],
// 		videoTracks: [],
// 		subtitles: []
// 	};
	
// 	// Fonction pour parser la durée PT format vers secondes
// 	const parseDuration = (duration) => {
// 		if (!duration) return 0;
// 		// PT34M11.34S -> 34*60 + 11.34 = 2051.34 secondes
// 		const match = duration.match(/PT(?:(\d+)H)?(?:(\d+)M)?(?:([\d.]+)S)?/);
// 		if (!match) return 0;
// 		const hours = parseInt(match[1]) || 0;
// 		const minutes = parseInt(match[2]) || 0;
// 		const seconds = parseFloat(match[3]) || 0;
// 		return hours * 3600 + minutes * 60 + seconds;
// 	};
	
// 	// Fonction pour filtrer les periods avec contenu principal (> 10 minutes)
// 	const isMainContent = (duration) => {
// 		const durationInSeconds = parseDuration(duration);
// 		return durationInSeconds > 600; // Plus de 10 minutes
// 	};
	
// 	if (parsedXML.MPD && parsedXML.MPD.Period) {
// 		const periods = Array.isArray(parsedXML.MPD.Period) ? parsedXML.MPD.Period : [parsedXML.MPD.Period];
		
// 		// Filtrer seulement les periods de contenu principal
// 		const mainPeriods = periods.filter(period => isMainContent(period.duration));
		
// 		console.log(`Found ${periods.length} total periods, ${mainPeriods.length} main content periods`);
		
// 		mainPeriods.forEach((period, periodIndex) => {
// 			console.log(`Processing period: ${period.duration} (${parseDuration(period.duration)}s)`);
			
// 			if (period.AdaptationSet) {
// 				const adaptationSets = Array.isArray(period.AdaptationSet) ? period.AdaptationSet : [period.AdaptationSet];
				
// 				adaptationSets.forEach(adaptSet => {
// 					const contentType = adaptSet.contentType;
// 					let defaultKID = null;
// 					if (adaptSet.ContentProtection) {
// 						if (Array.isArray(adaptSet.ContentProtection)) {
// 							defaultKID = adaptSet.ContentProtection[0]['cenc:default_KID'];
// 						} else {
// 							defaultKID = adaptSet.ContentProtection['cenc:default_KID'];
// 						}

// 						if (defaultKID) {
// 							defaultKID = defaultKID.replace(/-/g, '');
// 						}
// 					}					
// 					if (adaptSet.Representation) {
// 						const representations = Array.isArray(adaptSet.Representation) ? adaptSet.Representation : [adaptSet.Representation];
						
// 						representations.forEach(rep => {
// 							const baseTrack = {
// 								id: rep.id,
// 								codec: rep.codecs,
// 								bandwidth: parseInt(rep.bandwidth),
// 								defaultKID: defaultKID ? defaultKID.replace(/-/g, '') : null,
// 								duration: parseDuration(period.duration),
// 								formatedDuration: formatDuration(parseDuration(period.duration))
// 							};
							
// 							if (contentType === 'video') {
// 								obj.videoTracks.push({
// 									...baseTrack,
// 									name: `${rep.width}x${rep.height}`,
// 									fps: parseFloat(rep.frameRate),
// 									resolution: {
// 										width: parseInt(rep.width),
// 										height: parseInt(rep.height)
// 									}
// 								});
// 							} else if (contentType === 'audio') {
// 								obj.audioTracks.push({
// 									...baseTrack,
// 									name: rep.id || `${adaptSet.lang || 'unknown'}_${rep.bandwidth}`,
// 									language: adaptSet.lang || 'unknown',
// 									channels: rep.AudioChannelConfiguration ? rep.AudioChannelConfiguration.value + 'CH' : '2CH',
// 									audioSamplingRate: parseInt(rep.audioSamplingRate)
// 								});
// 							}
// 						});
// 					}
// 				});
// 			}
// 		});
// 	}
	
// 	obj.videoTracks = obj.videoTracks.sort((a, b) => b.resolution.width - a.resolution.width);
// 	obj.audioTracks = obj.audioTracks.sort((a, b) => b.bandwidth - a.bandwidth);
	
// 	obj.videoTracks = obj.videoTracks.filter((track, index, self) => 
// 		index === self.findIndex(t => t.id === track.id && t.bandwidth === track.bandwidth)
// 	);
// 	obj.audioTracks = obj.audioTracks.filter((track, index, self) => 
// 		index === self.findIndex(t => t.id === track.id && t.bandwidth === track.bandwidth)
// 	);
	
// 	return obj;
// };

// const parseMPDStream = async (mpdUrl) => {
// 	const mpdResponse = await axios({
// 		url: mpdUrl,
// 		method: 'GET',
// 		responseType: 'text'
// 	});
// 	const eventHandler = ({ type, message }) => console.log(`${type}: ${message}`);
// 	const parsedManifest = mpdParser.parse(mpdResponse.data , { mpdUrl, eventHandler });
	
// 	const obj = {
// 		audioTracks: [],
// 		videoTracks: [],
// 		subtitles: []
// 	};

// // Ajoutez ça temporairement dans votre fonction parseMPDStream après le parsing
// console.log('=== DEBUG STRUCTURE ===');

// // Debug premier élément vidéo
// if (parsedManifest.playlists && parsedManifest.playlists.length > 0) {
// 	console.log('\n🎥 FIRST VIDEO TRACK:');
// 	console.log(JSON.stringify(parsedManifest.playlists[0], null, 2));
// }

// // // Debug premier élément audio
// // try {
// // 	const audioGroups = parsedManifest?.mediaGroups?.AUDIO?.audio;
// // 	if (audioGroups) {
// // 		const firstAudioKey = Object.keys(audioGroups)[0];
// // 		console.log('\n🔊 FIRST AUDIO TRACK:');
// // 		console.log(`Key: "${firstAudioKey}"`);
// // 		console.log('Group:', JSON.stringify(audioGroups[firstAudioKey], null, 2));
// // 		if (audioGroups[firstAudioKey].playlists[0]) {
// // 			console.log('First playlist:', JSON.stringify(audioGroups[firstAudioKey].playlists[0], null, 2));
// // 		}
// // 	}
// // } catch(e) {
// // 	console.log('No audio debug possible:', e.message);
// // }

// // // Debug premier élément subtitle
// // try {
// // 	const subsGroups = parsedManifest?.mediaGroups?.SUBTITLES?.subs;
// // 	if (subsGroups) {
// // 		const firstSubKey = Object.keys(subsGroups)[0];
// // 		console.log('\n📝 FIRST SUBTITLE TRACK:');
// // 		console.log(`Key: "${firstSubKey}"`);
// // 		console.log('Group:', JSON.stringify(subsGroups[firstSubKey], null, 2));
// // 		if (subsGroups[firstSubKey].playlists[0]) {
// // 			console.log('First playlist:', JSON.stringify(subsGroups[firstSubKey].playlists[0], null, 2));
// // 		}
// // 	}
// // } catch(e) {
// // 	console.log('No subtitle debug possible:', e.message);
// // }

// console.log('=== END DEBUG ===\n');	
// 	// Fonction pour filtrer les durées anormales (< 10min ou > 4h)
// 	const isValidDuration = (duration) => {
// 		if (!duration) return true; // Garder si pas de durée spécifiée
// 		const durationInSeconds = duration; // Conversion en secondes si nécessaire
// 		return durationInSeconds >= 600 && durationInSeconds <= 14400; // Entre 10min et 4h
// 	};
	
// 	// Traitement des groupes de média (AUDIO et SUBTITLES)
// 	const toParse = [{
// 		rootProp: 'AUDIO',
// 		subProp: 'audio',
// 		targetProp: 'audioTracks'
// 	}, {
// 		rootProp: 'SUBTITLES',
// 		subProp: 'subs',
// 		targetProp: 'subtitles'
// 	}];
	
// 	toParse.forEach(({ rootProp, subProp, targetProp }) => {
// 		try {
// 			for (const [key, value] of Object.entries(parsedManifest?.mediaGroups?.[rootProp]?.[subProp])) {
// 				for (let i = 0; i < value.playlists.length; i++) {
// 					const playlist = value.playlists[i];
					
// 					// Filtrer les tracks avec des durées anormales
// 					if (!isValidDuration(playlist.targetDuration)) {
// 						console.log(`🚫 Filtered out ${targetProp} "${key}" with suspicious duration: ${playlist.targetDuration}min`);
// 						continue;
// 					}
					
// 					if (targetProp === 'audioTracks') {
// 						obj.audioTracks.push({
// 							id: playlist?.attributes?.NAME || key,
// 							name: key,
// 							language: value.language || 'unknown',
// 							codec: playlist?.attributes?.CODECS,
// 							bandwidth: playlist?.attributes?.BANDWIDTH,
// 							channels: playlist?.attributes?.CHANNELS || '2CH',
// 							defaultKID: playlist?.contentProtection?.mp4protection?.attributes['cenc:default_KID']?.replaceAll('-', '') || null,
// 							duration: playlist?.targetDuration,
// 							formatedDuration: formatDuration(playlist?.targetDuration || 0),
// 							attributes: playlist.attributes
// 						});
// 					} else if (targetProp === 'subtitles') {
// 						obj.subtitles.push({
// 							id: playlist?.attributes?.NAME || key,
// 							name: key,
// 							language: value.language || 'unknown',
// 							codec: playlist?.attributes?.CODECS,
// 							format: playlist?.attributes?.FORMAT || 'UNKNOWN',
// 							defaultKID: playlist?.contentProtection?.mp4protection?.attributes['cenc:default_KID']?.replaceAll('-', '') || null,
// 							duration: playlist?.targetDuration,
// 							formatedDuration: formatDuration(playlist?.targetDuration || 0),
// 							attributes: playlist.attributes
// 						});
// 					}
// 				}
// 			}
// 		} catch(e) {
// 			console.log(`No ${targetProp} found in manifest`);
// 		}
// 	});
	
// 	// Traitement des tracks vidéo
// 	for (let i = 0; i < parsedManifest.playlists.length; i++) {
// 		const playlist = parsedManifest.playlists[i];
		
// 		// Filtrer les tracks vidéo avec des durées anormales
// 		if (!isValidDuration(playlist.targetDuration)) {
// 			console.log(`🚫 Filtered out video track with suspicious duration: ${playlist.targetDuration}min`);
// 			continue;
// 		}
		
// 		obj.videoTracks.push({
// 			id: playlist?.attributes?.NAME,
// 			name: `${playlist?.attributes?.RESOLUTION?.width || 'N/C'}x${playlist?.attributes?.RESOLUTION?.height || 'N/C'}`,
// 			codec: playlist?.attributes?.CODECS,
// 			bandwidth: playlist?.attributes?.BANDWIDTH,
// 			defaultKID: playlist?.contentProtection?.mp4protection?.attributes['cenc:default_KID']?.replaceAll('-', '') || null,
// 			fps: playlist?.attributes?.['FRAME-RATE'],
// 			resolution: {
// 				width: playlist?.attributes?.RESOLUTION?.width,
// 				height: playlist?.attributes?.RESOLUTION?.height
// 			},
// 			duration: playlist?.targetDuration,
// 			formatedDuration: formatDuration(playlist?.targetDuration || 0),
// 			attributes: playlist.attributes
// 		});
// 	}
	
// 	// Tri des tracks par qualité/priorité
// 	obj.videoTracks = obj.videoTracks.sort((a, b) => b.resolution.width - a.resolution.width);
// 	obj.audioTracks = obj.audioTracks.sort((a, b) => (b.bandwidth || 0) - (a.bandwidth || 0));
	
// 	return obj;
// };

app.post('/processMPD', async (req, res, next) => {
	try {
		res.json(await parseMPDStream(req.body.mpdUrl));
	} catch(e) {
		console.log(e);
		next(e);
	}
});

app.use((err, req, res, next) => {
	res.status(500).json({ error: err.message || err.toString() || 'An error occured' });
});

const safeMove = async (source, destination) => {
	try {
		const destDir = path.dirname(destination);
		if (!fs.existsSync(destDir)) {
			fs.mkdirSync(destDir, { recursive: true });
		}
		
		fs.renameSync(source, destination);
		console.log(`✓ Moved: ${path.basename(source)} -> ${destination}`);
		
	} catch (error) {
		if (error.code === 'EXDEV') {
			console.log(`⚠️  Cross-device detected, copying: ${path.basename(source)}`);
			fs.copyFileSync(source, destination);
			fs.unlinkSync(source);
			console.log(`✓ Copied: ${path.basename(source)} -> ${destination}`);
			
		} else if (error.code === 'ENOENT') {
			console.error(`❌ Source file not found: ${source}`);
			throw new Error(`Source file not found: ${source}`);
			
		} else {
			console.error(`❌ Move failed:`, error);
			throw error;
		}
	}
};

// const remuxToMKV = async (options) => {
//     const { mp4FilePath, outputPath, filename, wantedAudioTracks, wantedSubtitles, videoInfo } = options;
	
//     try {
//         console.log('🎬 Starting MKV remux...');
		
//         const mkvFilePath = `${outputPath}/${filename}.mkv`;
		
//         let mkvCommand = `mkvmerge -o "${mkvFilePath}" --verbose`;
		
//         mkvCommand += ` --title "${filename}"`;
		
//         const resolution = videoInfo?.resolution || { width: 'Unknown', height: 'Unknown' };
//         mkvCommand += ` --language 0:und`;
//         mkvCommand += ` --track-name "0:Video ${resolution.width}x${resolution.height}"`;
//         mkvCommand += ` "${mp4FilePath}"`;
		
//         for (let i = 0; i < wantedAudioTracks.length; i++) {
//             const audioTrack = wantedAudioTracks[i];
//             const codec = audioTrack.attributes.CODECS?.split('.')[0] || 'Unknown';
//             const bitrate = Math.round(audioTrack.attributes.BANDWIDTH / 1000);
			
//             const trackIndex = i + 1;
			
//             mkvCommand += ` --language ${trackIndex}:${audioTrack.language}`;
//             mkvCommand += ` --track-name "${trackIndex}:${audioTrack.language.toUpperCase()} ${codec} ${bitrate}kbps"`;
			
//             mkvCommand += ` --default-track ${trackIndex}:${i === 0 ? 'yes' : 'no'}`;
//         }
		
//         const srtFiles = fs.readdirSync(outputPath).filter(file => 
//             file.startsWith(filename) && file.endsWith('.srt')
//         );
		
//         for (let i = 0; i < srtFiles.length; i++) {
//             const srtFile = srtFiles[i];
//             const srtPath = `${outputPath}/${srtFile}`;
			
//             const srtIndex = i;
//             const correspondingSubtitle = wantedSubtitles[srtIndex];
			
//             if (correspondingSubtitle) {
//                 const language = correspondingSubtitle.language;
				
//                 const isForced = srtFile.toLowerCase().includes('forced') || srtFile.toLowerCase().includes('sdh') === false;
//                 const trackName = isForced ? `${language.toUpperCase()} Forced` : `${language.toUpperCase()}`;
				
//                 mkvCommand += ` --language 0:${language}`;
//                 mkvCommand += ` --track-name "0:${trackName}"`;
				
//                 if (isForced) {
//                     mkvCommand += ` --forced-track 0:yes`;
//                 }
				
//                 const defaultSub = (i === 0 && wantedAudioTracks.length > 0 && language === wantedAudioTracks[0].language) ? 'yes' : 'no';
//                 mkvCommand += ` --default-track 0:${defaultSub}`;
				
//                 mkvCommand += ` "${srtPath}"`;
//             }
//         }
		
//         console.log('🔧 MKV Command:', mkvCommand);
		
//         await runCommand(mkvCommand);
		
//         console.log(`✅ MKV remux completed: ${mkvFilePath}`);
		
//         //fs.unlinkSync(mp4FilePath);
//         //srtFiles.forEach(srt => fs.unlinkSync(`${outputPath}/${srt}`));
		
//         return mkvFilePath;
		
//     } catch (error) {
//         console.error('❌ MKV remux failed:', error);
//         throw new Error(`MKV remux failed: ${error.message}`);
//     }
// };

const upscaleVideo = async (inputFilePath, options = {}) => {
    const {
        scale = 2,           // Facteur d'upscale (2x, 4x)
        method = 'realesrgan', // 'realesrgan', 'waifu2x', 'lanczos'
        model = 'realesr-animevideov3', // Modèle Real-ESRGAN
        outputSuffix = '_upscaled',
        deleteOriginal = false,
        fps = null           // FPS de sortie (null = garder l'original)
    } = options;

    try {
        console.log(`🔍 Starting ${scale}x upscale with ${method}...`);
        
        const inputDir = path.dirname(inputFilePath);
        const inputName = path.basename(inputFilePath, '.mp4');
        const outputFilePath = path.join(inputDir, `${inputName}${outputSuffix}.mp4`);
        
        // Vérifier si le fichier upscalé existe déjà
        if (fs.existsSync(outputFilePath)) {
            console.log('📁 Upscaled file already exists, skipping...');
            return outputFilePath;
        }

        // Sélection de la méthode d'upscale
        switch (method.toLowerCase()) {
            case 'realesrgan':
                await upscaleWithRealESRGAN(inputFilePath, outputFilePath, { scale, model });
                break;
           case 'lanczos':
                await upscaleWithLanczos(inputFilePath, outputFilePath, { scale, fps });
                break;
            case 'bicubic':
                await upscaleWithBicubic(inputFilePath, outputFilePath, { scale, fps });
                break;
            case 'super-resolution':
                await upscaleWithSuperResolution(inputFilePath, outputFilePath, { scale, fps });
                break;
            default:
                throw new Error(`Unknown upscale method: ${method}`);
        }

        // Vérifier que le fichier de sortie existe
        if (!fs.existsSync(outputFilePath)) {
            throw new Error('Upscale failed: output file not created');
        }

        // Supprimer l'original si demandé
        if (deleteOriginal) {
            fs.unlinkSync(inputFilePath);
            fs.renameSync(outputFilePath, inputFilePath);
            console.log('🗑️ Original file deleted');
        }

        console.log(`✅ Video upscaled successfully: ${outputFilePath}`);
        return outputFilePath;

    } catch (error) {
        console.error('❌ Video upscale failed:', error);
        throw new Error(`Upscale failed: ${error.message}`);
    }
};

// ========== MÉTHODES D'UPSCALE ==========

async function upscaleWithRealESRGAN(inputPath, outputPath, { scale, model }) {
    console.log(`🤖 Using Real-ESRGAN with model: ${model}`);
    
    const realEsrganPath = softwareService.getLocalBinFileInfo('realesrgan').path;
    
    // Real-ESRGAN pour vidéo (meilleure qualité)
    const command = `${realEsrganPath} -i "${inputPath}" -o "${outputPath}" -n ${model} -s ${scale} -v`;
    
    console.log('🔧 Real-ESRGAN Command:', command);
    await runCommand(command);
}

async function upscaleWithBicubic(inputPath, outputPath, { scale, fps }) {
    console.log('🔄 Using FFmpeg Bicubic');
    
    const videoInfo = await getVideoInfo(inputPath);
    const newWidth = Math.round(videoInfo.width * scale);
    const newHeight = Math.round(videoInfo.height * scale);
    
    const fpsFilter = fps ? ` -r ${fps}` : '';
    const command = `ffmpeg -i "${inputPath}" -vf "scale=${newWidth}:${newHeight}:flags=bicubic" -c:a copy${fpsFilter} "${outputPath}"`;
    
    console.log('🔧 FFmpeg Bicubic Command:', command);
    await runCommand(command);
}

async function upscaleWithSuperResolution(inputPath, outputPath, { scale, fps }) {
    console.log('🧠 Using FFmpeg Super Resolution filter');
    
    const videoInfo = await getVideoInfo(inputPath);
    const newWidth = Math.round(videoInfo.width * scale);
    const newHeight = Math.round(videoInfo.height * scale);
    
    // Utilise le filtre super-resolution de FFmpeg (si disponible)
    const fpsFilter = fps ? ` -r ${fps}` : '';
    const command = `ffmpeg -i "${inputPath}" -vf "scale=${newWidth}:${newHeight}:flags=lanczos+accurate_rnd+full_chroma_int" -c:a copy${fpsFilter} "${outputPath}"`;
    
    console.log('🔧 FFmpeg Super Resolution Command:', command);
    await runCommand(command);
}

async function upscaleWithLanczos(inputPath, outputPath, { scale }) {
    console.log('⚡ Using FFmpeg Lanczos (fast fallback)');
    
    // Déterminer la résolution cible
    const videoInfo = await getVideoInfo(inputPath);
    const newWidth = Math.round(videoInfo.width * scale);
    const newHeight = Math.round(videoInfo.height * scale);
    
    // FFmpeg avec filtre Lanczos (rapide mais qualité moindre)
    const command = `ffmpeg -i "${inputPath}" -vf "scale=${newWidth}:${newHeight}:flags=lanczos" -c:a copy "${outputPath}"`;
    
    console.log('🔧 FFmpeg Lanczos Command:', command);
    await runCommand(command);
}

// ========== FONCTIONS UTILITAIRES ==========

async function getVideoInfo(filePath) {
    try {
        // const command = `ffprobe -v quiet -print_format json -show_format -show_streams "${filePath}"`;
        // const output = await runCommand(command, { returnOutput: true });
        const info = await ffprobe(filePath, { path: ffprobeStatic.path });

        console.log(info);
        
        const videoStream = info.streams.find(stream => stream.codec_type === 'video');
        
        return {
            width: parseInt(videoStream.width),
            height: parseInt(videoStream.height),
            //duration: parseFloat(info.format.duration),
            codec: videoStream.codec_name
        };
    } catch (error) {
        console.warn('⚠️ Could not get video info, using defaults', error);
        return { width: 1920, height: 1080, duration: 0, codec: 'unknown' };
    }
}

// ========== FONCTION D'AIDE POUR CHOISIR LA MEILLEURE MÉTHODE ==========

function getRecommendedUpscaleMethod(videoInfo, contentType = 'mixed') {
    const { width, height } = videoInfo;
    const totalPixels = width * height;
    
    // Recommandations basées sur le contenu et la résolution
    if (contentType === 'anime' || contentType === 'cartoon') {
        return {
            method: 'waifu2x',
            model: null,
            reason: 'Optimized for animated content'
        };
    }
    
    if (totalPixels < 1000000) { // < 1MP (très basse résolution)
        return {
            method: 'realesrgan',
            model: 'realesr-animevideov3',
            reason: 'Best quality for low resolution content'
        };
    }
    
    if (totalPixels < 2000000) { // < 2MP (résolution moyenne)
        return {
            method: 'realesrgan',
            model: 'realesrgan-x4plus',
            reason: 'Good balance of quality and speed'
        };
    }
    
    // Haute résolution - utiliser Lanczos pour la vitesse
    return {
        method: 'lanczos',
        model: null,
        reason: 'Fast processing for high resolution content'
    };
}

// ========== EXEMPLE D'UTILISATION ==========

/*
// Utilisation basique
const upscaledPath = await upscaleVideo('/path/to/video.mp4');

// Utilisation avancée
const upscaledPath = await upscaleVideo('/path/to/video.mp4', {
    scale: 4,
    method: 'realesrgan',
    model: 'realesr-animevideov3',
    outputSuffix: '_4x_upscaled',
    deleteOriginal: false
});

// Auto-détection de la meilleure méthode
const videoInfo = await getVideoInfo(inputPath);
const recommendation = getRecommendedUpscaleMethod(videoInfo, 'mixed');
const upscaledPath = await upscaleVideo(inputPath, {
    method: recommendation.method,
    model: recommendation.model,
    scale: 2
});
*/

const remuxToMKV = async (options) => {
	const { 
		mp4FilePath,        // Mode classique (MP4 existant)
		videoFilePath,      // Mode direct (fichier vidéo décrypté)
		audioFiles,         // Mode direct (array de fichiers audio)
		subtitleFiles,      // Mode direct (array de fichiers SRT)
		outputPath, 
		filename, 
		wantedAudioTracks, 
		wantedSubtitles, 
		videoInfo 
	} = options;
	
	try {
		console.log('🎬 Starting MKV creation...');
		
		const mkvFilePath = `${outputPath}/${filename}.mkv`;
		const isDirect = videoFilePath && audioFiles; // Mode direct si ces params sont fournis
		
		console.log(`📝 Mode: ${isDirect ? 'Direct from decrypted files' : 'Remux from MP4'}`);
		
		// Construction de la commande de base
		let mkvCommand = `mkvmerge -o "${mkvFilePath}" --verbose --title "${filename}"`;
		
		// === PARTIE VIDÉO ===
		const resolution = videoInfo?.resolution || { width: 'Unknown', height: 'Unknown' };
		const videoFile = isDirect ? videoFilePath : mp4FilePath;
		
		mkvCommand += ` --language 0:und --track-name "0:Video ${resolution.width}x${resolution.height}" "${videoFile}"`;
		
		// === PARTIE AUDIO ===
		if (isDirect) {
			wantedAudioTracks.forEach((audioTrack, index) => {
				const { language, codec, bitrate } = extractAudioTrackInfo(audioTrack);
				
				const matchingAudioFile = audioFiles.find(audioFile => {
					const filename = path.basename(audioFile);
					return filename.includes(`.${language.toLowerCase()}_`) || filename.includes(`_${language.toLowerCase()}.`) || filename.includes(`_${language.toLowerCase()}_`);
				});
				
				if (matchingAudioFile) {
					console.log(`🔗 Matching ${language} track with: ${path.basename(matchingAudioFile)}`);
					
					mkvCommand += ` --language 0:${language}`;
					mkvCommand += ` --track-name "0:${language.toUpperCase()} ${codec} ${bitrate}kbps"`;
					mkvCommand += ` --default-track 0:${index === 0 ? 'yes' : 'no'}`;
					mkvCommand += ` "${matchingAudioFile}"`;
				} else {
					console.warn(`⚠️ No audio file found for language: ${language}`);
				}
			});
		} else {
			wantedAudioTracks.forEach((audioTrack, index) => {
				const { language, codec, bitrate } = extractAudioTrackInfo(audioTrack);
				const trackIndex = index + 1; // +1 car 0 = vidéo
				
				mkvCommand += ` --language ${trackIndex}:${language}`;
				mkvCommand += ` --track-name "${trackIndex}:${language.toUpperCase()}"`;
				mkvCommand += ` --default-track ${trackIndex}:${index === 0 ? 'yes' : 'no'}`;
			});
		}
		
		// === PARTIE SOUS-TITRES ===
		const srtFilesToProcess = isDirect ? subtitleFiles : findSrtFiles(outputPath, filename);
        
        // Matcher les sous-titres par langue comme pour l'audio
        wantedSubtitles.forEach((subtitleInfo, index) => {
            const language = subtitleInfo.language || 'und';
            
            // Trouver le fichier SRT correspondant à cette langue
            const matchingSrtFile = srtFilesToProcess.find(srtPath => {
                const filename = path.basename(srtPath).toLowerCase();
                return filename.includes(`.${language.toLowerCase()}_`) || 
                       filename.includes(`_${language.toLowerCase()}.`) || 
                       filename.includes(`_${language.toLowerCase()}_`) ||
                       filename.includes(`.${language.toLowerCase()}.`);
            });
            
            if (matchingSrtFile) {
                console.log(`🔗 Matching ${language} subtitle with: ${path.basename(matchingSrtFile)}`);
                
                const { isForced, trackName } = extractSubtitleInfo(subtitleInfo, matchingSrtFile);
                
                mkvCommand += ` --language 0:${language}`;
                mkvCommand += ` --track-name "0:${trackName}"`;
                
                if (isForced) {
                    mkvCommand += ` --forced-track 0:yes`;
                }
                
                const defaultAudioLang = wantedAudioTracks[0]?.language;
                const isDefault = (index === 0 && language === defaultAudioLang) ? 'yes' : 'no';
                mkvCommand += ` --default-track 0:${isDefault}`;
                
                mkvCommand += ` "${matchingSrtFile}"`;
            } else {
                console.warn(`⚠️ No subtitle file found for language: ${language}`);
            }
        });
		
		console.log('🔧 MKV Command:', mkvCommand);
		console.log('⚙️  Will execute:', mkvCommand);
		
		await runCommand(mkvCommand);
		
		console.log(`✅ MKV creation completed: ${mkvFilePath}`);
		
		// Nettoyage optionnel (commenté pour sécurité)
		// if (!isDirect && mp4FilePath) fs.unlinkSync(mp4FilePath);
		// srtFilesToProcess.forEach(srt => fs.unlinkSync(srt));
		
		return mkvFilePath;
		
	} catch (error) {
		console.error('❌ MKV creation failed:', error);
		throw new Error(`MKV creation failed: ${error.message}`);
	}
};

// ========== FONCTIONS UTILITAIRES ==========

function extractAudioTrackInfo(audioTrack) {
	const language = audioTrack.language || 'und';
	const codec = audioTrack.codec?.split('.')[0] || 'unknown';
	const bitrate = Math.round((audioTrack.bandwidth || 0) / 1000);
	
	return { language, codec, bitrate };
}

function extractSubtitleInfo(subtitleInfo, srtPath) {
	const language = subtitleInfo.language || 'und';
	
	// Détecter si c'est forcé via le nom du fichier ou les métadonnées
	const filename = path.basename(srtPath).toLowerCase();
	const isForced = false;//filename.includes('forced') || 
					//filename.includes('sdh') === false || 
					//subtitleInfo.forced === true;
	
	const trackName = isForced ? `${language.toUpperCase()} Forced` : language.toUpperCase();
	
	return { language, isForced, trackName };
}

function findSrtFiles(outputPath, filename) {
	try {
		return fs.readdirSync(outputPath)
			.filter(file => file.startsWith(filename) && file.endsWith('.srt'))
			.map(file => `${outputPath}/${file}`)
			.sort(); // Tri pour ordre prévisible
	} catch (error) {
		console.warn('⚠️ Could not read SRT files:', error.message);
		return [];
	}
}

// Processus de la file d'attente
// videoQueue.process((job) => {
// 	return new Promise(async (resolve, reject) => {
// 		try {
// 			console.log('Will launch job')
// 			const { mp4Filename, mpdUrl, keys, wantedResolution, wantedAudioTracks, wantedSubtitles, wantedRemux } = job.data;
// 			const downloaderPath = softwareService.getLocalBinFileInfo('downloader').path;
// 			const mp4decryptPath = softwareService.getLocalBinFileInfo('mp4decrypt').path;

// 			console.log('wantedSubtitles', wantedSubtitles);
// 			const workdir = path.join(TMP_PATH, mp4Filename);
// 			if (!fs.existsSync(workdir))
// 				fs.mkdirSync(workdir);
// 			const mp4FilenameWithExt= `${mp4Filename}.mp4`;
// 			const finalPath = path.join(OUTPUT_PATH, mp4Filename);

// 			const filesExist = await checkFilesExistance('encrypted', workdir);
// 			if (filesExist.length === 0) {
// 				console.log('Encrypted files not found, downloading...');
// 				let objectsDownloaded = -1, previousPercentage = -1;
// 				const objectsToDownload = 1 + wantedAudioTracks.length + wantedSubtitles.length;
// 				job.progress(10);  // Début à 10%

// 				const bwAudio = wantedAudioTracks.length === 1 ? `:bwMin=\"${wantedAudioTracks.map(elem => Math.floor(elem.attributes.BANDWIDTH / 1000 -1)).join('|')}\":bwMax=\"${wantedAudioTracks.map(elem => Math.round(elem.attributes.BANDWIDTH / 1000 + 1)).join('|')}\"` : '';
// 				const bwSubs = wantedSubtitles.length === 1 ? `:bwMin=\"${wantedSubtitles.map(elem => Math.floor(elem.attributes.BANDWIDTH / 1000 -1)).join('|')}\":bwMax=\"${wantedSubtitles.map(elem => Math.round(elem.attributes.BANDWIDTH / 1000 + 1)).join('|')}\"` : '';

// 				const subPart = wantedSubtitles.length > 0 ? `--select-subtitle lang=\"${wantedSubtitles.map(elem => elem.language).join('|')}\"${bwSubs}` : '--drop-subtitle lang=\".*\"';
// 				const audioPart = wantedAudioTracks.length > 0 ? `--select-audio lang=\"${wantedAudioTracks.map(elem => elem.language).join('|')}\":codecs=\"${[...new Set(wantedAudioTracks.map(elem => elem.attributes.CODECS))].join('|')}\":for=all${bwAudio}` : '--drop-audio lang=\".*\"';

// 				const { executeCommand, emitter } = runProgressCommand(`${downloaderPath} \"${mpdUrl}\" --save-dir ${workdir} --save-name ${mp4Filename}_encrypted --select-video id=\"${wantedResolution.id}\" ${audioPart} ${subPart}`, true);

// 				emitter.on('percentage', (percentage) => {
// 				    if (percentage < previousPercentage) {
// 				        objectsDownloaded++;
// 				    }
// 				    previousPercentage = percentage;

// 				    const subPercMax = 50 / objectsToDownload;
// 				    job.progress(Math.round((10 + (objectsDownloaded * subPercMax)) + (percentage * subPercMax / 100)));
// 				});

// 				await executeCommand;
// 			} else {
// 				console.log('Encrypted files already exist, bypassing download...')
// 			}
// 			job.progress(60);

// 			// Decrypt video stream
// 			await runCommand(`${mp4decryptPath} ${keys.map(k => `--key ${k.key}:${k.value}`).join(' ')} "${workdir}/${mp4Filename}_encrypted.mp4" "${workdir}/${mp4Filename}_decrypted.mp4"`);

// 			job.progress(70);

// 			// Decrypt audio streams
// 			const audioFiles = fs.readdirSync(workdir);
// 			const finalAudio = [];
// 			for (const file of audioFiles) {
// 				if (file.startsWith(`${mp4Filename}_encrypted`) && file.endsWith('.m4a')) {
// 					const baseName = path.basename(file, '.m4a');
// 					await runCommand(`${mp4decryptPath} ${keys.map(k => `--key ${k.key}:${k.value}`).join(' ')} "${workdir}/${file}" "${workdir}/${baseName}_decrypted.m4a"`);
// 					finalAudio.push(`${workdir}/${baseName}_decrypted.m4a`);
// 				}
// 			}

// 			job.progress(80);

// 			// Combinaison avec ffmpeg
// 			let ffmpegCommand = `ffmpeg -y -i ${workdir}/${mp4Filename}_decrypted.mp4`;
// 			let mapCommand = ' -map 0:v';
// 			let inputIndex = 1;

// 			for (const file of finalAudio) {
// 				ffmpegCommand += ` -i ${file}`;
// 				mapCommand += ` -map ${inputIndex}:a`;
// 				inputIndex++;
// 			}

// 			if (!fs.existsSync(finalPath))
// 				fs.mkdirSync(finalPath);

// 			ffmpegCommand += `${mapCommand} -c copy ${finalPath}/${mp4FilenameWithExt}`;
// 			await runCommand(ffmpegCommand);

// 			job.progress(90);

// 			if (wantedRemux) {
// 				console.log('🎬 Starting optional MKV remux...');

// 				try {
// 					await remuxToMKV({
// 						mp4FilePath: `${finalPath}/${mp4FilenameWithExt}`,
// 						outputPath: finalPath,
// 						filename: mp4Filename,
// 						wantedAudioTracks,
// 						wantedSubtitles,
// 						videoInfo: wantedResolution
// 					});

// 					job.progress(95);
// 					console.log('✅ MKV remux completed successfully');

// 				} catch (remuxError) {
// 					console.error('⚠️  MKV remux failed, keeping MP4:', remuxError);
// 				}
// 			}

// 			// Renommage des fichiers SRT
// 			const subFiles = fs.readdirSync(workdir);
// 			let counter = 1;
// 			for (const file of subFiles) {
// 				if (file.startsWith(`${mp4Filename}_encrypted`) && file.endsWith('.srt')) {
// 					const sourcePath = `${workdir}/${file}`;
// 					const destPath = `${finalPath}/${mp4Filename}_${counter}.srt`;

// 					await safeMove(sourcePath, destPath);
// 					counter++;
// 				}
// 			}


// 			// Nettoyage (commenté pour correspondre au script original)
// 			await runCommand(`rm -fr ${workdir}`);

// 			job.progress(100);
// 			resolve({ message: `File fetched and decrypted with success: ${mp4Filename}.mp4`, filePath: `${OUTPUT_PATH}/${mp4Filename}.mp4`, fileName: `${mp4Filename}.mp4` });
// 		} catch (error) {
// 			console.log('Error while processing task', error)
// 			reject(new Error(`${error.toString() || error}`));
// 		}
// 	});
// });

videoQueue.process(async (job) => {
	try {
		console.log('🚀 Starting video processing job');
		const { mp4Filename, mpdUrl, keys, wantedResolution, wantedAudioTracks, wantedSubtitles, wantedRemux, wantToUpscale } = job.data;

		const config = {
			downloaderPath: softwareService.getLocalBinFileInfo('downloader').path,
			mp4decryptPath: softwareService.getLocalBinFileInfo('mp4decrypt').path,
			workdir: path.join(TMP_PATH, mp4Filename),
			mp4FilenameWithExt: `${mp4Filename}.mp4`,
			finalPath: path.join(OUTPUT_PATH, mp4Filename)
		};

		await prepareDirectories(config);

		await downloadEncryptedFiles(job, config, { mpdUrl, wantedResolution, wantedAudioTracks, wantedSubtitles, mp4Filename });
		job.progress(60);

		await decryptVideoFile(config, keys, mp4Filename);
		job.progress(70);

		const decryptedAudioFiles = await decryptAudioFiles(config, keys, mp4Filename);
		job.progress(80);

		if (wantToUpscale) {
			await upscaleVideo(`${config.workdir}/${mp4Filename}_decrypted.mp4`, {
				method: 'lanczos',
				deleteOriginal: true,
			});
		}

		if (wantedRemux) {
			console.log('🎬 Direct MKV creation with mkvtoolnix (bypassing FFmpeg)...');
			await createMKVDirectly(config, { 
				decryptedAudioFiles, 
				wantedAudioTracks, 
				wantedSubtitles, 
				videoInfo: wantedResolution, 
				mp4Filename 
			});
			job.progress(95);
		} else {
			await combineMediaFiles(config, decryptedAudioFiles, mp4Filename);
			job.progress(90);
		}

		await handleSubtitlesAndCleanup(config, mp4Filename);
		job.progress(100);

		const finalExtension = wantedRemux ? '.mkv' : '.mp4';
		const finalFileName = `${mp4Filename}${finalExtension}`;

		return { 
			message: `File fetched and decrypted with success: ${finalFileName}`, 
			filePath: `${OUTPUT_PATH}/${mp4Filename}/${finalFileName}`, 
			fileName: finalFileName
		};

	} catch (error) {
		console.error('❌ Error while processing task:', error);
		throw new Error(`Processing failed: ${error.message || error}`);
	}
});

async function createMKVDirectly(config, { decryptedAudioFiles, wantedAudioTracks, wantedSubtitles, videoInfo, mp4Filename }) {
	console.log('🎬 Creating MKV directly from decrypted files...');
	const { workdir, finalPath } = config;

	const subFiles = fs.readdirSync(workdir);
	const srtFiles = subFiles
		.filter(file => file.startsWith(`${mp4Filename}_encrypted`) && file.endsWith('.srt'))
		.map(file => `${workdir}/${file}`);

	try {
		await remuxToMKV({
			videoFilePath: `${workdir}/${mp4Filename}_decrypted.mp4`,
			audioFiles: decryptedAudioFiles,
			subtitleFiles: srtFiles,
			outputPath: finalPath,
			filename: mp4Filename,
			wantedAudioTracks,
			wantedSubtitles,
			videoInfo
		});
		
		console.log('✅ Direct MKV creation completed successfully');
	} catch (remuxError) {
		console.error('❌ Direct MKV creation failed:', remuxError);
		// Fallback vers FFmpeg si échec
		console.log('🔄 Falling back to FFmpeg + remux...');
		await combineMediaFiles(config, decryptedAudioFiles, mp4Filename);
		await performMKVRemux(config, { wantedAudioTracks, wantedSubtitles, videoInfo: videoInfo, mp4Filename });
	}
}

async function prepareDirectories(config) {
	const { workdir, finalPath } = config;
	
	if (!fs.existsSync(workdir)) {
		fs.mkdirSync(workdir, { recursive: true });
	}
	if (!fs.existsSync(finalPath)) {
		fs.mkdirSync(finalPath, { recursive: true });
	}
}

const downloadMPDManifest = async (url, filepath) => {
	try {
		const response = await axios({
			method: 'GET',
			url,
			headers: {
				'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:142.0) Gecko/20100101 Firefox/142.0',
        		'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
				'Accept-Language': 'en-US,en;q=0.5',
				'Accept-Encoding': 'gzip, deflate, br, zstd'
			},
			decompress: true
		});

		fs.writeFileSync(filepath, response.data);

		return response.data;
	} catch (error) {
		console.error('Erreur lors du téléchargement:', error.message);
		throw error;
	}
};

async function downloadEncryptedFiles(job, config, { mpdUrl, wantedResolution, wantedAudioTracks, wantedSubtitles, mp4Filename }) {
	const { workdir, downloaderPath } = config;
	const filesExist = await checkFilesExistance('encrypted', workdir);
	
	if (filesExist.length > 0) {
		console.log('📁 Encrypted files already exist, bypassing download...');
		return;
	}
	console.log('⬇️  Encrypted files not found, downloading...');
	
	const downloadParams = buildDownloadParameters(wantedAudioTracks, wantedSubtitles);
	const objectsToDownload = 1 + wantedAudioTracks.length + wantedSubtitles.length;
	
	job.progress(10);
	await downloadMPDManifest(mpdUrl, `${workdir}/manifest.mpd`);
	
	const baseUrl = mpdUrl.substring(0, mpdUrl.lastIndexOf('/') + 1);
	
	const command = `${downloaderPath} "${workdir}/manifest.mpd" --base-url "${baseUrl}" --save-dir "${workdir}" --save-name "${mp4Filename}_encrypted" --select-video id="${wantedResolution.id}" ${downloadParams.audioPart} ${downloadParams.subPart} -H "User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:142.0) Gecko/20100101 Firefox/142.0"`;
	
	const { executeCommand, emitter } = runProgressCommand(command, true);
	// Gestion du progress avec meilleure lisibilité
	let objectsDownloaded = -1;
	let previousPercentage = -1;
	emitter.on('percentage', (percentage) => {
		if (percentage < previousPercentage) {
			objectsDownloaded++;
		}
		previousPercentage = percentage;
		const subPercMax = 50 / objectsToDownload;
		const newProgress = Math.round((10 + (objectsDownloaded * subPercMax)) + (percentage * subPercMax / 100));
		job.progress(newProgress);
	});
	await executeCommand;
}

function buildDownloadParameters(wantedAudioTracks, wantedSubtitles) {
	// Construire la sélection par ID pour audio
	const audioPart = wantedAudioTracks.length > 0 
		? `--select-audio id="${wantedAudioTracks.map(elem => elem.id).join('|')}":for=all`
		: '--drop-audio id=".*"';
	
	// Construire la sélection par ID pour sous-titres
	const subPart = wantedSubtitles.length > 0 
		? `--select-subtitle id="${wantedSubtitles.map(elem => elem.id).join('|')}":for=all`
		: '--drop-subtitle id=".*"';
	
	return { audioPart, subPart };
}

async function decryptVideoFile(config, keys, mp4Filename) {
	console.log('🔓 Decrypting video stream...');
	const { workdir, mp4decryptPath } = config;
	
	const keyParams = keys.map(k => `--key ${k.key}:${k.value}`).join(' ');
	const command = `${mp4decryptPath} ${keyParams} "${workdir}/${mp4Filename}_encrypted.mp4" "${workdir}/${mp4Filename}_decrypted.mp4"`;
	
	await runCommand(command);
}

async function decryptAudioFiles(config, keys, mp4Filename) {
	console.log('🔓 Decrypting audio streams...');
	const { workdir, mp4decryptPath } = config;
	
	const audioFiles = fs.readdirSync(workdir);
	const encryptedAudioFiles = audioFiles.filter(file => 
		file.startsWith(`${mp4Filename}_encrypted`) && file.endsWith('.m4a')
	);

	const decryptedAudioFiles = [];
	const keyParams = keys.map(k => `--key ${k.key}:${k.value}`).join(' ');

	// Déchiffrer tous les fichiers audio
	for (const file of encryptedAudioFiles) {
		const baseName = path.basename(file, '.m4a');
		const decryptedPath = `${workdir}/${baseName}_decrypted.m4a`;
		
		const command = `${mp4decryptPath} ${keyParams} "${workdir}/${file}" "${decryptedPath}"`;
		await runCommand(command);
		
		decryptedAudioFiles.push(decryptedPath);
	}

	return decryptedAudioFiles;
}

async function combineMediaFiles(config, decryptedAudioFiles, mp4Filename) {
	console.log('🎬 Combining media files with FFmpeg...');
	const { workdir, finalPath, mp4FilenameWithExt } = config;
	
	// Construction de la commande FFmpeg
	let ffmpegCommand = `ffmpeg -y -i ${workdir}/${mp4Filename}_decrypted.mp4`;
	let mapCommand = ' -map 0:v';
	
	// Ajouter les inputs audio et leurs mappings
	decryptedAudioFiles.forEach((file, index) => {
		const inputIndex = index + 1;
		ffmpegCommand += ` -i ${file}`;
		mapCommand += ` -map ${inputIndex}:a`;
	});

	ffmpegCommand += `${mapCommand} -c copy ${finalPath}/${mp4FilenameWithExt}`;
	await runCommand(ffmpegCommand);
}

async function performMKVRemux(config, { wantedAudioTracks, wantedSubtitles, videoInfo, mp4Filename }) {
	console.log('🎬 Starting optional MKV remux...');
	
	try {
		await remuxToMKV({
			mp4FilePath: `${config.finalPath}/${config.mp4FilenameWithExt}`,
			outputPath: config.finalPath,
			filename: mp4Filename,
			wantedAudioTracks,
			wantedSubtitles,
			videoInfo
		});
		
		console.log('✅ MKV remux completed successfully');
	} catch (remuxError) {
		console.error('⚠️  MKV remux failed, keeping MP4:', remuxError);
		// On continue sans faire échouer le job
	}
}

async function handleSubtitlesAndCleanup(config, mp4Filename) {
	console.log('📝 Handling subtitles and cleanup...');
	const { workdir, finalPath } = config;
	
	// Renommage des fichiers SRT
	const subFiles = fs.readdirSync(workdir);
	const srtFiles = subFiles.filter(file => 
		file.startsWith(`${mp4Filename}_encrypted`) && file.endsWith('.srt')
	);

	for (let i = 0; i < srtFiles.length; i++) {
		const file = srtFiles[i];
		const sourcePath = `${workdir}/${file}`;
		const destPath = `${finalPath}/${mp4Filename}_${i + 1}.srt`;
		
		await safeMove(sourcePath, destPath);
	}

	// Nettoyage du répertoire de travail
	console.log('🧹 Cleaning up temporary files...');
	await runCommand(`rm -rf ${workdir}`);
}

app.listen(port, () => {
	console.log(`Server running at http://localhost:${port}`);
	const dirsToCheck = [{
		path: BASE_PATH,
		name: 'data'
	}, {
		path: OUTPUT_PATH,
		name: 'output'
	}, {
		path: TMP_PATH,
		name: 'tmp'
	}];

	for (let i = 0; i < dirsToCheck.length; i++) {
		const dir = dirsToCheck[i];
		if (!fs.existsSync(dir.path)) {
			console.log(`Creating ${dir.name} directory...`);
			fs.mkdirSync(dir.path);
		}
	}
	
	softwareService.init();

});