xtc.go

package xtx

import (
	"bytes"
	"encoding/binary"
	"fmt"
	"image"
	"io"
)

// Metadata holds optional metadata for an XTC/XTCH container.
type Metadata struct {
	Title     string
	Author    string
	Publisher string
	Language  string

	CreateTime uint32 // Unix timestamp
	CoverPage  uint16 // 0-based page index; 0xFFFF = none
}

// Chapter represents a named range of pages within an XTC/XTCH container.
type Chapter struct {
	Name      string
	StartPage uint16 // 0-based, inclusive
	EndPage   uint16 // 0-based, inclusive
}

// xtcHeader is the 56-byte XTC/XTCH file header (binary layout).
type xtcHeader struct {
	Mark           uint32
	Version        uint16
	PageCount      uint16
	ReadDirection  uint8
	HasMetadata    uint8
	HasThumbnails  uint8
	HasChapters    uint8
	CurrentPage    uint32
	MetadataOffset uint64
	IndexOffset    uint64
	DataOffset     uint64
	ThumbOffset    uint64
	ChapterOffset  uint64
}

// pageIndex is a 16-byte per-page index entry (binary layout).
type pageIndex struct {
	Offset uint64
	Size   uint32
	Width  uint16
	Height uint16
}

// XTC represents an XTC or XTCH comic container. Use [NewXTC] to create one,
// add pages and metadata, then call [XTC.Encode] to write it out.
type XTC struct {
	xtch      bool
	direction ReadDirection
	metadata  *Metadata
	chapters  []Chapter
	pages     []pageData
	thumbs    []pageData
}

// pageData stores pre-encoded XTG/XTH image data along with its dimensions.
type pageData struct {
	data   []byte
	width  uint16
	height uint16
}

// NewXTC creates a new empty container.
// If xtch is true, the container uses the XTCH variant; otherwise standard XTC.
func NewXTC(xtch bool) *XTC {
	return &XTC{xtch: xtch}
}

// SetDirection sets the reading direction of the comic.
func (c *XTC) SetDirection(d ReadDirection) {
	c.direction = d
}

// SetMetadata sets the container's metadata block.
func (c *XTC) SetMetadata(m Metadata) {
	c.metadata = &m
}

// AddChapter appends a chapter to the container.
func (c *XTC) AddChapter(ch Chapter) {
	c.chapters = append(c.chapters, ch)
}

// AddPage encodes img as XTG and appends it as a page to the container.
func (c *XTC) AddPage(img image.Image) error {
	return c.addPage(img, FormatMonochrome, &c.pages)
}

// AddPageXTH encodes img as XTH and appends it as a page to the container.
func (c *XTC) AddPageXTH(img image.Image) error {
	return c.addPage(img, FormatGrayscale, &c.pages)
}

// AddThumbnail appends a pre-built [*Monochrome] image as a thumbnail.
// Thumbnails are optional and stored in the thumbnail area of the container.
func (c *XTC) AddThumbnail(img *Monochrome) error {
	var buf bytes.Buffer
	if err := Encode(&buf, img, nil); err != nil {
		return fmt.Errorf("xtx: encoding thumbnail: %w", err)
	}
	c.thumbs = append(c.thumbs, pageData{
		data:   buf.Bytes(),
		width:  uint16(img.Rect.Dx()),
		height: uint16(img.Rect.Dy()),
	})
	return nil
}

// addPage encodes an image in the specified format and appends to target slice.
func (c *XTC) addPage(img image.Image, format Format, target *[]pageData) error {
	var buf bytes.Buffer
	bounds := img.Bounds()
	w, h := bounds.Dx(), bounds.Dy()
	if err := Encode(&buf, img, &Options{Format: format}); err != nil {
		return err
	}
	*target = append(*target, pageData{
		data:   buf.Bytes(),
		width:  uint16(w),
		height: uint16(h),
	})
	return nil
}

// Encode writes the complete XTC/XTCH container to w.
func (c *XTC) Encode(w io.Writer) error {
	if len(c.pages) == 0 {
		return fmt.Errorf("xtx: container has no pages")
	}

	magic := MagicXTC
	if c.xtch {
		magic = MagicXTCH
	}

	hasMeta := c.metadata != nil
	hasChapters := len(c.chapters) > 0
	hasThumbs := len(c.thumbs) > 0

	// Calculate section offsets.
	offset := uint64(XTCHeaderSize)

	var metaOffset uint64
	if hasMeta {
		metaOffset = offset
		offset += MetadataSize
	}

	var chapterOffset uint64
	if hasChapters {
		chapterOffset = offset
		offset += uint64(len(c.chapters)) * ChapterSize
	}

	indexOffset := offset
	offset += uint64(len(c.pages)) * IndexEntrySize

	dataOffset := offset

	// Calculate page offsets within data area.
	pageOffsets := make([]uint64, len(c.pages))
	pos := dataOffset
	for i, p := range c.pages {
		pageOffsets[i] = pos
		pos += uint64(len(p.data))
	}

	var thumbOffset uint64
	if hasThumbs {
		thumbOffset = pos
	}

	// Write header.
	hdr := xtcHeader{
		Mark:           magic,
		Version:        0x0100,
		PageCount:      uint16(len(c.pages)),
		ReadDirection:  uint8(c.direction),
		CurrentPage:    0,
		MetadataOffset: metaOffset,
		IndexOffset:    indexOffset,
		DataOffset:     dataOffset,
		ThumbOffset:    thumbOffset,
		ChapterOffset:  chapterOffset,
	}
	if hasMeta {
		hdr.HasMetadata = 1
	}
	if hasThumbs {
		hdr.HasThumbnails = 1
	}
	if hasChapters {
		hdr.HasChapters = 1
	}

	if err := binary.Write(w, binary.LittleEndian, &hdr); err != nil {
		return fmt.Errorf("xtx: writing XTC header: %w", err)
	}

	// Write metadata.
	if hasMeta {
		if err := c.writeMetadata(w); err != nil {
			return err
		}
	}

	// Write chapters.
	if hasChapters {
		if err := c.writeChapters(w); err != nil {
			return err
		}
	}

	// Write page index.
	for i, p := range c.pages {
		idx := pageIndex{
			Offset: pageOffsets[i],
			Size:   uint32(len(p.data)),
			Width:  p.width,
			Height: p.height,
		}
		if err := binary.Write(w, binary.LittleEndian, &idx); err != nil {
			return fmt.Errorf("xtx: writing page index %d: %w", i, err)
		}
	}

	// Write page data.
	for i, p := range c.pages {
		if _, err := w.Write(p.data); err != nil {
			return fmt.Errorf("xtx: writing page data %d: %w", i, err)
		}
	}

	// Write thumbnails.
	for i, t := range c.thumbs {
		if _, err := w.Write(t.data); err != nil {
			return fmt.Errorf("xtx: writing thumbnail %d: %w", i, err)
		}
	}

	return nil
}

// writeMetadata writes the 256-byte metadata block.
func (c *XTC) writeMetadata(w io.Writer) error {
	buf := make([]byte, MetadataSize)

	copyStringField(buf[0:MetaTitleSize], c.metadata.Title)
	copyStringField(buf[0x80:0x80+MetaAuthorSize], c.metadata.Author)
	copyStringField(buf[0xC0:0xC0+MetaPublisherSize], c.metadata.Publisher)
	copyStringField(buf[0xE0:0xE0+MetaLanguageSize], c.metadata.Language)

	binary.LittleEndian.PutUint32(buf[0xF0:], c.metadata.CreateTime)
	binary.LittleEndian.PutUint16(buf[0xF4:], c.metadata.CoverPage)
	binary.LittleEndian.PutUint16(buf[0xF6:], uint16(len(c.chapters)))
	// bytes 0xF8–0xFF: reserved (already zeroed)

	_, err := w.Write(buf)
	if err != nil {
		return fmt.Errorf("xtx: writing metadata: %w", err)
	}
	return nil
}

// writeChapters writes all chapter entries.
func (c *XTC) writeChapters(w io.Writer) error {
	for i, ch := range c.chapters {
		buf := make([]byte, ChapterSize)
		copyStringField(buf[0:80], ch.Name)
		binary.LittleEndian.PutUint16(buf[0x50:], ch.StartPage)
		binary.LittleEndian.PutUint16(buf[0x52:], ch.EndPage)
		// bytes 0x54–0x5F: reserved (already zeroed)
		if _, err := w.Write(buf); err != nil {
			return fmt.Errorf("xtx: writing chapter %d: %w", i, err)
		}
	}
	return nil
}

// copyStringField copies a UTF-8 string into a fixed-size byte field,
// null-terminating and zero-filling the remainder.
func copyStringField(dst []byte, s string) {
	n := copy(dst, s)
	// Zero-fill remainder (dst was already zeroed from make, but be explicit).
	for i := n; i < len(dst); i++ {
		dst[i] = 0
	}
}

// DecodeXTC reads an XTC/XTCH container from r.
func DecodeXTC(r io.ReadSeeker) (*XTC, error) {
	var hdr xtcHeader
	if err := binary.Read(r, binary.LittleEndian, &hdr); err != nil {
		return nil, fmt.Errorf("xtx: reading XTC header: %w", err)
	}

	if hdr.Mark != MagicXTC && hdr.Mark != MagicXTCH {
		return nil, ErrInvalidMagic
	}

	c := &XTC{
		xtch:      hdr.Mark == MagicXTCH,
		direction: ReadDirection(hdr.ReadDirection),
	}

	// Read metadata.
	if hdr.HasMetadata == 1 {
		meta, err := readMetadata(r, hdr.MetadataOffset)
		if err != nil {
			return nil, err
		}
		c.metadata = meta
	}

	// Read chapters. Chapter count is stored in the metadata block at offset 0xF6.
	if hdr.HasChapters == 1 {
		var chapterCount int
		if c.metadata != nil {
			// Re-read chapter count from metadata offset.
			chapterCount = readChapterCount(r, hdr.MetadataOffset)
		}
		if chapterCount > 0 {
			chapters, err := readChapters(r, hdr.ChapterOffset, chapterCount)
			if err != nil {
				return nil, err
			}
			c.chapters = chapters
		}
	}

	// Read page index and data.
	if _, err := r.Seek(int64(hdr.IndexOffset), io.SeekStart); err != nil {
		return nil, fmt.Errorf("xtx: seeking to index: %w", err)
	}

	for i := 0; i < int(hdr.PageCount); i++ {
		var idx pageIndex
		if err := binary.Read(r, binary.LittleEndian, &idx); err != nil {
			return nil, fmt.Errorf("xtx: reading page index %d: %w", i, err)
		}

		// Save current position, seek to page data, read it, seek back.
		curPos, err := r.Seek(0, io.SeekCurrent)
		if err != nil {
			return nil, err
		}
		if _, err := r.Seek(int64(idx.Offset), io.SeekStart); err != nil {
			return nil, fmt.Errorf("xtx: seeking to page %d: %w", i, err)
		}
		data := make([]byte, idx.Size)
		if _, err := io.ReadFull(r, data); err != nil {
			return nil, fmt.Errorf("xtx: reading page %d data: %w", i, err)
		}
		if _, err := r.Seek(curPos, io.SeekStart); err != nil {
			return nil, err
		}

		c.pages = append(c.pages, pageData{
			data:   data,
			width:  idx.Width,
			height: idx.Height,
		})
	}

	return c, nil
}

// PageCount returns the number of pages in the container.
func (c *XTC) PageCount() int {
	return len(c.pages)
}

// Page decodes and returns the i-th page as an [image.Image].
// The returned image is either [*Monochrome] or [*Grayscale] depending
// on the page's format.
func (c *XTC) Page(i int) (image.Image, error) {
	if i < 0 || i >= len(c.pages) {
		return nil, fmt.Errorf("xtx: page index %d out of range [0, %d)", i, len(c.pages))
	}
	r := bytes.NewReader(c.pages[i].data)
	return Decode(r)
}

// Direction returns the reading direction.
func (c *XTC) Direction() ReadDirection {
	return c.direction
}

// GetMetadata returns the container metadata, or nil if not set.
func (c *XTC) GetMetadata() *Metadata {
	return c.metadata
}

// Chapters returns the chapter list.
func (c *XTC) Chapters() []Chapter {
	return c.chapters
}

// readMetadata reads the 256-byte metadata block at the given offset.
func readMetadata(r io.ReadSeeker, offset uint64) (*Metadata, error) {
	if _, err := r.Seek(int64(offset), io.SeekStart); err != nil {
		return nil, fmt.Errorf("xtx: seeking to metadata: %w", err)
	}
	buf := make([]byte, MetadataSize)
	if _, err := io.ReadFull(r, buf); err != nil {
		return nil, fmt.Errorf("xtx: reading metadata: %w", err)
	}

	m := &Metadata{
		Title:      readStringField(buf[0:MetaTitleSize]),
		Author:     readStringField(buf[0x80 : 0x80+MetaAuthorSize]),
		Publisher:  readStringField(buf[0xC0 : 0xC0+MetaPublisherSize]),
		Language:   readStringField(buf[0xE0 : 0xE0+MetaLanguageSize]),
		CreateTime: binary.LittleEndian.Uint32(buf[0xF0:]),
		CoverPage:  binary.LittleEndian.Uint16(buf[0xF4:]),
	}
	return m, nil
}

// readChapterCount reads the chapter count from the metadata block.
func readChapterCount(r io.ReadSeeker, metadataOffset uint64) int {
	var buf [2]byte
	pos, _ := r.Seek(0, io.SeekCurrent)
	r.Seek(int64(metadataOffset)+0xF6, io.SeekStart)
	io.ReadFull(r, buf[:])
	r.Seek(pos, io.SeekStart)
	return int(binary.LittleEndian.Uint16(buf[:]))
}

// readChapters reads chapter entries at the given offset.
func readChapters(r io.ReadSeeker, offset uint64, chapterCount int) ([]Chapter, error) {
	if _, err := r.Seek(int64(offset), io.SeekStart); err != nil {
		return nil, fmt.Errorf("xtx: seeking to chapters: %w", err)
	}
	chapters := make([]Chapter, 0, chapterCount)
	for i := 0; i < chapterCount; i++ {
		buf := make([]byte, ChapterSize)
		if _, err := io.ReadFull(r, buf); err != nil {
			return nil, fmt.Errorf("xtx: reading chapter %d: %w", i, err)
		}
		chapters = append(chapters, Chapter{
			Name:      readStringField(buf[0:80]),
			StartPage: binary.LittleEndian.Uint16(buf[0x50:]),
			EndPage:   binary.LittleEndian.Uint16(buf[0x52:]),
		})
	}
	return chapters, nil
}

// readStringField reads a null-terminated string from a fixed-size byte field.
func readStringField(buf []byte) string {
	for i, b := range buf {
		if b == 0 {
			return string(buf[:i])
		}
	}
	return string(buf)
}