Skip to content

armgit / Filee

Public Imported from GitHub
0

Free, open-source file converter. Convert 263 formats offline by drag & drop — images, PDF, Word, Excel, PowerPoint, HWP/HWPX, video, audio, e-books and archives. No upload, no Office needed.

35.6 KB
Raw Blame
// E-books without external programs (EPUB, MOBI, FB2, HTMLZ, TXTZ, comics) and with the optional calibre package.
// Inputs are generated by EbookBuilders; outputs are parsed back (EPUB structure, PDF page counts, text content).

using System.IO.Compression;
using System.Text;
using System.Xml.Linq;
using Filee.Core.Conversion;
using Filee.Core.Presets;
using Filee.Engines.Ebooks;
using ImageMagick;
using PdfSharp.Pdf.IO;

namespace Filee.Engines.Tests;

public class EbookTests(EngineFixture fx) : IClassFixture<EngineFixture>
{
    private static readonly string[] OptionalEngines = ["pandoc", "libreoffice", "calibre"];

    private RoutePlanner BuiltInPlanner(params string[] assumeInstalled) =>
        new ConverterCatalog(fx.Converters.Where(c => !OptionalEngines.Contains(c.Id))) { Priority = fx.Catalog.Priority }
            .CreatePlanner(assumeInstalled);

    private async Task<string> ConvertAsync(string input, string target, Preset? preset = null)
    {
        preset ??= new Preset();
        preset.TargetFormat = target;
        var job = await fx.ConvertAsync([input], preset);
        Assert.True(job.State == JobState.Completed, string.Join("; ", job.Files.Select(f => $"{f.ErrorKey} {f.ErrorDetail}")));
        return job.Outputs.Single();
    }

    private async Task<string> FailureAsync(string input, string target)
    {
        var job = await fx.ConvertAsync([input], new Preset { TargetFormat = target });
        Assert.Equal(JobState.Failed, job.State);
        return job.Files.Single().ErrorDetail ?? "";
    }

    private bool HasRhwp => fx.Catalog.StatusOf(fx.Converters.Single(c => c.Id == "rhwp")).IsAvailable;

    private bool HasCalibre => fx.Catalog.StatusOf(fx.Converters.Single(c => c.Id == "calibre")).IsAvailable;

    private static int PdfPages(string pdf)
    {
        using var document = PdfReader.Open(pdf, PdfDocumentOpenMode.Import);
        return document.PageCount;
    }

    /// <summary>The text of an EPUB read back with the built-in reader.</summary>
    private string EpubText(string epub) =>
        Hwp.Hwpx.PlainTextWriter.Write(EpubReader.ReadBook(epub, fx.NewFolder(), TestContext.Current.CancellationToken).Document);

    // ───────────────────────── Routes ─────────────────────────

    [Fact]
    public void E_book_routes_use_the_built_in_engine()
    {
        var planner = BuiltInPlanner("rhwp");

        // E-book readers are also registered with the HWPX writer, which comes first in the default engine order.
        Assert.Equal(["hwpx-writer", "rhwp"], planner.Plan("epub", "pdf")!.Steps.Select(s => s.Converter.Id));
        Assert.Equal(["hwpx-writer", "rhwp", "pdfium"], planner.Plan("mobi", "png")!.Steps.Select(s => s.Converter.Id));
        foreach (var (from, to) in new[] { ("mobi", "epub"), ("azw3", "epub"), ("fb2", "epub"), ("epub", "fb2"), ("md", "epub"), ("docx", "epub"), ("epub", "txt"), ("cbr", "pdf"), ("pdf", "cbz"), ("azw4", "pdf"), ("htmlz", "txtz") })
            Assert.Equal("ebook", Assert.Single(planner.Plan(from, to)!.Steps).Converter.Id);
        Assert.Null(planner.Plan("epub", "mobi")); // needs calibre
    }

    [Fact]
    public void Calibre_adds_kindle_output_and_rare_formats_but_never_wins_over_built_in_routes()
    {
        var planner = fx.Catalog.CreatePlanner(["calibre"]);

        Assert.Equal("calibre", Assert.Single(planner.Plan("epub", "azw3")!.Steps).Converter.Id);
        Assert.Equal(["ebook", "calibre"], planner.Plan("fb2", "mobi")!.Steps.Select(s => s.Converter.Id));
        Assert.Equal(["calibre", "ebook"], planner.Plan("lit", "txt")!.Steps.Select(s => s.Converter.Id));
        Assert.Equal("ebook", Assert.Single(planner.Plan("mobi", "epub")!.Steps).Converter.Id);
        Assert.Equal("ebook", Assert.Single(planner.Plan("epub", "fb2")!.Steps).Converter.Id);
    }

    /// <summary>The engine order with calibre moved to <paramref name="index"/>.</summary>
    private List<string> CalibreAt(int index)
    {
        var order = fx.Catalog.Priority.Where(id => id != "calibre").ToList();
        order.Insert(index, "calibre");
        return order;
    }

    [Fact]
    public void Calibre_makes_e_book_pdfs_only_when_ranked_above_the_hwpx_writer()
    {
        string[] installed = ["calibre", "rhwp", "pandoc", "libreoffice"];
        var writer = fx.Catalog.Priority.ToList().IndexOf("hwpx-writer");
        RoutePlanner Planner(IReadOnlyList<string> priority) =>
            new ConverterCatalog(fx.Converters) { Priority = priority }.CreatePlanner(installed);
        var byDefault = fx.Catalog.CreatePlanner(installed);
        var belowWriter = Planner(CalibreAt(writer + 1));
        var aboveWriter = Planner(CalibreAt(writer));
        var first = Planner(CalibreAt(0));

        // Books the built-in engines read: the default stays HWPX writer → rhwp (#127 moved calibre to the top).
        foreach (var from in CalibreConverter.PdfInputs.Except(CalibreConverter.Inputs))
        {
            Assert.Equal(["hwpx-writer", "rhwp"], byDefault.Plan(from, "pdf")!.Steps.Select(s => s.Converter.Id));
            Assert.Equal(["hwpx-writer", "rhwp"], belowWriter.Plan(from, "pdf")!.Steps.Select(s => s.Converter.Id));
            Assert.Equal("calibre", Assert.Single(aboveWriter.Plan(from, "pdf")!.Steps).Converter.Id);
            Assert.Equal("calibre", Assert.Single(first.Plan(from, "pdf")!.Steps).Converter.Id);
        }
        Assert.Equal(["hwpx-writer", "rhwp", "pdfium"], byDefault.Plan("epub", "png")!.Steps.Select(s => s.Converter.Id));
        Assert.Equal(["calibre", "pdfium"], first.Plan("epub", "png")!.Steps.Select(s => s.Converter.Id));

        // Formats only calibre reads: one calibre run instead of calibre → EPUB → HWPX writer → rhwp.
        Assert.Equal("calibre", Assert.Single(byDefault.Plan("lit", "pdf")!.Steps).Converter.Id);
        // Other documents keep their engines.
        Assert.DoesNotContain("calibre", first.Plan("docx", "pdf")!.Steps.Select(s => s.Converter.Id));
    }

    // ───────────────────────── EPUB ─────────────────────────

    [Fact]
    public void Book_chapters_only_include_images_from_the_unpacked_book()
    {
        var folder = fx.NewFolder();
        var book = Path.Combine(folder, "book");
        var chapterFolder = Path.Combine(book, "Text");
        var imageFolder = Path.Combine(book, "Images");
        Directory.CreateDirectory(chapterFolder);
        Directory.CreateDirectory(imageFolder);
        var inside = Path.Combine(imageFolder, "inside.png");
        var outside = Path.Combine(folder, "private.png");
        var sibling = Path.Combine(folder, "book-evil", "sibling.png"); // shares the "book" prefix
        Directory.CreateDirectory(Path.GetDirectoryName(sibling)!);
        File.WriteAllBytes(inside, EbookBuilders.Png(4, 4, MagickColors.Teal));
        File.WriteAllBytes(outside, EbookBuilders.Png(4, 4, MagickColors.Red));
        File.WriteAllBytes(sibling, EbookBuilders.Png(4, 4, MagickColors.Red));
        var chapter = Path.Combine(chapterFolder, "chapter.xhtml");
        File.WriteAllText(chapter, $"""
            <html><body><p><img src="../Images/inside.png"><img src="../../private.png"><img src="../../book-evil/sibling.png"><img src="{new Uri(outside).AbsoluteUri}"></p></body></html>
            """);

        var document = ChapterReader.Read([chapter], Path.Combine(book, "~media"), TestContext.Current.CancellationToken);
        Assert.Equal(inside, Assert.Single(Hwp.Hwpx.HDocumentWalker.Images(document)).Path);
    }

    [Fact]
    public void Epub_reader_keeps_chapters_links_pictures_and_metadata()
    {
        var book = EpubReader.ReadBook(EbookBuilders.Epub(fx.NewFolder()), fx.NewFolder(), TestContext.Current.CancellationToken);

        Assert.Equal("별빛 이야기", book.Metadata.Title);
        Assert.Equal(["김작가"], book.Metadata.Authors);
        Assert.Equal("ko", book.Metadata.Language);
        Assert.EndsWith("cover.png", book.Metadata.CoverImage);
        var blocks = book.Document.Sections.Single().Blocks;
        var headings = blocks.OfType<Hwp.Hwpx.HParagraph>().Where(p => p.HeadingLevel == 1).ToList();
        Assert.Equal(["첫 번째 장", "두 번째 장", "세 번째 장"], headings.Select(h => Hwp.Hwpx.HDocumentWalker.Text(h.Inlines)));
        Assert.Equal([false, true, true], headings.Select(h => h.PageBreakBefore)); // every chapter on a new page
        var inlines = blocks.SelectMany(b => Hwp.Hwpx.HDocumentWalker.Inlines([b])).ToList();
        var link = inlines.OfType<Hwp.Hwpx.HLink>().Single();
        Assert.Contains(inlines.OfType<Hwp.Hwpx.HBookmark>(), b => "#" + b.Name == link.Target); // chapter 1 → note in "ch 3.xhtml"
        Assert.Single(inlines.OfType<Hwp.Hwpx.HImage>());
        Assert.Single(blocks.OfType<Hwp.Hwpx.HTable>());
        Assert.Contains(inlines.OfType<Hwp.Hwpx.HText>(), t => t.Text == "크게" && t.Format.Bold is true); // class rule from the linked CSS
        Assert.Contains(inlines.OfType<Hwp.Hwpx.HText>(), t => t.Text == "빈 div 다음 문단"); // <div/> did not swallow the page
    }

    [Fact]
    public async Task Epub_to_pdf_puts_every_chapter_on_its_own_page()
    {
        Assert.SkipUnless(HasRhwp, "rhwp not found (pwsh build/fetch-engines.ps1 -Only rhwp)");
        var pdf = await ConvertAsync(EbookBuilders.Epub(fx.NewFolder()), "pdf");

        Assert.True(PdfPages(pdf) >= 3);
    }

    [Fact]
    public async Task Epub_to_txt_html_and_markdown()
    {
        var epub = EbookBuilders.Epub(fx.NewFolder());

        var text = await File.ReadAllTextAsync(await ConvertAsync(epub, "txt"), TestContext.Current.CancellationToken);
        foreach (var expected in new[] { "첫 번째 장", "밤하늘에 별이 반짝였다.", "주석 내용입니다.", "● 목록 하나", "이름\t값" })
            Assert.Contains(expected, text);
        Assert.DoesNotContain("<", text);

        var html = await File.ReadAllTextAsync(await ConvertAsync(epub, "html"), TestContext.Current.CancellationToken);
        Assert.Contains("<h1 id=\"_h1\">첫 번째 장</h1>", html);
        Assert.Contains("src=\"data:image/png;base64,", html); // one self-contained file
        Assert.Contains("<b>별</b>", html);
        Assert.Contains("<title>별빛 이야기</title>", html);

        var md = await ConvertAsync(epub, "md");
        var markdown = await File.ReadAllTextAsync(md, TestContext.Current.CancellationToken);
        Assert.Contains("# 첫 번째 장", markdown);
        Assert.Contains("**별**", markdown);
        Assert.Contains("| 이름 | 값 |", markdown);
        var picture = System.Text.RegularExpressions.Regex.Match(markdown, @"!\[\]\(<([^>]+)>\)").Groups[1].Value;
        Assert.True(File.Exists(Path.Combine(Path.GetDirectoryName(md)!, Uri.UnescapeDataString(picture))));

        var textOnly = await fx.ConvertAsync([epub], new Preset { TargetFormat = "md", Document = { LeaveOutPictures = true } });
        var withoutPictures = await File.ReadAllTextAsync(textOnly.Outputs.Single(), TestContext.Current.CancellationToken);
        Assert.Contains("# 첫 번째 장", withoutPictures);
        Assert.DoesNotContain("![", withoutPictures);
    }

    [Theory]
    [InlineData(0x41u)]
    [InlineData(0x40u)]
    public async Task Markdown_dds_picture_keeps_its_colours_in_epub(uint flags)
    {
        var dir = fx.NewFolder();
        byte[] pixels = [.. Enumerable.Repeat<byte[]>([255, 0, 0, 255], 16).SelectMany(p => p)];
        File.WriteAllBytes(Path.Combine(dir, "red.dds"), ImageFormatTests.Dds(flags, 0xFF, 0xFF00, 0xFF0000, 0xFF000000, pixels));
        var md = Path.Combine(dir, "book.md");
        await File.WriteAllTextAsync(md, "![red](red.dds)", TestContext.Current.CancellationToken);

        var epub = await ConvertAsync(md, "epub");

        using var zip = ZipFile.OpenRead(epub);
        using var stream = Assert.Single(zip.Entries, e => e.FullName.StartsWith("OEBPS/images/", StringComparison.Ordinal)
            && e.FullName.EndsWith(".png", StringComparison.Ordinal)).Open();
        using var image = new MagickImage(stream);
        Assert.Equal(MagickFormat.Png, image.Format);
        Assert.Equal((4u, 4u), (image.Width, image.Height));
        Assert.Equal(pixels.Where((_, i) => i % 4 != 3).ToArray(), image.GetPixels().ToByteArray(PixelMapping.RGB));
    }

    [Fact]
    public async Task Markdown_to_epub_is_a_valid_package_that_reads_back()
    {
        var dir = fx.NewFolder();
        File.WriteAllBytes(Path.Combine(dir, "그림.png"), EbookBuilders.Png(120, 80, MagickColors.Gold));
        var md = Path.Combine(dir, "책.md");
        await File.WriteAllTextAsync(md, """
            ---
            title: 마크다운 책
            ---

            # 1장 시작

            첫 문단에 **굵게**와 [링크](https://example.com)가 있습니다.[^1]

            ![그림](그림.png)

            ## 1.1 절

            - 하나
            - 둘

            # 2장 끝

            | A | B |
            |---|---|
            | 1 | 2 |

            [^1]: 각주입니다.
            """, TestContext.Current.CancellationToken);

        var epub = await ConvertAsync(md, "epub");

        var package = EpubAssert.Valid(epub);
        Assert.Equal("마크다운 책", package.Title);
        Assert.Equal("ko", package.Language);
        Assert.Equal(2, package.Chapters); // split at the level-1 headings
        Assert.Equal(1, package.Images);
        Assert.Contains("1장 시작", package.Toc);
        Assert.Contains("1.1 절", package.Toc);
        var text = EpubText(epub);
        foreach (var expected in new[] { "1장 시작", "굵게", "하나", "2장 끝", "각주입니다." })
            Assert.Contains(expected, text);
    }

    [Fact]
    public async Task Text_html_and_docx_become_epub()
    {
        var dir = fx.NewFolder();
        var txt = Path.Combine(dir, "메모.txt");
        await File.WriteAllTextAsync(txt, "첫 문단의 첫 줄\n같은 문단\n\n둘째 문단", TestContext.Current.CancellationToken);
        var html = Path.Combine(dir, "page.html");
        await File.WriteAllTextAsync(html, "<html><head><title>웹 페이지</title></head><body><h1>제목</h1><p>본문</p></body></html>", TestContext.Current.CancellationToken);
        var docx = new DocxBuilder().Paragraph(DocxBuilder.P(DocxBuilder.R("워드 문서 본문"))).Save(Path.Combine(dir, "워드.docx"));

        EpubAssert.Valid(await ConvertAsync(txt, "epub"));
        Assert.Contains("둘째 문단", EpubText(await ConvertAsync(txt, "epub")));
        Assert.Equal("웹 페이지", EpubAssert.Valid(await ConvertAsync(html, "epub")).Title);
        Assert.Contains("워드 문서 본문", EpubText(await ConvertAsync(docx, "epub")));
    }

    [Fact]
    public async Task Drm_protected_epub_is_refused_with_a_clear_message()
    {
        var dir = fx.NewFolder();
        var epub = EbookBuilders.Epub(dir);
        using (var zip = ZipFile.Open(epub, ZipArchiveMode.Update))
            EbookBuilders.Entry(zip, "META-INF/encryption.xml", """
                <encryption xmlns="urn:oasis:names:tc:opendocument:xmlns:container" xmlns:enc="http://www.w3.org/2001/04/xmlenc#">
                  <enc:EncryptedData><enc:EncryptionMethod Algorithm="http://www.w3.org/2001/04/xmlenc#aes128-cbc"/>
                  <enc:CipherData><enc:CipherReference URI="OEBPS/Text/ch1.xhtml"/></enc:CipherData></enc:EncryptedData>
                </encryption>
                """);

        Assert.Contains("DRM", await FailureAsync(epub, "txt"));
    }

    // ───────────────────────── MOBI ─────────────────────────

    private const string MobiHtml = """
        <html><head><guide><reference type="toc" title="Contents" filepos=0000000000 /></guide></head><body>
        <h1>Chapter One</h1>
        <p>It was a <b>dark</b> and stormy night; the rain fell in torrents — except at occasional intervals.</p>
        <p>See <a filepos=FILEPOS>the note</a> below. Ünïcödé text and 한글 too.</p>
        <p><img recindex="00001" /></p>
        <mbp:pagebreak/>
        <h1>Chapter Two</h1>
        <p>The note is here.</p>
        </body></html>
        """;

    /// <summary>MOBI HTML with a filepos link pointing at "The note is here." (a byte offset in the text).</summary>
    private static string MobiSource()
    {
        var placeholder = MobiHtml.Replace("FILEPOS", "0000000000", StringComparison.Ordinal);
        var target = Encoding.UTF8.GetBytes(placeholder[..placeholder.IndexOf("<p>The note", StringComparison.Ordinal)]).Length;
        return MobiHtml.Replace("FILEPOS", target.ToString("0000000000", System.Globalization.CultureInfo.InvariantCulture), StringComparison.Ordinal);
    }

    [Theory]
    [InlineData(2)] // PalmDOC
    [InlineData(17480)] // HUFF/CDIC
    [InlineData(1)] // uncompressed
    public async Task Mobi_to_epub_keeps_text_pictures_links_and_metadata(int compression)
    {
        var dir = fx.NewFolder();
        var mobi = Path.Combine(dir, "book.mobi");
        var cover = EbookBuilders.Png(100, 150, MagickColors.DarkBlue);
        await File.WriteAllBytesAsync(mobi, EbookBuilders.Mobi(MobiSource(), [EbookBuilders.Png(64, 32, MagickColors.Orange), cover],
            new EbookBuilders.MobiOptions(Compression: compression, Cover: 1, Title: "Stormy Night", Author: "E. Bulwer-Lytton")), TestContext.Current.CancellationToken);

        var epub = await ConvertAsync(mobi, "epub");

        var package = EpubAssert.Valid(epub);
        Assert.Equal("Stormy Night", package.Title);
        Assert.Contains("E. Bulwer-Lytton", package.Authors);
        Assert.Equal(2, package.Images); // the picture and the cover
        Assert.True(package.HasCover);
        var book = EpubReader.ReadBook(epub, fx.NewFolder(), TestContext.Current.CancellationToken);
        var text = Hwp.Hwpx.PlainTextWriter.Write(book.Document);
        foreach (var expected in new[] { "Chapter One", "dark and stormy night", "Ünïcödé text and 한글 too", "Chapter Two", "The note is here." })
            Assert.Contains(expected, text);
        var inlines = book.Document.Sections.SelectMany(s => Hwp.Hwpx.HDocumentWalker.Inlines(s.Blocks)).ToList();
        var link = inlines.OfType<Hwp.Hwpx.HLink>().Single();
        Assert.Contains(inlines.OfType<Hwp.Hwpx.HBookmark>(), b => "#" + b.Name == link.Target); // filepos link survives
        Assert.True(inlines.OfType<Hwp.Hwpx.HText>().Single(t => t.Text == "dark").Format.Bold);
    }

    [Fact]
    public async Task Drm_protected_mobi_is_refused_with_a_clear_message()
    {
        var mobi = Path.Combine(fx.NewFolder(), "locked.azw");
        await File.WriteAllBytesAsync(mobi, EbookBuilders.Mobi(MobiSource(), [], new EbookBuilders.MobiOptions(Encryption: 2)), TestContext.Current.CancellationToken);

        Assert.Contains("DRM", await FailureAsync(mobi, "epub"));
    }

    [Fact]
    public async Task Palmdoc_text_books_are_read_as_text()
    {
        var text = "Plain PalmDOC text.\n\nSecond paragraph of the book."u8.ToArray();
        var record0 = new byte[16];
        record0[1] = 2; // PalmDOC compression
        System.Buffers.Binary.BinaryPrimitives.WriteUInt32BigEndian(record0.AsSpan(4), (uint)text.Length);
        record0[9] = 1; // one text record
        var prc = Path.Combine(fx.NewFolder(), "old.prc");
        await File.WriteAllBytesAsync(prc, EbookBuilders.PalmDb("Old Book", "TEXtREAd", [record0, EbookBuilders.PalmDocCompress(text)]), TestContext.Current.CancellationToken);

        var txt = await File.ReadAllTextAsync(await ConvertAsync(prc, "txt"), TestContext.Current.CancellationToken);

        Assert.Contains("Plain PalmDOC text.", txt);
        Assert.Contains("Second paragraph of the book.", txt);
    }

    [Fact]
    public async Task Print_replica_gives_back_its_pdf()
    {
        var dir = fx.NewFolder();
        var pdf = await ConvertAsync(EbookBuilders.Cbz(dir), "pdf");
        var azw4 = Path.Combine(dir, "replica.azw4");
        await File.WriteAllBytesAsync(azw4, EbookBuilders.PrintReplica(await File.ReadAllBytesAsync(pdf, TestContext.Current.CancellationToken)), TestContext.Current.CancellationToken);

        var extracted = await ConvertAsync(azw4, "pdf");

        Assert.Equal(await File.ReadAllBytesAsync(pdf, TestContext.Current.CancellationToken), await File.ReadAllBytesAsync(extracted, TestContext.Current.CancellationToken));
    }

    // ───────────────────────── FB2 ─────────────────────────

    [Fact]
    public async Task Fb2_to_epub_keeps_sections_notes_cover_and_the_legacy_encoding()
    {
        var epub = await ConvertAsync(EbookBuilders.Fb2(fx.NewFolder()), "epub");

        var package = EpubAssert.Valid(epub);
        Assert.Equal("Война и мир", package.Title);
        Assert.Equal(["Лев Толстой"], package.Authors);
        Assert.Equal("ru", package.Language);
        Assert.True(package.HasCover);
        Assert.Contains("Глава первая", package.Toc);
        Assert.Contains("epub:type=\"footnote\"", package.AllText); // the note became a footnote
        var text = EpubText(epub);
        foreach (var expected in new[] { "Первый абзац и курсив.", "Строка стиха один", "Текст подглавы.", "Цитата из книги.", "Текст примечания." })
            Assert.Contains(expected, text);
    }

    [Fact]
    public async Task Epub_to_fb2_round_trips()
    {
        var fb2 = await ConvertAsync(EbookBuilders.Epub(fx.NewFolder()), "fb2");

        var xml = XDocument.Load(fb2);
        XNamespace ns = "http://www.gribuser.ru/xml/fictionbook/2.0";
        Assert.Equal("별빛 이야기", xml.Descendants(ns + "book-title").Single().Value);
        Assert.Equal(3, xml.Root!.Element(ns + "body")!.Elements(ns + "section").Count());
        Assert.Equal(2, xml.Descendants(ns + "binary").Count()); // picture + cover
        var book = Fb2Reader.ReadBook(fb2, fx.NewFolder());
        var text = Hwp.Hwpx.PlainTextWriter.Write(book.Document);
        foreach (var expected in new[] { "첫 번째 장", "밤하늘에 별이 반짝였다.", "주석 내용입니다.", "목록 하나" })
            Assert.Contains(expected, text);
        Assert.Contains(book.Document.Sections.SelectMany(s => Hwp.Hwpx.HDocumentWalker.Inlines(s.Blocks)), i => i is Hwp.Hwpx.HText { Text: "별", Format.Bold: true });
    }

    // ───────────────────────── HTMLZ / TXTZ ─────────────────────────

    [Fact]
    public void Txtz_only_includes_images_from_the_unpacked_book()
    {
        var folder = fx.NewFolder();
        var outside = Path.Combine(folder, "private.png");
        File.WriteAllBytes(outside, EbookBuilders.Png(4, 4, MagickColors.Red));
        var txtz = Path.Combine(folder, "book.txtz");
        using (var zip = ZipFile.Open(txtz, ZipArchiveMode.Create))
        {
            using (var writer = new StreamWriter(zip.CreateEntry("index.txt").Open()))
                writer.Write($"![](images/inside.png) ![](../private.png) ![]({new Uri(outside).AbsoluteUri})");
            using var image = zip.CreateEntry("images/inside.png").Open();
            image.Write(EbookBuilders.Png(4, 4, MagickColors.Teal));
        }

        var book = ZippedText.ReadTxtzBook(txtz, folder); // unpacked next to private.png
        var image1 = Assert.Single(Hwp.Hwpx.HDocumentWalker.Images(book.Document));
        Assert.EndsWith(Path.Combine("images", "inside.png"), image1.Path);
    }

    [Fact]
    public async Task Htmlz_and_txtz_are_written_and_read()
    {
        var epub = EbookBuilders.Epub(fx.NewFolder());

        var htmlz = await ConvertAsync(epub, "htmlz");
        using (var zip = ZipFile.OpenRead(htmlz))
        {
            Assert.NotNull(zip.GetEntry("index.html"));
            Assert.NotNull(zip.GetEntry("metadata.opf"));
            Assert.Contains(zip.Entries, e => e.FullName.StartsWith("images/", StringComparison.Ordinal));
        }
        var fromHtmlz = await File.ReadAllTextAsync(await ConvertAsync(htmlz, "txt"), TestContext.Current.CancellationToken);
        Assert.Contains("주석 내용입니다.", fromHtmlz);

        var txtz = await ConvertAsync(epub, "txtz");
        var book = ZippedText.ReadTxtzBook(txtz, fx.NewFolder());
        Assert.Equal("별빛 이야기", book.Metadata.Title);
        Assert.Single(Hwp.Hwpx.HDocumentWalker.Images(book.Document));
        Assert.Contains("밤하늘에", Hwp.Hwpx.PlainTextWriter.Write(book.Document));
    }

    // ───────────────────────── Comics ─────────────────────────

    [Fact]
    public async Task Comics_become_pdf_with_one_page_per_picture_in_natural_order()
    {
        var dir = fx.NewFolder();
        foreach (var comic in new[] { EbookBuilders.Cbz(dir), EbookBuilders.Cbt(dir) })
        {
            var pdf = await ConvertAsync(comic, "pdf");

            using var document = PdfReader.Open(pdf, PdfDocumentOpenMode.Import);
            Assert.Equal(EbookBuilders.ComicPages.Length, document.PageCount);
            // Pages are as large as their pictures (96 dpi), in the order page1, page2, page10.
            for (var i = 0; i < document.PageCount; i++)
                Assert.Equal(EbookBuilders.ComicPages[i].Width * 72.0 / 96, document.Pages[i].Width.Point, 1);
        }
    }

    [Fact]
    public async Task A_comic_with_black_and_white_pages_becomes_a_pdf()
    {
        // #605: PNG pages go into the PDF as they are, and PDFsharp refuses a 1-bit PNG.
        var dir = fx.NewFolder();
        var cbz = Path.Combine(dir, "scans.cbz");
        using (var zip = ZipFile.Open(cbz, ZipArchiveMode.Create))
        {
            zip.CreateEntryFromFile(ImageAndPdfTests.MakeScan(dir, "page1.png"), "page1.png");
            zip.CreateEntryFromFile(ImageAndPdfTests.MakeScan(dir, "page2.png", "16", "2"), "page2.png");
        }

        using var document = PdfReader.Open(await ConvertAsync(cbz, "pdf"), PdfDocumentOpenMode.Import);
        Assert.Equal(2, document.PageCount);
    }

    [Fact]
    public async Task Comics_become_fixed_layout_epub_and_pdf_becomes_cbz()
    {
        var dir = fx.NewFolder();
        var cbz = EbookBuilders.Cbz(dir);

        var epub = await ConvertAsync(cbz, "epub");
        var package = EpubAssert.Valid(epub);
        Assert.True(package.FixedLayout);
        Assert.Equal(EbookBuilders.ComicPages.Length, package.Chapters);
        Assert.Equal(EbookBuilders.ComicPages.Length, package.Images);

        var pdf = await ConvertAsync(cbz, "pdf");
        var back = await ConvertAsync(pdf, "cbz", new Preset { Pdf = { RenderDpi = 96 } });
        using var zip = ZipFile.OpenRead(back);
        Assert.Equal(["001.jpg", "002.jpg", "003.jpg"], zip.Entries.Select(e => e.FullName));
        using var first = new MagickImage(zip.Entries[0].Open());
        Assert.Equal(EbookBuilders.ComicPages[0].Width, first.Width, 2u);

        var fromCbt = await ConvertAsync(EbookBuilders.Cbt(dir), "cbz");
        using var repacked = ZipFile.OpenRead(fromCbt);
        Assert.Equal(["001.png", "002.jpg", "003.png"], repacked.Entries.Select(e => e.FullName));
    }

    // ───────────────────────── Calibre ─────────────────────────

    [Fact]
    public async Task Calibre_writes_kindle_books_that_the_built_in_reader_reads_back()
    {
        Assert.SkipUnless(HasCalibre, "calibre not found (pwsh build/fetch-engines.ps1 -Only calibre)");
        var epub = EbookBuilders.Epub(fx.NewFolder());

        foreach (var format in new[] { "azw3", "mobi" })
        {
            var kindle = await ConvertAsync(epub, format);
            Assert.True(new FileInfo(kindle).Length > 1000);

            // AZW3 is KF8 (skeleton / fragment indexes), MOBI is MOBI 6 (+ KF8 in calibre's joint files).
            var book = MobiReader.ReadBook(kindle, fx.NewFolder(), TestContext.Current.CancellationToken);
            Assert.Equal("별빛 이야기", book.Metadata.Title);
            Assert.Contains("김작가", book.Metadata.Authors);
            var text = Hwp.Hwpx.PlainTextWriter.Write(book.Document);
            foreach (var expected in new[] { "첫 번째 장", "밤하늘에 별이 반짝였다.", "두 번째 장", "주석 내용입니다.", "목록 둘" })
                Assert.Contains(expected, text);
            Assert.NotEmpty(Hwp.Hwpx.HDocumentWalker.Images(book.Document));
            var inlines = book.Document.Sections.SelectMany(s => Hwp.Hwpx.HDocumentWalker.Inlines(s.Blocks)).ToList();
            var link = inlines.OfType<Hwp.Hwpx.HLink>().FirstOrDefault(l => l.Target.StartsWith('#'));
            Assert.NotNull(link);
            Assert.Contains(inlines.OfType<Hwp.Hwpx.HBookmark>(), b => "#" + b.Name == link.Target);
        }
    }

    [Fact]
    public async Task Calibre_reads_and_writes_rare_formats()
    {
        Assert.SkipUnless(HasCalibre, "calibre not found (pwsh build/fetch-engines.ps1 -Only calibre)");
        var epub = EbookBuilders.Epub(fx.NewFolder());

        var lit = await ConvertAsync(epub, "lit");
        var text = await File.ReadAllTextAsync(await ConvertAsync(lit, "txt"), TestContext.Current.CancellationToken); // calibre → EPUB → built-in → TXT

        Assert.Contains("밤하늘에", text);
        Assert.Contains("주석 내용입니다.", text);
    }

    [Fact]
    public async Task Calibre_ranked_first_makes_a4_pdfs_of_e_books()
    {
        Assert.SkipUnless(HasCalibre, "calibre not found (pwsh build/fetch-engines.ps1 -Only calibre)");
        var epub = EbookBuilders.Epub(fx.NewFolder());
        var catalog = new ConverterCatalog(fx.Converters) { Priority = CalibreAt(0) };
        await using var queue = new JobQueue(catalog);
        var job = new ConversionJob([epub], new Preset { TargetFormat = "pdf" }, "pdf");

        await queue.RunAsync(job);

        Assert.True(job.State == JobState.Completed, string.Join("; ", job.Files.Select(f => $"{f.ErrorKey} {f.ErrorDetail}")));
        using var pdf = UglyToad.PdfPig.PdfDocument.Open(job.Outputs.Single());
        Assert.Contains("calibre", pdf.Information.Producer, StringComparison.OrdinalIgnoreCase);
        var page = pdf.GetPage(pdf.NumberOfPages);
        Assert.Equal(595, page.Width, 2.0);  // A4 in points (calibre: 594.96 × 840.96)
        Assert.Equal(842, page.Height, 2.0);
        Assert.Contains("밤하늘에", string.Concat(pdf.GetPages().Select(p => p.Text)));
    }
}

/// <summary>EPUB structure checks (the OCF / OPF rules epubcheck applies first).</summary>
internal static class EpubAssert
{
    /// <summary>A package path relative to a folder of the package ("OEBPS/Text" + "../Images/a.png").</summary>
    private static string Combine(string folder, string relative)
    {
        var parts = folder.Split('/', StringSplitOptions.RemoveEmptyEntries).ToList();
        foreach (var part in relative.Split('/'))
        {
            if (part == "..")
            {
                if (parts.Count > 0)
                    parts.RemoveAt(parts.Count - 1);
            }
            else if (part is not ("." or ""))
            {
                parts.Add(part);
            }
        }
        return string.Join('/', parts);
    }

    public sealed record Package(string Title, string Language, List<string> Authors, int Chapters, int Images, bool HasCover, bool FixedLayout, string Toc, string AllText);

    public static Package Valid(string epub)
    {
        // "mimetype" is the first entry, stored, without extra field, so its content is at byte 38.
        var bytes = File.ReadAllBytes(epub);
        Assert.Equal("PK\u0003\u0004", Encoding.ASCII.GetString(bytes, 0, 4));
        Assert.Equal(0, BitConverter.ToUInt16(bytes, 8)); // stored
        Assert.Equal(0, BitConverter.ToUInt16(bytes, 28)); // no extra field
        Assert.Equal("mimetypeapplication/epub+zip", Encoding.ASCII.GetString(bytes, 30, 28));

        using var zip = ZipFile.OpenRead(epub);
        var container = XDocument.Load(zip.GetEntry("META-INF/container.xml")!.Open());
        var opfPath = container.Descendants().Single(e => e.Name.LocalName == "rootfile").Attribute("full-path")!.Value;
        var opf = XDocument.Load(zip.GetEntry(opfPath)!.Open());
        var root = Path.GetDirectoryName(opfPath)!.Replace('\\', '/');
        string Resolve(string href) => (root.Length > 0 ? root + "/" : "") + Uri.UnescapeDataString(href);

        XNamespace opfNs = "http://www.idpf.org/2007/opf";
        XNamespace dc = "http://purl.org/dc/elements/1.1/";
        Assert.Equal("3.0", opf.Root!.Attribute("version")!.Value);
        var items = opf.Descendants(opfNs + "item").ToList();
        foreach (var item in items)
            Assert.NotNull(zip.GetEntry(Resolve(item.Attribute("href")!.Value))); // every manifest item exists
        Assert.Equal(items.Count, items.Select(i => i.Attribute("id")!.Value).Distinct().Count());
        var ids = items.ToDictionary(i => i.Attribute("id")!.Value);
        var spine = opf.Descendants(opfNs + "itemref").Select(r => ids[r.Attribute("idref")!.Value]).ToList();
        Assert.NotEmpty(spine);
        Assert.NotNull(opf.Descendants(dc + "identifier").SingleOrDefault());
        Assert.NotNull(opf.Descendants(opfNs + "meta").SingleOrDefault(m => m.Attribute("property")?.Value == "dcterms:modified"));

        // Navigation: the nav document (with a non-empty toc) and the NCX, both well-formed.
        var nav = items.Single(i => (i.Attribute("properties")?.Value ?? "").Split(' ').Contains("nav"));
        var navXml = XDocument.Load(zip.GetEntry(Resolve(nav.Attribute("href")!.Value))!.Open());
        Assert.Contains(navXml.Descendants(), e => e.Name.LocalName == "li");
        var ncx = items.Single(i => i.Attribute("media-type")!.Value == "application/x-dtbncx+xml");
        var ncxXml = XDocument.Load(zip.GetEntry(Resolve(ncx.Attribute("href")!.Value))!.Open());
        Assert.Contains(ncxXml.Descendants(), e => e.Name.LocalName == "navPoint");

        // Every XHTML file is well-formed and its links and pictures point at files in the package.
        var allText = new StringBuilder();
        foreach (var item in items.Where(i => i.Attribute("media-type")!.Value == "application/xhtml+xml"))
        {
            var path = Resolve(item.Attribute("href")!.Value);
            var xhtml = XDocument.Load(zip.GetEntry(path)!.Open());
            allText.Append(xhtml.ToString());
            var folder = Path.GetDirectoryName(path)!.Replace('\\', '/');
            foreach (var reference in xhtml.Descendants().SelectMany(e => e.Attributes().Where(a => a.Name.LocalName is "src" or "href")))
            {
                var value = reference.Value.Split('#')[0];
                if (value.Length == 0 || value.Contains(':', StringComparison.Ordinal))
                    continue;
                var target = Combine(folder, Uri.UnescapeDataString(value));
                Assert.True(zip.GetEntry(target) is not null, $"{path} refers to {value}, which is not in the package.");
            }
        }

        return new Package(
            opf.Descendants(dc + "title").First().Value,
            opf.Descendants(dc + "language").First().Value,
            [.. opf.Descendants(dc + "creator").Select(c => c.Value)],
            spine.Count(s => !s.Attribute("href")!.Value.StartsWith("cover", StringComparison.Ordinal)),
            items.Count(i => i.Attribute("media-type")!.Value.StartsWith("image/", StringComparison.Ordinal)),
            items.Any(i => (i.Attribute("properties")?.Value ?? "").Contains("cover-image", StringComparison.Ordinal)),
            opf.Descendants(opfNs + "meta").Any(m => m.Attribute("property")?.Value == "rendition:layout" && m.Value == "pre-paginated"),
            navXml.ToString(),
            allText.ToString());
    }
}