page.go

package textractor

import (
	"slices"
	"sort"
	"strings"

	"github.com/hupe1980/go-textractor/internal"
)

type Page struct {
	id         string
	number     int
	width      float32
	height     float32
	childIDs   []string
	words      []*Word
	lines      []*Line
	keyValues  []*KeyValue
	tables     []*Table
	layouts    []*Layout
	queries    []*Query
	signatures []*Signature
}

func (p *Page) ID() string {
	return p.id
}

func (p *Page) Number() int {
	return p.number
}

func (p *Page) Width() float32 {
	return p.width
}

func (p *Page) Height() float32 {
	return p.height
}

func (p *Page) Words() []*Word {
	return p.words
}

func (p *Page) Lines() []*Line {
	return p.lines
}

func (p *Page) Tables() []*Table {
	return p.tables
}

func (p *Page) KeyValues() []*KeyValue {
	return p.keyValues
}

func (p *Page) Layouts() []*Layout {
	return p.layouts
}

func (p *Page) Queries() []*Query {
	return p.queries
}

func (p *Page) Signatures() []*Signature {
	return p.signatures
}

func (p *Page) AddLayouts(layouts ...*Layout) {
	p.layouts = append(p.layouts, layouts...)
}

func (p *Page) Text(optFns ...func(*TextLinearizationOptions)) string {
	text, _ := p.textAndWords(optFns...)
	return text
}

func (p *Page) textAndWords(optFns ...func(*TextLinearizationOptions)) (string, []*Word) {
	// Create a copy of the layouts to avoid modifying the original slice
	sortedLayouts := make([]*Layout, len(p.layouts))
	copy(sortedLayouts, p.layouts)

	// Sort layouts based on the reading order
	sort.Slice(sortedLayouts, func(i, j int) bool {
		return sortedLayouts[i].BoundingBox().Top() < sortedLayouts[j].BoundingBox().Top()
	})

	pageTexts := make([]string, len(sortedLayouts))
	wordLists := make([][]*Word, len(sortedLayouts))

	for i, l := range sortedLayouts {
		text, words := l.TextAndWords(optFns...)

		pageTexts[i] = text
		wordLists[i] = words
	}

	return strings.Join(pageTexts, "\n"), internal.Concatenate(wordLists...)
}

func (p *Page) SearchValueByKey(key string) []*KeyValue {
	searchKey := strings.ToLower(key)

	var result []*KeyValue

	for _, kv := range p.keyValues {
		if key := kv.Key(); key != nil {
			if strings.Contains(strings.ToLower(key.Text()), searchKey) {
				result = append(result, kv)
			}
		}
	}

	return result
}

func (p *Page) isChild(id string) bool {
	return slices.Contains(p.childIDs, id)
}