const https = require('https');
const http = require('http');
const fs = require('fs');
const path = require('path');
const crypto = require('crypto');
const multer = require('multer');
const { extractWebseed, extractInfoHash } = require('./torrent');

const SAVE_PATH = process.env.DOWNLOAD_PATH || '/downloads/webshare';
const MEDIA_ROOT = process.env.MEDIA_ROOT || '/data';
const upload = multer({ storage: multer.memoryStorage() });

const MAX_CONCURRENT = parseInt(process.env.MAX_CONCURRENT_DOWNLOADS || '2', 10);
const STATE_FILE = path.join(SAVE_PATH, '.queue-state.json');

// hash → download entry (persisted to disk)
const downloads = new Map();
let activeDownloads = 0;
const waitingQueue = []; // { entry, webseedUrl }

function saveState() {
    try {
        const data = [...downloads.values()].map(e => ({
            hash: e.hash, name: e.name, size: e.size,
            progress: e.progress, state: e.state, category: e.category,
            webseedUrl: e.webseedUrl,
        }));
        fs.writeFileSync(STATE_FILE, JSON.stringify(data));
    } catch { }
}

function loadState() {
    try {
        const data = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
        for (const e of data) {
            if (e.state === 'downloading' || e.state === 'queuedDL') {
                // Always re-download — partial files from interrupted downloads are corrupt
                const filePath = path.join(SAVE_PATH, e.name);
                try { fs.unlinkSync(filePath); } catch { }
                if (e.webseedUrl) {
                    e.progress = 0;
                    downloads.set(e.hash, e);
                    enqueue(e, e.webseedUrl);
                    console.log(`[qbt] re-queued: ${e.name}`);
                }
            } else if (e.state === 'uploading') {
                const filePath = path.join(SAVE_PATH, e.name);
                if (fs.existsSync(filePath)) {
                    // Sync size to actual file — Content-Length may have been wrong
                    try { e.size = fs.statSync(filePath).size; } catch {}
                    downloads.set(e.hash, e);
                    console.log(`[qbt] restored uploading: ${e.name}`);
                }
                // File gone → already imported and cleaned up; drop entry.
                // Sonarr tracks hasFile=true so it won't re-search.
            } else if (e.state === 'error') {
                // Keep as error — don't auto-retry on restart; Sonarr will re-search if needed.
                downloads.set(e.hash, e);
                setTimeout(() => {
                    downloads.delete(e.hash);
                    saveState();
                }, 3 * 60 * 1000);
            } else {
                downloads.set(e.hash, e);
            }
        }
    } catch { }
}

function cleanupAfterDownload(entry) {
    const fpath = path.join(SAVE_PATH, entry.name);
    let attempts = 0;
    const check = setInterval(() => {
        attempts++;
        try {
            if (fs.statSync(fpath).nlink > 1) {
                fs.unlinkSync(fpath);
                console.log(`[cleanup] auto-deleted after import: ${entry.name}`);
                clearInterval(check);
            } else if (attempts >= 60) {
                clearInterval(check);
            }
        } catch { clearInterval(check); }
    }, 10_000);
}

function dequeue() {
    if (activeDownloads >= MAX_CONCURRENT || waitingQueue.length === 0) return;
    const { entry, webseedUrl } = waitingQueue.shift();
    activeDownloads++;
    entry.state = 'downloading';
    (async () => {
        try {
            console.log(`[qbt] downloading ${entry.name} via ${webseedUrl.slice(0, 60)}…`);
            await streamToFile(webseedUrl, entry);
            // Use actual file size — Content-Length header can lie
            try { entry.size = fs.statSync(path.join(SAVE_PATH, entry.name)).size; } catch {}
            entry.progress = 1.0;
            entry.state = 'uploading';
            console.log(`[qbt] done: ${entry.name}`);
            cleanupAfterDownload(entry);
        } catch (err) {
            // Delete partial file before retry
            try { fs.unlinkSync(path.join(SAVE_PATH, entry.name)); } catch { }
            // "File temporarily unavailable" is Webshare's FATAL error — not actually retryable.
            const retryable = err.message.includes('stalled') || err.message.includes('ECONNRESET')
                || err.message.includes('HTTP 5');
            if (retryable) {
                console.warn(`[qbt] will retry ${entry.name} in 2 min: ${err.message}`);
                entry.state = 'queuedDL';
                saveState();
                setTimeout(() => enqueue(entry, webseedUrl), 2 * 60 * 1000);
            } else {
                entry.state = 'error';
                console.error(`[qbt] failed ${entry.name}: ${err.message}`);
                // Sonarr treats qBittorrent's "error" state as an advisory warning, not
                // a failure — it never auto-blocklists/redownloads on its own. Removing
                // the entry makes the download disappear from the client's list, which
                // Sonarr does treat as failed (triggering its existing auto-redownload).
                setTimeout(() => {
                    downloads.delete(entry.hash);
                    saveState();
                }, 3 * 60 * 1000);
            }
        } finally {
            activeDownloads--;
            saveState();
            dequeue();
        }
    })();
}

function enqueue(entry, webseedUrl) {
    entry.state = 'queuedDL';
    entry.webseedUrl = webseedUrl;
    waitingQueue.push({ entry, webseedUrl });
    console.log(`[qbt] queued (${waitingQueue.length} waiting, ${activeDownloads}/${MAX_CONCURRENT} active): ${entry.name}`);
    saveState();
    dequeue();
}

function identToHash(ident) {
    return crypto.createHash('sha1').update('ws:' + ident).digest('hex');
}

function streamToFile(url, entry) {
    return new Promise((resolve, reject) => {
        const follow = (u, hops) => {
            if (hops > 10) return reject(new Error('Too many redirects'));
            const mod = u.startsWith('https') ? https : http;
            mod.get(u, res => {
                if (res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 303) {
                    res.resume();
                    return follow(res.headers.location, hops + 1);
                }
                if (res.statusCode !== 200) {
                    res.resume();
                    return reject(new Error(`HTTP ${res.statusCode}`));
                }

                entry.size = parseInt(res.headers['content-length'] || '0', 10);

                // try to grab filename from Content-Disposition
                const cd = res.headers['content-disposition'] || '';
                const m = cd.match(/filename\*?=(?:UTF-8'')?["']?([^"';\r\n]+)/i);
                if (m) {
                    const fn = decodeURIComponent(m[1].trim().replace(/^["']|["']$/g, ''));
                    if (fn) entry.name = fn;
                }

                let received = 0;
                let lastDataAt = Date.now();
                const dest = path.join(SAVE_PATH, entry.name);
                const file = fs.createWriteStream(dest);

                // Poll every 10s — avoids setTimeout/clearTimeout on every chunk
                const stallCheck = setInterval(() => {
                    if (Date.now() - lastDataAt > 60_000)
                        res.destroy(new Error('Download stalled (60s no data)'));
                }, 10_000);

                res.on('data', chunk => {
                    received += chunk.length;
                    lastDataAt = Date.now();
                    if (entry.size > 0) entry.progress = received / entry.size;
                });
                res.pipe(file);
                const done = () => clearInterval(stallCheck);
                file.on('finish', () => { done(); file.close(resolve); });
                file.on('error', (e) => { done(); reject(e); });
                res.on('error', (e) => { done(); reject(e); });
            }).on('error', reject);
        };
        follow(url, 0);
    });
}


function register(app) {
    fs.mkdirSync(SAVE_PATH, { recursive: true });

    // ── auth ──────────────────────────────────────────────────────────────
    app.post('/api/v2/auth/login', (req, res) => {
        res.cookie('SID', 'webshare-session', { httpOnly: true });
        res.send('Ok.');
    });
    app.get('/api/v2/auth/logout', (req, res) => res.send('Ok.'));

    // ── app info ──────────────────────────────────────────────────────────
    app.get('/api/v2/app/version',       (req, res) => res.send('5.0.0'));
    app.get('/api/v2/app/webapiVersion', (req, res) => res.send('2.8.3'));
    app.get('/api/v2/app/buildInfo',     (req, res) => res.json({
        bitness: 64, boost: '1.84.0', libtorrent: '2.0.10', openssl: '3.2.1', qt: '6.6.2', zlib: '1.3.1',
    }));
    app.get('/api/v2/app/preferences', (req, res) => res.json({
        save_path: SAVE_PATH + '/',
        temp_path_enabled: false,
        create_subfolder_enabled: false,
        incomplete_files_ext: false,
    }));

    // ── torrent list ──────────────────────────────────────────────────────
    app.get('/api/v2/torrents/info', (req, res) => {
        const list = [...downloads.values()].map(d => ({
            hash:         d.hash,
            name:         d.name,
            state:        d.state,
            progress:     d.progress,
            size:         d.size,
            downloaded:   Math.floor(d.progress * d.size),
            save_path:    SAVE_PATH + '/',
            content_path: path.join(SAVE_PATH, d.name),
            num_seeds:    0,
            num_leechs:   0,
            ratio:        0,
            eta:          (d.state === 'downloading' || d.state === 'queuedDL') ? 9999 : 0,
            category:     d.category || '',
            tags:         '',
        }));
        res.json(list);
    });

    app.get('/api/v2/torrents/properties', (req, res) => {
        const d = downloads.get(req.query.hash);
        if (!d) return res.status(404).json({});
        res.json({ save_path: SAVE_PATH + '/', hash: d.hash });
    });

    // Sonarr calls this to discover the file list inside a torrent.
    // Without it Sonarr falls back to directory-scan mode and reports
    // "No files found are eligible for import in /path/to/file.mkv".
    app.get('/api/v2/torrents/files', (req, res) => {
        const d = downloads.get(req.query.hash);
        if (!d) return res.status(404).json({});
        res.json([{
            name: d.name,
            size: d.size,
            progress: d.progress,
            priority: 1,
            is_seed: d.state === 'uploading',
            piece_range: [0, 0],
            availability: d.state === 'uploading' ? 1 : -1,
        }]);
    });

    app.get('/api/v2/torrents/categories', (req, res) => res.json({
        webshare: { name: 'webshare', savePath: SAVE_PATH + '/' },
    }));

    // ── add download — accepts both url list AND .torrent file upload ─────
    app.post('/api/v2/torrents/add', upload.fields([{ name: 'torrents' }]), (req, res) => {
        res.send('Ok.');

        const body    = req.body || {};
        const category = body.category || '';

        // Case 1: Sonarr sends a .torrent file (multipart upload)
        const files = req.files && req.files['torrents'];
        if (files && files.length) {
            for (const f of files) {
                const webseedUrl = extractWebseed(f.buffer);
                const hash = extractInfoHash(f.buffer)
                    || crypto.createHash('sha1').update(f.buffer).digest('hex');

                if (!webseedUrl) {
                    // Real multi-file torrent — we can't download it.
                    // Record as 'error' so Sonarr stops re-adding this release.
                    if (!downloads.has(hash)) {
                        const name = f.originalname.replace(/\.torrent$/i, '') || hash;
                        downloads.set(hash, { hash, name, state: 'error', progress: 0, size: 0, category });
                        saveState();
                        console.warn(`[qbt] no url-list, recording as error: ${name}`);
                    }
                    continue;
                }

                // If we already have this webseed URL under any hash (e.g. old sha1(url) hash),
                // re-map it to the correct info hash so Sonarr can track it.
                const existingByUrl = [...downloads.values()]
                    .find(e => e.webseedUrl === webseedUrl);
                if (existingByUrl) {
                    if (existingByUrl.hash !== hash) {
                        downloads.delete(existingByUrl.hash);
                        existingByUrl.hash = hash;
                        downloads.set(hash, existingByUrl);
                        saveState();
                        console.log(`[qbt] re-hashed existing entry: ${existingByUrl.name}`);
                    }
                    continue;
                }

                if (downloads.has(hash)) continue;
                const name = f.originalname.replace(/\.torrent$/i, '') || hash;
                const entry = { hash, name, state: 'downloading', progress: 0, size: 0, category };
                downloads.set(hash, entry);
                console.log(`[qbt] queued via .torrent: ${name}`);
                enqueue(entry, webseedUrl);
            }
            return;
        }

        // Case 2: url list (our old path, kept as fallback)
        const urls = (body.urls || '').trim().split(/\s+/).filter(Boolean);
        for (const url of urls) {
            const m = url.match(/\/(?:download|stream)\/([^/?&#]+)/);
            const ident = m ? m[1] : null;
            const hash = crypto.createHash('sha1').update(url).digest('hex');
            if (downloads.has(hash)) continue;
            const entry = { hash, name: (ident || hash), state: 'downloading', progress: 0, size: 0, category };
            downloads.set(hash, entry);
            console.log(`[qbt] queued via url: ${url}`);
            enqueue(entry, url);
        }
    });

    // ── cleanup: delete staging files that have been imported or are stale ───
    // Fast path: Sonarr hardlinks → nlink > 1 → delete immediately.
    // Fallback: Sonarr copies instead of hardlinks (nlink stays 1) → delete
    // any completed file whose mtime is older than 2 hours. Never touch files
    // that are actively downloading or queued.
    function cleanupStaging() {
        let staged;
        try { staged = fs.readdirSync(SAVE_PATH); } catch { return; }
        const now = Date.now();
        const TWO_HOURS = 5 * 60 * 1000;

        const activeFiles = new Set(
            [...downloads.values()]
                .filter(e => e.state === 'downloading' || e.state === 'queuedDL')
                .map(e => e.name)
        );

        for (const fname of staged) {
            if (fname.startsWith('.')) continue;
            if (activeFiles.has(fname)) continue;
            const fpath = path.join(SAVE_PATH, fname);
            try {
                const st = fs.statSync(fpath);
                if (!st.isFile()) continue;
                if (st.nlink > 1) {
                    fs.unlinkSync(fpath);
                    console.log(`[cleanup] deleted after hardlink: ${fname}`);
                } else if (now - st.mtimeMs > TWO_HOURS) {
                    fs.unlinkSync(fpath);
                    console.log(`[cleanup] deleted stale staging file (>2h): ${fname}`);
                }
            } catch { }
        }
    }

    // Load persisted state on startup, then run cleanup
    loadState();
    cleanupStaging();
    setInterval(cleanupStaging, 15 * 60 * 1000);

    // ── control ───────────────────────────────────────────────────────────
    app.post('/api/v2/torrents/delete', (req, res) => {
        const hashes = (req.body.hashes || '').split('|');
        const deleteFiles = req.body.deleteFiles === 'true';
        for (const h of hashes) {
            const entry = downloads.get(h);
            if (entry && deleteFiles) {
                const fpath = path.join(SAVE_PATH, entry.name);
                try { fs.unlinkSync(fpath); console.log(`[qbt] deleted file: ${entry.name}`); } catch { }
            }
            downloads.delete(h);
        }
        saveState();
        res.send('Ok.');
    });
    app.post('/api/v2/torrents/pause',          (req, res) => res.send('Ok.'));
    app.post('/api/v2/torrents/resume',         (req, res) => res.send('Ok.'));
    app.post('/api/v2/torrents/setCategory',    (req, res) => res.send('Ok.'));
    app.post('/api/v2/torrents/setLocation',    (req, res) => res.send('Ok.'));
    app.post('/api/v2/torrents/rename',         (req, res) => res.send('Ok.'));
    app.post('/api/v2/torrents/createCategory', (req, res) => res.send('Ok.'));
    app.post('/api/v2/torrents/editCategory',   (req, res) => res.send('Ok.'));
    app.post('/api/v2/torrents/removeCategories', (req, res) => res.send('Ok.'));
}

module.exports = { register };