import "dotenv/config";
import express from "express";
import path from "path";
import { Readable } from "node:stream";
import {
    fetchCommits,
    fetchManifest,
    fetchRepo,
    fetchReleases,
    normalizeRepoInput,
    parseRepoEntry,
    readRepos
} from "./lib/pluginService.js";
import {
    buildLicensePayload,
    createLicense,
    findLicenseByKey,
    getLicenseById,
    listLicensesByUser,
    touchLicenseHostname
} from "./lib/licenseService.js";
import {
    countRepos,
    createRepo as createRepoRecord,
    deleteRepo as deleteRepoRecord,
    findRepoByOwnerRepo,
    getRepoById,
    listRepos,
    updateRepo as updateRepoRecord
} from "./lib/repoService.js";
import { HOST, PATHS, PORT } from "./lib/config.js";
import { ensureSchema } from "./lib/schema.js";
import { authenticateUser, registerUser, adminCreateUser, listUsers, getUserById } from "./lib/userService.js";
import { requireAuth, requireAdmin } from "./middleware/auth.js";
import { getDownloadSourceForLicense, resolveRepoDownload, buildDownloadUrl } from "./lib/downloadService.js";

const app = express();
app.use(express.json());

try {
    await ensureSchema();
    await seedLegacyRepos();
} catch (error) {
    console.error("Kon database schema niet initialiseren:", error);
    process.exit(1);
}

function buildRepoUrl(repoEntry) {
    if (!repoEntry) return null;
    if (repoEntry.provider === "gitea") {
        const base = (repoEntry.baseUrl || "").replace(/\/$/, "");
        return base && repoEntry.repo ? `${base}/${repoEntry.repo}` : null;
    }
    return `https://github.com/${repoEntry.repo}`;
}

async function resolveRepoMetaFromRequest(body = {}) {
    const owner = typeof body.owner === "string" ? body.owner.trim() : "";
    const repository = typeof body.repository === "string" ? body.repository.trim() : "";
    if (!owner || !repository) {
        return null;
    }

    const requestedProvider = (body.provider || body.repoProvider || "").toLowerCase() || null;
    const requestedBaseUrl = body.baseUrl || body.repoBaseUrl || null;
    const ownerRepo = `${owner}/${repository}`;

    const existing = await findRepoByOwnerRepo(ownerRepo, requestedProvider || undefined);
    const provider = existing?.provider || requestedProvider || "github";
    const baseUrl =
        existing?.baseUrl || requestedBaseUrl || (provider === "github" ? "https://github.com" : null);

    const repoEntry = normalizeRepoInput(
        { repo: ownerRepo, provider, baseUrl },
        { repo: ownerRepo, provider, baseUrl }
    );

    if (!repoEntry) {
        return null;
    }

    try {
        const info = await fetchRepo(repoEntry);
        const manifest = await fetchManifest(repoEntry, info.defaultBranch).catch(() => null);
        const releases = await fetchReleases(repoEntry).catch(() => []);
        const latestRelease = releases[0];
        const version = manifest?.version || latestRelease?.tag || latestRelease?.name || info.defaultBranch || null;
        const pluginName = manifest?.plugin_name || existing?.label || info.name || repository;

        return {
            repoId: existing?.id || null,
            repoEntry,
            pluginName,
            version
        };
    } catch (error) {
        return null;
    }
}

async function seedLegacyRepos() {
    try {
        const repoCount = await countRepos();
        if (repoCount > 0) {
            return;
        }
        const legacy = await readRepos(PATHS.reposFile);
        if (!Array.isArray(legacy) || legacy.length === 0) {
            return;
        }
        for (const entry of legacy) {
            try {
                await createRepoRecord(entry);
            } catch (error) {
                if (error?.meta !== "DUPLICATE") {
                    console.warn("Kon legacy repo niet importeren:", error.message);
                }
            }
        }
    } catch (error) {
        console.warn("Legacy repos importeren mislukt:", error.message);
    }
}

app.post("/api/auth/register", async (req, res) => {
    try {
        const { username, name, email, password } = req.body || {};
        if (!username || !name || !email || !password) {
            return res.status(400).json({ error: "Vul gebruikersnaam, naam, e-mail en wachtwoord in." });
        }
        if (password.length < 8) {
            return res.status(400).json({ error: "Wachtwoord moet minimaal 8 karakters zijn." });
        }
        const { user, token } = await registerUser({
            username: String(username).trim(),
            name: String(name).trim(),
            email: String(email).trim().toLowerCase(),
            password: String(password)
        });
        res.status(201).json({ token, user });
    } catch (error) {
        if (error?.code === "ER_DUP_ENTRY") {
            const field = error.meta === "EMAIL" ? "e-mailadres" : "gebruikersnaam";
            return res.status(409).json({ error: `Dit ${field} is al in gebruik.` });
        }
        res.status(500).json({ error: "Registratie mislukt." });
    }
});

app.post("/api/auth/login", async (req, res) => {
    try {
        const { identifier, password } = req.body || {};
        if (!identifier || !password) {
            return res.status(400).json({ error: "Vul gebruikersnaam/e-mail en wachtwoord in." });
        }
        const { user, token } = await authenticateUser(String(identifier).trim(), String(password));
        res.json({ token, user });
    } catch (error) {
        const message = error?.meta === "INVALID_CREDENTIALS" ? "Onjuiste inloggegevens." : "Login mislukt.";
        res.status(401).json({ error: message });
    }
});

app.get("/api/auth/me", requireAuth, (req, res) => {
    res.json({ user: req.user });
});

app.get("/api/admin/users", requireAuth, requireAdmin, async (_req, res) => {
    try {
        const users = await listUsers();
        res.json({ count: users.length, items: users });
    } catch (error) {
        res.status(500).json({ error: "Kon gebruikers niet laden." });
    }
});

app.post("/api/admin/users", requireAuth, requireAdmin, async (req, res) => {
    try {
        const { username, name, email, password, isAdmin } = req.body || {};
        if (!username || !name || !email || !password) {
            return res.status(400).json({ error: "Alle velden zijn verplicht." });
        }
        if (String(password).length < 8) {
            return res.status(400).json({ error: "Wachtwoord moet minimaal 8 karakters zijn." });
        }
        const user = await adminCreateUser({
            username: String(username).trim(),
            name: String(name).trim(),
            email: String(email).trim().toLowerCase(),
            password: String(password),
            isAdmin: Boolean(isAdmin)
        });
        res.status(201).json({ user });
    } catch (error) {
        if (error?.code === "ER_DUP_ENTRY") {
            const field = error.meta === "EMAIL" ? "e-mailadres" : "gebruikersnaam";
            return res.status(409).json({ error: `Dit ${field} is al in gebruik.` });
        }
        res.status(500).json({ error: "Gebruiker aanmaken mislukt." });
    }
});

function resolveOwnerRepoFromBody(body = {}) {
    if (body.ownerRepo) {
        return String(body.ownerRepo).trim();
    }
    const owner = typeof body.owner === "string" ? body.owner.trim() : "";
    const repo = typeof body.repo === "string" ? body.repo.trim() : "";
    if (owner && repo) {
        return `${owner}/${repo}`;
    }
    return "";
}

app.get("/api/repos", requireAuth, requireAdmin, async (_req, res) => {
    try {
        const repos = await listRepos();
        res.json({ count: repos.length, items: repos });
    } catch (error) {
        res.status(500).json({ error: "Kon repos niet laden." });
    }
});

app.post("/api/repos", requireAuth, requireAdmin, async (req, res) => {
    try {
        const ownerRepo = resolveOwnerRepoFromBody(req.body);
        if (!ownerRepo) {
            return res.status(400).json({ error: "Geef een owner en repo op." });
        }
        const provider = (req.body?.provider || "github").toLowerCase();
        const baseUrl = req.body?.baseUrl || null;
        const label = req.body?.label || null;
        const repo = await createRepoRecord({
            provider,
            ownerRepo,
            baseUrl,
            label
        });
        res.status(201).json({ repo });
    } catch (error) {
        if (error?.meta === "DUPLICATE") {
            return res.status(409).json({ error: error.message });
        }
        res.status(500).json({ error: "Kon repo niet opslaan." });
    }
});

app.patch("/api/repos/:id", requireAuth, requireAdmin, async (req, res) => {
    try {
        const repoId = Number(req.params.id);
        if (Number.isNaN(repoId)) {
            return res.status(400).json({ error: "Ongeldige repo id." });
        }
        const ownerRepo = resolveOwnerRepoFromBody(req.body);
        const payload = {
            provider: req.body?.provider,
            ownerRepo: ownerRepo || undefined,
            baseUrl: req.body?.baseUrl,
            label: req.body?.label
        };
        const repo = await updateRepoRecord(repoId, payload);
        res.json({ repo });
    } catch (error) {
        if (error?.meta === "NOT_FOUND") {
            return res.status(404).json({ error: error.message });
        }
        if (error?.meta === "DUPLICATE") {
            return res.status(409).json({ error: error.message });
        }
        res.status(500).json({ error: "Kon repo niet bijwerken." });
    }
});

app.delete("/api/repos/:id", requireAuth, requireAdmin, async (req, res) => {
    try {
        const repoId = Number(req.params.id);
        if (Number.isNaN(repoId)) {
            return res.status(400).json({ error: "Ongeldige repo id." });
        }
        await deleteRepoRecord(repoId);
        res.status(204).end();
    } catch (error) {
        if (error?.meta === "NOT_FOUND") {
            return res.status(404).json({ error: error.message });
        }
        if (error?.meta === "IN_USE") {
            return res.status(409).json({ error: error.message });
        }
        res.status(500).json({ error: "Kon repo niet verwijderen." });
    }
});

app.get("/api/plugins", async (_req, res) => {
    try {
        const repos = await listRepos();
        const results = await Promise.all(
            repos.map(async (repo) => {
                const entry = {
                    provider: repo.provider,
                    repo: repo.ownerRepo,
                    baseUrl: repo.baseUrl
                };
                try {
                    const info = await fetchRepo(entry);
                    const manifest = await fetchManifest(entry, info.defaultBranch || info.default_branch);
                    return {
                        ...info,
                        manifest,
                        provider: repo.provider,
                        baseUrl: repo.baseUrl,
                        repoId: repo.id,
                        label: repo.label,
                        ownerRepo: repo.ownerRepo
                    };
                } catch {
                    const parsed = parseRepoEntry(entry);
                    return {
                        fullName: parsed.ownerRepo,
                        name: parsed.ownerRepo.split("/")[1] || parsed.ownerRepo,
                        description: "Kon gegevens niet ophalen.",
                        repoUrl: buildRepoUrl({ provider: repo.provider, baseUrl: repo.baseUrl, repo: repo.ownerRepo }),
                        stars: 0,
                        forks: 0,
                        issues: 0,
                        updatedAt: null,
                        topics: [],
                        manifest: null,
                        provider: repo.provider,
                        ownerRepo: repo.ownerRepo,
                        baseUrl: repo.baseUrl,
                        repoId: repo.id,
                        label: repo.label,
                        isPrivate: false
                    };
                }
            })
        );

        res.json({
            count: results.length,
            updatedAt: new Date().toISOString(),
            items: results
        });
    } catch (error) {
        res.status(500).json({ error: "Kon plugins niet laden." });
    }
});

function buildPluginDownloadEndpoint(ownerRepo, { provider, baseUrl, version } = {}) {
    const [owner, repo] = ownerRepo.split("/");
    if (!owner || !repo) {
        return null;
    }
    const params = new URLSearchParams();
    if (provider) {
        params.set("provider", provider);
    }
    if (baseUrl) {
        params.set("baseUrl", baseUrl);
    }
    if (version) {
        params.set("version", version);
    }
    const search = params.toString();
    return `/api/plugins/${owner}/${repo}/download${search ? `?${search}` : ""}`;
}

app.get("/api/plugins/:owner/:repo", async (req, res) => {
    const ownerRepo = `${req.params.owner}/${req.params.repo}`;
    try {
        const repoIdQuery = Number(req.query.repoId);
        let repoRecord = null;
        if (!Number.isNaN(repoIdQuery)) {
            repoRecord = await getRepoById(repoIdQuery);
        }
        if (!repoRecord) {
            repoRecord = await findRepoByOwnerRepo(ownerRepo);
        }

        let provider = (req.query.provider || repoRecord?.provider || "github").toLowerCase();
        if (repoRecord?.provider) {
            provider = repoRecord.provider;
        }
        const baseUrlFallback = provider === "github" ? "https://github.com" : "";
        let baseUrlQuery = req.query.baseUrl || repoRecord?.baseUrl || baseUrlFallback;
        if (repoRecord?.baseUrl) {
            baseUrlQuery = repoRecord.baseUrl;
        }
        const entry =
            repoRecord && repoRecord.ownerRepo
                ? {
                      provider: repoRecord.provider,
                      repo: repoRecord.ownerRepo,
                      baseUrl: repoRecord.baseUrl || baseUrlQuery || undefined
                  }
                : provider === "github"
                    ? ownerRepo
                    : { provider, repo: ownerRepo, baseUrl: baseUrlQuery };
        const normalizedEntry =
            normalizeRepoInput(entry, { repo: ownerRepo, provider, baseUrl: baseUrlQuery }) ||
            null;

        if (!normalizedEntry) {
            return res.status(400).json({ error: "Ongeldige repository." });
        }

        let info;
        let manifest = null;
        let releases = [];
        let commits = [];

        try {
            info = await fetchRepo(normalizedEntry);
            [manifest, releases, commits] = await Promise.all([
                fetchManifest(normalizedEntry, info.defaultBranch).catch(() => null),
                fetchReleases(normalizedEntry).catch(() => []),
                fetchCommits(normalizedEntry).catch(() => [])
            ]);
        } catch (fetchError) {
            console.warn("Kon plugin info niet ophalen:", fetchError.message);
            const parsed = parseRepoEntry(normalizedEntry);
            const fallbackRepo = {
                provider: repoRecord?.provider || parsed.provider,
                baseUrl: repoRecord?.baseUrl || parsed.baseUrl,
                repo: repoRecord?.ownerRepo || parsed.ownerRepo
            };
            const repoUrl = buildRepoUrl(fallbackRepo);
            const name = repoRecord?.label || parsed.ownerRepo.split("/")[1] || parsed.ownerRepo;
            return res.json({
                fullName: fallbackRepo.repo,
                name,
                description: repoRecord?.label ? `Plugin: ${repoRecord.label}` : "Kon gegevens niet ophalen.",
                repoUrl,
                provider: fallbackRepo.provider,
                ownerRepo: fallbackRepo.repo,
                baseUrl: fallbackRepo.baseUrl,
                repoId: repoRecord?.id || null,
                label: repoRecord?.label || null,
                manifest: null,
                releases: [],
                commits: [],
                download: null,
                version: null,
                versionSource: null,
                isPrivate: false
            });
        }

        const isPrivate = Boolean(info?.isPrivate);
        const allowDownloads = normalizedEntry && !isPrivate;

        const effectiveBaseUrl =
            normalizedEntry?.baseUrl ||
            baseUrlQuery ||
            info.baseUrl ||
            (provider === "github" ? "https://github.com" : "");

        const releasesWithDownload =
            allowDownloads && releases.length > 0
                ? releases.map((release) => {
                      const tagOrName = release.tag || release.name;
                      if (!tagOrName) {
                          return release;
                      }
                      const endpoint = buildPluginDownloadEndpoint(ownerRepo, {
                          provider,
                          baseUrl: effectiveBaseUrl,
                          version: tagOrName
                      });
                      return {
                          ...release,
                          downloadUrl: endpoint,
                          sourceDownloadUrl: buildDownloadUrl(normalizedEntry, tagOrName, "release")
                      };
                  })
                : releases;

        let downloadMeta = null;
        if (allowDownloads) {
            const latestRelease = releasesWithDownload[0];
            const sourceType = latestRelease ? "release" : "branch";
            const version = latestRelease?.tag || latestRelease?.name || info.defaultBranch || "main";
            if (version) {
                const endpoint = buildPluginDownloadEndpoint(ownerRepo, {
                    provider,
                    baseUrl: effectiveBaseUrl,
                    version
                });
                downloadMeta = {
                    url: endpoint,
                    sourceUrl: buildDownloadUrl(normalizedEntry, version, sourceType),
                    version,
                    sourceType
                };
            }
        }

        const versionFromManifest = manifest?.version;
        const versionFromDownload = downloadMeta?.version;
        const versionFromReleases = releasesWithDownload?.[0]?.tag || releasesWithDownload?.[0]?.name;
        const resolvedVersion = versionFromManifest || versionFromDownload || versionFromReleases || null;
        const versionSource = versionFromManifest ? "manifest" : versionFromDownload ? "release" : versionFromReleases ? "releases" : null;

        res.json({
            ...info,
            repoId: repoRecord?.id || null,
            label: repoRecord?.label || null,
            version: resolvedVersion,
            versionSource,
            manifest,
            releases: releasesWithDownload,
            download: downloadMeta,
            isPrivate,
            commits
        });
    } catch (error) {
        res.status(500).json({ error: "Kon plugin details niet laden." });
    }
});

app.get("/api/plugins/:owner/:repo/download", async (req, res) => {
    const ownerRepo = `${req.params.owner}/${req.params.repo}`;
    try {
        const provider = (req.query.provider || "github").toLowerCase();
        const baseUrl = req.query.baseUrl || undefined;
        const version = req.query.version || "latest";

        if (provider === "gitea" && !baseUrl) {
            return res.status(400).json({ error: "Gitea downloads vereisen een baseUrl." });
        }

        const repoEntry = normalizeRepoInput(
            { repo: ownerRepo, provider, baseUrl },
            { repo: ownerRepo, provider, baseUrl }
        );

        if (!repoEntry) {
            return res.status(400).json({ error: "Ongeldige repository." });
        }

        const source = await resolveRepoDownload(repoEntry, version);
        const remoteResponse = await fetch(source.url);
        if (!remoteResponse.ok || !remoteResponse.body) {
            return res.status(502).json({ error: "Kon plugin versie niet downloaden." });
        }

        res.setHeader("Content-Type", remoteResponse.headers.get("content-type") || "application/zip");
        const length = remoteResponse.headers.get("content-length");
        if (length) {
            res.setHeader("Content-Length", length);
        }
        res.setHeader("Content-Disposition", `attachment; filename="${source.filename}"`);
        res.setHeader("X-Plugin-Version", source.version);

        const stream = Readable.fromWeb(remoteResponse.body);
        stream.on("error", (err) => {
            console.error("Plugin download stream error:", err);
            res.destroy(err);
        });
        stream.pipe(res);
    } catch (error) {
        if (error?.meta === "PRIVATE_REPO") {
            return res.status(403).json({ error: "Downloads voor private plugins zijn uitgeschakeld." });
        }
        console.error("Plugin download endpoint error:", error);
        if (!res.headersSent) {
            res.status(500).json({ error: "Download mislukt." });
        } else {
            res.end();
        }
    }
});

app.get("/api/licenses", requireAuth, async (req, res) => {
    try {
        let targetUserId = req.user.id;
        if (req.user.isAdmin && req.query.userId) {
            const parsed = Number(req.query.userId);
            if (Number.isNaN(parsed)) {
                return res.status(400).json({ error: "Ongeldige userId." });
            }
            const targetUser = await getUserById(parsed);
            if (!targetUser) {
                return res.status(404).json({ error: "Gebruiker niet gevonden." });
            }
            targetUserId = parsed;
        }
        const payload = await listLicensesByUser(targetUserId);
        res.json({
            count: payload.length,
            updatedAt: new Date().toISOString(),
            items: payload
        });
    } catch (error) {
        res.status(500).json({ error: "Kon licenties niet laden." });
    }
});

app.post("/api/licenses", requireAuth, async (req, res) => {
    try {
        const body = req.body || {};
        const repoId = body.repoId ? Number(body.repoId) : null;
        if (body.repoId && Number.isNaN(repoId)) {
            return res.status(400).json({ error: "Ongeldig repo id." });
        }
        let repoRecord = null;
        if (repoId) {
            repoRecord = await getRepoById(repoId);
            if (!repoRecord) {
                return res.status(404).json({ error: "Plugin niet gevonden." });
            }
        }
        const repoInput =
            typeof body.repo === "object"
                ? body.repo
                : typeof body.plugin === "object"
                    ? body.plugin
                    : body.repo || body.ownerRepo || body.fullName || body.plugin;
        const repoFromRecord = repoRecord
            ? {
                  repo: repoRecord.ownerRepo,
                  provider: repoRecord.provider,
                  baseUrl: repoRecord.baseUrl
              }
            : null;
        const repoEntry =
            normalizeRepoInput(repoInput, {
                repo: body.ownerRepo || body.fullName || body.repo || repoFromRecord?.repo,
                provider: body.provider || repoFromRecord?.provider,
                baseUrl: body.baseUrl || repoFromRecord?.baseUrl
            }) || repoFromRecord;

        if (!repoEntry) {
            return res.status(400).json({ error: "Kies een plugin om de licentie aan te koppelen." });
        }

        try {
            await fetchRepo(repoEntry);
        } catch (error) {
            return res.status(400).json({ error: "Kon plugin gegevens niet ophalen." });
        }

        let ownerUserId = req.user.id;
        if (req.user.isAdmin && body.userId) {
            const parsed = Number(body.userId);
            if (Number.isNaN(parsed)) {
                return res.status(400).json({ error: "Ongeldige gebruiker." });
            }
            const target = await getUserById(parsed);
            if (!target) {
                return res.status(404).json({ error: "Gebruiker niet gevonden." });
            }
            ownerUserId = parsed;
        }

        const payload = await createLicense(ownerUserId, {
            label: body.label?.trim(),
            note: body.note?.trim(),
            repo: repoEntry,
            repoId: repoId || undefined
        });
        res.status(201).json(payload);
    } catch (error) {
        res.status(500).json({ error: "Kon licentie niet aanmaken." });
    }
});

app.post("/api/licenses/verify", async (req, res) => {
    try {
        const { key, hostname } = req.body || {};
        if (!key || !hostname) {
            return res.status(400).json({ valid: false, error: "Licentiecode en hostname zijn verplicht." });
        }
        const license = await findLicenseByKey(String(key).trim());
        if (!license) {
            const repoMeta = await resolveRepoMetaFromRequest(req.body);
            const fallbackPayload = repoMeta
                ? {
                      pluginVersion: repoMeta.version,
                      license: {
                          pluginName: repoMeta.pluginName,
                          pluginVersion: repoMeta.version,
                          repoFullName: repoMeta.repoEntry.repo,
                          repoUrl: buildRepoUrl(repoMeta.repoEntry),
                          repoId: repoMeta.repoId || null,
                          repo: repoMeta.repoEntry
                      }
                  }
                : {};
            return res.status(404).json({ valid: false, error: "Licentie niet gevonden.", ...fallbackPayload });
        }

        const rawVersion = req.body?.currentVersion ?? req.body?.pluginVersion ?? null;
        const pluginVersion =
            rawVersion && String(rawVersion).trim().length > 0 ? String(rawVersion).trim().slice(0, 64) : null;

        const result = await touchLicenseHostname(license, hostname, { pluginVersion });
        if (!result.ok) {
            const status = result.conflict ? 403 : 400;
            const payload = await buildLicensePayload(license);
            return res
                .status(status)
                .json({ valid: false, error: result.error, boundHostname: license.primary_hostname, license: payload });
        }

        const freshLicense = await getLicenseById(license.id);
        const payload = await buildLicensePayload(freshLicense);
        res.json({
            valid: true,
            hostname: payload.primaryHostname,
            boundNow: !!result.boundNow,
            license: payload
        });
    } catch (error) {
        res.status(500).json({ valid: false, error: "Validatie mislukt." });
    }
});

async function handleLicenseDownload(res, { key, hostname, version = "latest" }) {
    try {
        if (!key || !hostname) {
            return res.status(400).json({ error: "Licentiecode en hostname zijn verplicht." });
        }
        const license = await findLicenseByKey(String(key).trim());
        if (!license) {
            return res.status(404).json({ error: "Licentie niet gevonden." });
        }
        const result = await touchLicenseHostname(license, hostname);
        if (!result.ok) {
            const status = result.conflict ? 403 : 400;
            return res.status(status).json({ error: result.error, boundHostname: license.primary_hostname });
        }
        const source = await getDownloadSourceForLicense(license, version);
        const remoteResponse = await fetch(source.url);
        if (!remoteResponse.ok || !remoteResponse.body) {
            return res.status(502).json({ error: "Kon plugin versie niet ophalen." });
        }

        res.setHeader("Content-Type", remoteResponse.headers.get("content-type") || "application/zip");
        const length = remoteResponse.headers.get("content-length");
        if (length) {
            res.setHeader("Content-Length", length);
        }
        res.setHeader("Content-Disposition", `attachment; filename=\"${source.filename}\"`);
        res.setHeader("X-Plugin-Version", source.version);

        const stream = Readable.fromWeb(remoteResponse.body);
        stream.on("error", (err) => {
            console.error("Download stream error", err);
            res.destroy(err);
        });
        stream.pipe(res);
    } catch (error) {
        if (error?.meta === "PRIVATE_REPO") {
            if (!res.headersSent) {
                return res.status(403).json({ error: "Downloads voor private plugins zijn uitgeschakeld." });
            }
            return res.end();
        }
        console.error("Download endpoint error:", error);
        if (!res.headersSent) {
            res.status(500).json({ error: "Download mislukt." });
        } else {
            res.end();
        }
    }
}

app.post("/api/licenses/download", async (req, res) => {
    await handleLicenseDownload(res, {
        key: req.body?.key,
        hostname: req.body?.hostname,
        version: req.body?.version || "latest"
    });
});

app.get("/api/licenses/download", async (req, res) => {
    await handleLicenseDownload(res, {
        key: req.query.key,
        hostname: req.query.hostname,
        version: req.query.version || "latest"
    });
});

app.use(express.static(PATHS.distDir));
app.get("*", (_req, res) => {
    res.sendFile(path.join(PATHS.distDir, "index.html"));
});

app.listen(PORT, HOST, () => {
    console.log(`Server draait op http://${HOST}:${PORT}`);
});