import { getConfig as loadConfig } from '../../shared/config.js';
import { queryOne, queryAll, run } from '../../shared/database.js';
import { getAnimeById } from '../anime/anime.service';
import { getBookById } from '../books/books.service';
import crypto from 'crypto';
import fs from 'fs';
import path from 'path';
import { exec } from 'child_process';
import { promisify } from 'util';
import AdmZip from 'adm-zip';

const execPromise = promisify(exec);

const FFMPEG_PATH = 'D:\\ffmpeg\\bin\\ffmpeg.exe'; // Hardcoded como pediste

type AnimeDownloadParams = {
    anilistId: number;
    episodeNumber: number;
    streamUrl: string;
    quality?: string;
    subtitles?: Array<{ language: string; url: string }>;
    chapters?: Array<{ title: string; start_time: number; end_time: number }>;
};

type BookDownloadParams = {
    anilistId: number;
    chapterNumber: number;
    format: 'manga' | 'novel';
    content?: string;
    images?: Array<{ index: number; url: string }>;
};

async function ensureDirectory(dirPath: string) {
    if (!fs.existsSync(dirPath)) {
        fs.mkdirSync(dirPath, { recursive: true });
    }
}

async function downloadFile(url: string, outputPath: string): Promise<void> {
    const res = await fetch(url);
    if (!res.ok) throw new Error(`HTTP_${res.status}`);

    await ensureDirectory(path.dirname(outputPath));
    const buf = Buffer.from(await res.arrayBuffer());
    fs.writeFileSync(outputPath, buf);
}

async function getOrCreateEntry(
    anilistId: number,
    type: 'anime' | 'manga' | 'novels'
): Promise<{ id: string; path: string; folderName: string }> {
    const existing = await queryOne(
        `SELECT id, path, folder_name FROM local_entries 
         WHERE matched_id = ? AND matched_source = 'anilist' AND type = ?`,
        [anilistId, type],
        'local_library'
    );

    if (existing) {
        return {
            id: existing.id,
            path: existing.path,
            folderName: existing.folder_name
        };
    }

    const metadata: any = type === 'anime'
        ? await getAnimeById(anilistId)
        : await getBookById(anilistId);

    if (!metadata) {
        throw new Error('METADATA_NOT_FOUND');
    }

    const config = loadConfig();
    const basePath = config.library?.[type];

    if (!basePath) {
        throw new Error(`NO_LIBRARY_PATH_FOR_${type.toUpperCase()}`);
    }

    const title = metadata.title?.romaji || metadata.title?.english || `ID_${anilistId}`;
    const safeName = title.replace(/[<>:"/\\|?*]/g, '_');
    const folderPath = path.join(basePath, safeName);

    await ensureDirectory(folderPath);

    const entryId = crypto.createHash('sha1').update(folderPath).digest('hex');
    const now = Date.now();

    await run(
        `INSERT INTO local_entries (id, type, path, folder_name, matched_id, matched_source, last_scan)
         VALUES (?, ?, ?, ?, ?, 'anilist', ?)`,
        [entryId, type, folderPath, safeName, anilistId, now],
        'local_library'
    );

    return {
        id: entryId,
        path: folderPath,
        folderName: safeName
    };
}

export async function downloadAnimeEpisode(params: AnimeDownloadParams) {
    const { anilistId, episodeNumber, streamUrl, quality, subtitles, chapters } = params;

    const entry = await getOrCreateEntry(anilistId, 'anime');

    const existingFile = await queryOne(
        `SELECT id FROM local_files WHERE entry_id = ? AND unit_number = ?`,
        [entry.id, episodeNumber],
        'local_library'
    );

    if (existingFile) {
        return {
            status: 'ALREADY_EXISTS',
            message: `Episode ${episodeNumber} already exists`,
            entry_id: entry.id,
            episode: episodeNumber
        };
    }

    const outputFileName = `Episode_${episodeNumber.toString().padStart(2, '0')}.mkv`;
    const outputPath = path.join(entry.path, outputFileName);
    const tempDir = path.join(entry.path, '.temp');
    await ensureDirectory(tempDir);

    try {
        let inputArgs: string[] = [];
        let videoInput = streamUrl;

        if (streamUrl.includes('.m3u8')) {
            if (quality) {
                const tempM3u8 = path.join(tempDir, 'stream.m3u8');
                await downloadFile(streamUrl, tempM3u8);
                const content = fs.readFileSync(tempM3u8, 'utf8');

                const qualities = content.match(/RESOLUTION=\d+x(\d+)/g) || [];
                const targetHeight = quality.replace('p', '');
                const targetLine = content.split('\n').find(line =>
                    line.includes(`RESOLUTION=`) && line.includes(`x${targetHeight}`)
                );

                if (targetLine) {
                    const nextLine = content.split('\n')[content.split('\n').indexOf(targetLine) + 1];
                    if (nextLine && !nextLine.startsWith('#')) {
                        const baseUrl = streamUrl.substring(0, streamUrl.lastIndexOf('/') + 1);
                        videoInput = nextLine.startsWith('http') ? nextLine : baseUrl + nextLine;
                    }
                }

                fs.unlinkSync(tempM3u8);
            }
        }

        inputArgs = ['-i', videoInput];

        const subtitleFiles: string[] = [];
        if (subtitles && subtitles.length > 0) {
            for (let i = 0; i < subtitles.length; i++) {
                const sub = subtitles[i];
                const subPath = path.join(tempDir, `subtitle_${i}.${sub.url.endsWith('.vtt') ? 'vtt' : 'srt'}`);
                await downloadFile(sub.url, subPath);
                subtitleFiles.push(subPath);
                inputArgs.push('-i', subPath);
            }
        }

        let ffmpegArgs = [
            ...inputArgs,
            '-map', '0:v',
            '-map', '0:a',
            '-c:v', 'copy',
            '-c:a', 'copy'
        ];

        for (let i = 0; i < subtitleFiles.length; i++) {
            ffmpegArgs.push('-map', `${i + 1}:s`);
            ffmpegArgs.push(`-metadata:s:s:${i}`, `language=${subtitles![i].language}`);
        }

        if (subtitleFiles.length > 0) {
            ffmpegArgs.push('-c:s', 'copy');
        }

        if (chapters && chapters.length > 0) {
            const metadataFile = path.join(tempDir, 'chapters.txt');
            let chapterContent = ';FFMETADATA1\n';

            for (const chapter of chapters) {
                const startMs = Math.floor(chapter.start_time * 1000);
                const endMs = Math.floor(chapter.end_time * 1000);

                chapterContent += '[CHAPTER]\n';
                chapterContent += `TIMEBASE=1/1000\n`;
                chapterContent += `START=${startMs}\n`;
                chapterContent += `END=${endMs}\n`;
                chapterContent += `title=${chapter.title}\n`;
            }

            fs.writeFileSync(metadataFile, chapterContent);
            ffmpegArgs.push('-i', metadataFile);
            ffmpegArgs.push('-map_metadata', `${inputArgs.length / 2}`);
        }

        ffmpegArgs.push(outputPath);

        const command = `${FFMPEG_PATH} ${ffmpegArgs.join(' ')}`;
        await execPromise(command, { maxBuffer: 1024 * 1024 * 100 });

        fs.rmSync(tempDir, { recursive: true, force: true });

        const fileId = crypto.randomUUID();
        await run(
            `INSERT INTO local_files (id, entry_id, file_path, unit_number)
             VALUES (?, ?, ?, ?)`,
            [fileId, entry.id, outputPath, episodeNumber],
            'local_library'
        );

        await run(
            `UPDATE local_entries SET last_scan = ? WHERE id = ?`,
            [Date.now(), entry.id],
            'local_library'
        );

        return {
            status: 'SUCCESS',
            entry_id: entry.id,
            file_id: fileId,
            episode: episodeNumber,
            path: outputPath
        };

    } catch (error: any) {
        fs.rmSync(tempDir, { recursive: true, force: true });
        if (fs.existsSync(outputPath)) {
            fs.unlinkSync(outputPath);
        }

        const err = new Error('DOWNLOAD_FAILED');
        (err as any).details = error.message;
        throw err;
    }
}

export async function downloadBookChapter(params: BookDownloadParams) {
    const { anilistId, chapterNumber, format, content, images } = params;

    const type = format === 'manga' ? 'manga' : 'novels';
    const entry = await getOrCreateEntry(anilistId, type);

    const existingFile = await queryOne(
        `SELECT id FROM local_files WHERE entry_id = ? AND unit_number = ?`,
        [entry.id, chapterNumber],
        'local_library'
    );

    if (existingFile) {
        return {
            status: 'ALREADY_EXISTS',
            message: `Chapter ${chapterNumber} already exists`,
            entry_id: entry.id,
            chapter: chapterNumber
        };
    }

    try {
        let outputPath: string;
        let fileId: string;

        if (format === 'manga') {
            const chapterName = `Chapter_${chapterNumber.toString().padStart(3, '0')}.cbz`;
            outputPath = path.join(entry.path, chapterName);

            const zip = new AdmZip();
            const sortedImages = images!.sort((a, b) => a.index - b.index);

            for (const img of sortedImages) {
                const res = await fetch(img.url);
                if (!res.ok) throw new Error(`HTTP_${res.status}`);
                const buf = Buffer.from(await res.arrayBuffer());

                const ext = path.extname(new URL(img.url).pathname) || '.jpg';
                const filename = `${img.index.toString().padStart(4, '0')}${ext}`;
                zip.addFile(filename, buf);
            }

            zip.writeZip(outputPath);

        } else {
            const chapterName = `Chapter_${chapterNumber.toString().padStart(3, '0')}.epub`;
            outputPath = path.join(entry.path, chapterName);

            const zip = new AdmZip();

            zip.addFile('mimetype', Buffer.from('application/epub+zip'), '', 0);

            const containerXml = `<?xml version="1.0" encoding="UTF-8"?>
<container version="1.0" xmlns="urn:oasis:names:tc:opendocument:xmlns:container">
  <rootfiles>
    <rootfile full-path="OEBPS/content.opf" media-type="application/oebps-package+xml"/>
  </rootfiles>
</container>`;
            zip.addFile('META-INF/container.xml', Buffer.from(containerXml));

            const contentOpf = `<?xml version="1.0" encoding="UTF-8"?>
<package xmlns="http://www.idpf.org/2007/opf" version="3.0" unique-identifier="bookid">
  <metadata xmlns:dc="http://purl.org/dc/elements/1.1/">
    <dc:title>Chapter ${chapterNumber}</dc:title>
    <dc:identifier id="bookid">chapter-${anilistId}-${chapterNumber}</dc:identifier>
    <dc:language>en</dc:language>
  </metadata>
  <manifest>
    <item id="chapter" href="chapter.xhtml" media-type="application/xhtml+xml"/>
  </manifest>
  <spine>
    <itemref idref="chapter"/>
  </spine>
</package>`;
            zip.addFile('OEBPS/content.opf', Buffer.from(contentOpf));

            const chapterXhtml = `<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <title>Chapter ${chapterNumber}</title>
</head>
<body>
${content}
</body>
</html>`;
            zip.addFile('OEBPS/chapter.xhtml', Buffer.from(chapterXhtml));

            zip.writeZip(outputPath);
        }

        fileId = crypto.randomUUID();
        await run(
            `INSERT INTO local_files (id, entry_id, file_path, unit_number)
             VALUES (?, ?, ?, ?)`,
            [fileId, entry.id, outputPath, chapterNumber],
            'local_library'
        );

        await run(
            `UPDATE local_entries SET last_scan = ? WHERE id = ?`,
            [Date.now(), entry.id],
            'local_library'
        );

        return {
            status: 'SUCCESS',
            entry_id: entry.id,
            file_id: fileId,
            chapter: chapterNumber,
            format,
            path: outputPath
        };

    } catch (error: any) {
        const err = new Error('DOWNLOAD_FAILED');
        (err as any).details = error.message;
        throw err;
    }
}