object SpindlerLocalDataSource {
    private val path: String = "files/sample.ged"
    private val gedcomIndexDtoToModelMapper: GedcomIndexDtoToModelMapper by lazy { GedcomIndexDtoToModelMapper() }

    suspend fun getData(): GedcomIndex {
        val text = Res.readBytes(path = path).decodeToString()
        return gedcomIndexDtoToModelMapper(text)
    }
}

// Usage  
val familyTree = SpindlerLocalDataSource.getData()
println("Found ${familyTree.individuals.size} individuals!")
println("Found ${familyTree.families.size} families!")  

object SpindlerRemoteDataSource {
    private val httpClient = HttpClient()
    private val gedcomMapper = GedcomIndexDtoToModelMapper()

    suspend fun loadData(url: String, headers: Map<String, String>? = null): GedcomIndex {
        try {
            val gedcomContent = httpClient.get(url) {
                headers {
                    append(
                        HttpHeaders.Accept,
                        "text/plain, text/gedcom, application/octet-stream, */*"
                    )
                    headers?.forEach { (key, value) ->
                        append(key, value)
                    }
                }
            }.body<String>()

            return gedcomIndexDtoToModelMapper(gedcomContent)
        } catch (e: Exception) {
            throw RemoteDataSourceException(
                "Failed to download or parse GEDCOM file from $url",
                e
            )
        } finally {
            close()
        }
    }
}

// Usage  
val familyTree = SpindlerRemoteDataSource.loadData("https://example.com/family.ged")
println("Found ${familyTree.individuals.size} individuals!")
println("Found ${familyTree.families.size} families!")   

data class Individual(
    val id: String,
    val nodes: List<GedcomNode>,
)

data class Family(
    val id: String,
    val nodes: List<GedcomNode>,
)

data class Family(
    val id: String,
    val nodes: List<GedcomNode>,
) {
    val marriageDateRaw: String?
        get() = nodes.firstOrNull { it.tag == Tag.MARRIAGE }?.children
            ?.firstOrNull { it.tag == Tag.DATE }?.value

    val marriageDate: LocalDate?
        get() = DateParsing.tryParseDate(marriageDateRaw)

    val marriageDateFormatted: String
        get() = marriageDate?.toString() ?: "~${marriageDateRaw ?: "N/A"}"

    val marriagePlace: String?
        get() = nodes.firstOrNull { it.tag == Tag.MARRIAGE }?.children
            ?.firstOrNull { it.tag == Tag.PLACE }?.value
}

val individual = familyTree.individuals["I001"]

// Basic Information  
println("Name: ${individual.formattedName}")
println("Given Names: ${individual.givenNames.joinToString(", ")}")
println("Surnames: ${individual.surnames.joinToString(", ")}")
println("Sex: ${individual.sex.name}")

// Life Events  
println("Born: ${individual.birthDateFormatted}")
println("Birth Place: ${individual.birthPlace ?: "Unknown"}")
println("Died: ${individual.deathDateFormatted}")

// Additional Details  
println("Education: ${individual.education ?: "N/A"}")
println("Religion: ${individual.religion ?: "N/A"}")

// Family Relationships  
individual.familyIDAsChild?.let { familyId ->
    val childFamily = familyTree.families[familyId]
    println("Parents' Family: $familyId")
}

individual.familyIDAsSpouse?.let { familyId ->
    val spouseFamily = familyTree.families[familyId]
    println("Spouse Family: $familyId")
}

// MacFamilyTree Integration  
individual.macFamilyTreeID?.let {
    println("MacFamilyTree ID: $it")
}

// Metadata  
println("Last Changed: ${individual.changeDate ?: "N/A"}")
println("Created: ${individual.creationDate ?: "N/A"}")  

val family = familyTree.families["F001"]

// Marriage Information  
println("Marriage Date: ${family.marriageDateFormatted}")
println("Marriage Place: ${family.marriagePlace ?: "Unknown"}")

// Family Members  
family.husbandID?.let { husbandId ->
    val husband = familyTree.individuals[husbandId]
    println("Husband: ${husband.formattedName}")
}

family.wifeID?.let { wifeId ->
    val wife = familyTree.individuals[wifeId]
    println("Wife: ${wife.formattedName}")
}

// Children  
if (family.childrenIDs.isNotEmpty()) {
    println("Children:")
    family.childrenIDs.forEach { childId ->
        val child = familyTree.individuals[childId]
        println("  - ${child.formattedName}")
    }
}

// MacFamilyTree Extensions  
family.macFamilyTreeLabel?.let {
    println("MacFamilyTree Label: $it")
}  

individual.familyIDAsChild
individual.familyIDAsSpouse

family.husbandID
family.wifeID
family.childrenIDs

// These all parse correctly:  
// "1845"           -> 1845-01-01  
// "ABT 1845"       -> ~1845 (approximate)  
// "BEF 1900"       -> ~1900 (before)  
// "EST 1820"       -> ~1820 (estimated)  
// "25 DEC 1800"    -> 1800-12-25  

val individual = familyTree.individuals["I001"]
individual.birthDate          // LocalDate? - null if not parseable  
individual.birthDateRaw       // String? - Raw GEDCOM text  
individual.birthDateFormatted // String - always has a value  

val individual = familyTree.individuals["I001"]

// Find all custom tags  
val customTags = individual.nodes.filter {
    it.tag.startsWith("_") // Custom tags often start with _}  

// Access specific node data  
    val occupationNode = individual.nodes.firstOrNull { it.tag == "OCCU" }
    val occupation = occupationNode?.value