LyrixLib

// Package.swift
dependencies: [
    .package(url: "https://github.com/RustyKnight/LyrixLib.git", from: "1.0.0"),
],
targets: [
    .target(name: "MyTarget", dependencies: ["LyrixLib"]),
]

import LyrixLib

let parser = LyrixParser()

// Parse from a file URL — format (.lrc / .lrcx) is inferred from the extension
let doc = try parser.parse(contentsOf: url)

// Or parse a string directly
let doc = try parser.parse(content, format: .lrcx)

// Query the active line at a playback position (milliseconds)
let line = doc.activeLine(at: 32_566)
print(line?.displayText)  // plain text, no annotations

// Also get the next upcoming line for preview
let (current, next) = doc.activeLines(at: 32_566)

let parser = LyrixParser()

// From a file URL (extension determines format)
let doc = try parser.parse(contentsOf: URL(filePath: "song.lrcx"))

// From a String with an explicit format
let doc = try parser.parse(content, format: .lrc)
let doc = try parser.parse(content, format: .lrcx)

doc.metadata.title      // String?
doc.metadata.artist     // String?
doc.metadata.album      // String?
doc.metadata.author     // String?  — songwriter ([au:])
doc.metadata.lyricist   // String?  — lyricist ([lr:])
doc.metadata.createdBy  // String?  — LRC file creator ([by:])
doc.metadata.offset     // Int      — global ms shift, already applied to all timestamps
doc.metadata.length     // String?  — e.g. "3:45"

// Active line at a given playback position
let line: LyrixLine? = doc.activeLine(at: milliseconds)

// Active line + the immediately following line (useful for preview)
let (current, next): (LyrixLine?, LyrixLine?) = doc.activeLines(at: milliseconds)

// All lines, sorted ascending by timestamp
let lines: [LyrixLine] = doc.lines

// Silence detection — true before the first line, on instrumental breaks,
// and after a line's end time (when determinable from [tt] or LRCX word timing)
let silent: Bool = doc.isLyricsSilent(at: milliseconds)

line.timestamp           // Int     — start time in ms (offset already applied)
line.displayText         // String  — plain text, no ruby/annotation markup
line.text                // String  — text preserving {ruby} notation
line.isInstrumentalBreak // Bool   — true when the line has no text (silent gap)
line.translation         // String? — from [tr:lang] (LRCX)
line.characterTiming     // [CharacterTiming] — from [tt] (LRCX)
line.lineDurationMilliseconds // Int? — total line duration from [tt] trailing marker (LRCX)
line.words               // [WordSegment] — word-level segments (LRCX karaoke)
line.rubySegments        // [RubySegment]  — line-level ruby segments (LRC)
line.wordCharBoundaries  // [Int]  — character end-positions in displayText for each word (LRCX)

// Active word segment at a given playback position
let word: WordSegment? = line.activeWord(at: milliseconds)

word.timestamp          // Int    — word start time in ms
word.displayText        // String — plain word text
word.isUnfill           // Bool   — true for [<ts] reverse-fill words
word.rubySegments       // [RubySegment]

// Number of characters to highlight, given ms elapsed since the line started
let offset = currentMs - line.timestamp
let count  = line.highlightedCharacterCount(atOffset: offset)

// The character-timing steps themselves
for step in line.characterTiming {
    print("\(step.offsetMilliseconds) ms → highlight \(step.characterCount) chars")
}

// RubySegment appears in both LyrixLine.rubySegments and WordSegment.rubySegments
segment.base            // String  — displayed base text (e.g. "心")
segment.ruby            // String? — annotation text  (e.g. "こころ"), nil if absent
segment.displayText     // String  — alias for .base

do {
    let doc = try LyrixParser().parse(contentsOf: url)
} catch LyrixError.fileReadFailed(let path) {
    print("Could not read file: \(path)")
} catch LyrixError.emptyContent {
    print("The lyrics content was empty")
}

import LyrixLib

func syncToPlayback(url: URL, positionMs: Int) throws {
    let doc = try LyrixParser().parse(contentsOf: url)

    let (current, next) = doc.activeLines(at: positionMs)
    print("Now:  \(current?.displayText ?? "(intro)")")
    print("Next: \(next?.displayText   ?? "")")
}

import LyrixLib

func karaokeHighlight(url: URL, positionMs: Int) throws {
    let doc = try LyrixParser().parse(contentsOf: url)
    guard let line = doc.activeLine(at: positionMs) else { return }

    // Highlight the active word
    let word = line.activeWord(at: positionMs)
    print("Line: \(line.displayText)")
    print("Word: \(word?.displayText ?? "")")

    // wordCharBoundaries gives character end-positions in displayText for each word,
    // accounting for any synthetic inter-word spaces inserted by displayText.
    let boundaries = line.wordCharBoundaries
    print("Word boundaries: \(boundaries)")
}

import LyrixLib

func characterBar(url: URL, positionMs: Int) throws {
    let doc = try LyrixParser().parse(contentsOf: url)
    guard let line = doc.activeLine(at: positionMs) else { return }

    let offset  = positionMs - line.timestamp
    let count   = line.highlightedCharacterCount(atOffset: offset)
    let total   = line.displayText.count

    let filled  = String(repeating: "█", count: count)
    let empty   = String(repeating: "░", count: total - count)
    print("\(filled)\(empty)  \(line.displayText)")

    // Show translation if available
    if let translation = line.translation {
        print("  ↳ \(translation)")
    }
}

import LyrixLib

func printWithFurigana(url: URL, positionMs: Int) throws {
    let doc = try LyrixParser().parse(contentsOf: url)
    guard let line = doc.activeLine(at: positionMs) else { return }

    for segment in line.rubySegments {
        if let ruby = segment.ruby {
            print("\(segment.base)[\(ruby)]", terminator: "")
        } else {
            print(segment.base, terminator: "")
        }
    }
    print()
}

import LyrixLib

func updateLyricsUI(doc: LyrixDocument, positionMs: Int) {
    if doc.isLyricsSilent(at: positionMs) {
        // Hide or fade lyrics display
        return
    }

    let (current, next) = doc.activeLines(at: positionMs)
    print("Now:  \(current?.displayText ?? "")")
    print("Next: \(next?.displayText   ?? "")")
}