Extract.kt

/*
 * search-doc-service
 * Copyright (C) 2020 Memoriav
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

package org.memobase.helpers

import com.beust.klaxon.JsonArray
import com.beust.klaxon.JsonObject
import org.apache.logging.log4j.LogManager
import org.memobase.model.CreatorNameContainer
import org.memobase.model.DateContainer
import org.memobase.model.LanguageContainer
import org.memobase.model.NameContainer
import org.memobase.rdf.NS

object Extract {
    private val log = LogManager.getLogger("ExtractSearchDoc")

    private fun languageTag(entity: JsonObject, language: String): List<String> {
        return entity["@value"].let {
            if (entity["@language"] == language && it != null)
                listOf(it as String)
            else
                emptyList()
        }
    }

    fun languageContainer(parent: String, entity: Any?): List<LanguageContainer> {
        return when (entity) {
            is String -> listOf(LanguageContainer(emptyList(), emptyList(), emptyList(), listOf(entity)))
            is JsonObject ->
                listOf(
                    LanguageContainer(
                        de = languageTag(entity, "de"),
                        fr = languageTag(entity, "fr"),
                        it = languageTag(entity, "it"),
                        un = emptyList()
                    )
                )
            is List<*> ->
                listOf(entity.mapNotNull { subEntity ->
                    when (subEntity) {
                        is String ->
                            LanguageContainer(emptyList(), emptyList(), emptyList(), listOf(subEntity))
                        is JsonObject ->
                            LanguageContainer(
                                de = languageTag(subEntity, "de"),
                                fr = languageTag(subEntity, "fr"),
                                it = languageTag(subEntity, "it"),
                                un = emptyList()
                            )
                        else -> {
                            log.error("Could not extract language container from subEntity $subEntity in entity $entity.")
                            null
                        }
                    }
                }.reduce { acc, languageContainer ->
                    acc.merge(languageContainer)
                })
            null -> {
                log.info("No items in $parent found.")
                emptyList()
            }
            else -> {
                log.error("Could not extract language container from entity: $entity in parent $parent.")
                emptyList()
            }
        }
    }

    fun extractDate(entities: List<JsonObject>): List<DateContainer> {
        return entities.map { entity ->
            val isNormalized = entity.containsKey("normalizedDateValue")
            val date = if (isNormalized) {
                entity["normalizedDateValue"] as String
            } else {
                entity["expressedDate"] as String
            }
            val qualifier = entity["dateQualifier"] as String?
            val certainty = entity["certainty"] as String?
            val facetList = when (entity["@type"] as String) {
                NS.rico + "SingleDate" ->
                    if (isNormalized)
                        DateFacetBuilder.buildFromNormalizedSingleDate(date)
                    else emptyList()
                NS.rico + "DateRange" ->
                    if (isNormalized)
                        DateFacetBuilder.buildFromNormalizedDateRange(date)
                    else emptyList()
                else -> emptyList()
            }
            DateContainer(
                date = date,
                qualifier = qualifier,
                certainty = certainty,
                facet = facetList
            )
        }
    }

    fun typedEntityByType(
        entities: List<JsonObject>,
        field: String,
        type: String,
        annotationField: String
    ): List<LanguageContainer> {
        return entities.filter { it[field] == type }.flatMap {
            languageContainer(it["@id"] as String, it[annotationField])
        }
    }

    fun facetEntity(entities: List<JsonObject>, property: String): List<NameContainer> {
        return entities.mapNotNull {
            val lang = languageContainer(it["@id"] as String, it[property])
            if (lang.isEmpty()) {
                null
            } else {
                NameContainer(lang.first(), lang.first().toList())
            }
        }
    }

    fun extractPlaces(entities: List<JsonObject>): List<LanguageContainer> {
        return entities.flatMap {
            languageContainer(it["@id"] as String, it["name"])
        }
    }

    fun extractSourceId(entities: List<JsonObject>): String {
        return entities.first {
            it["type"] as String == "original"
        }["identifier"] as String? ?: error("Identifier contains no property rico:identifier: $entities.")
    }

    fun extractTypedCreationRelationAgent(
        creationRelations: List<JsonObject>,
        input: Map<String, JsonObject>,
        creationRelationTypeParam: String,
        agentTypeParam: String
    ): List<CreatorNameContainer> {
        return creationRelations.mapNotNull { creationRelation ->
            val creationRelationType = creationRelation["type"] as String
            if (creationRelationTypeParam != creationRelationType) return@mapNotNull null
            val name = languageContainer("creation-relation-name", creationRelation["name"])
            if (name.isEmpty()) {
                log.warn("No name for creation relation found: $creationRelation.")
            }
            val agent = Filter.entitiesByProperty("creationRelationHasTarget", creationRelation, input).first()
            val agentType = agent["@type"] as String
            if (agentType != agentTypeParam) return@mapNotNull null
            val agentName = languageContainer(agent["@id"] as String, agent["name"])
            if (agentName.isEmpty()) {
                log.error("Agent/Person/CorporateBody without rico:name found: ${agent["@id"]}.")
                null
            } else {
                return@mapNotNull CreatorNameContainer(
                    agentName.reduce { acc, languageContainer -> acc.merge(languageContainer) },
                    if (name.isNotEmpty()) name.reduce { acc, languageContainer -> acc.merge(languageContainer) }
                    else LanguageContainer(emptyList(), emptyList(), emptyList(), listOf("Unknown")))
            }
        }
    }

    fun listOfStrings(value: Any?): List<String> {
        return when (value) {
            is String -> listOf(value)
            is List<*> ->
                if (value[0] is String)
                    value as List<String>
                else
                    emptyList()
            else ->
                emptyList()
        }
    }

    fun identifier(value: Any?): List<String> {
        return when (value) {
            is String -> listOf(value)
            is JsonObject -> value["@id"].let { if (it is String) listOf(it) else emptyList() }
            is JsonArray<*> ->
                value.mapNotNull { item ->
                    when (item) {
                        is String -> item
                        is JsonObject -> value["@id"].let { id: Any? ->
                            if (id is String)
                                id
                            else null
                        }
                        else -> null
                    }
                }
            else -> emptyList()
        }
    }
}