import org.antlr.stringtemplate.StringTemplate

import eu.dnetlib.hope.domains.common.Derivative
import eu.dnetlib.hope.domains.common.LandingPage
import eu.dnetlib.hope.domains.common.OAIHeader
import eu.dnetlib.hope.domains.visual.*

class FESLidoUtils {

	def escapeXml = {String s ->
		//return s.replaceAll("&", "&amp;").replaceAll(">", "&gt;").replaceAll("<", "&lt;").replaceAll("\"", "&quot;").replaceAll("'", "&apos;")
		return s.replaceAll("&", "&amp;").replaceAll(">", "&gt;").replaceAll("<", "&lt;")
	}

	def String transformObjekt(Node objekt, StringTemplate template, String dateOfColl, String repoId, String set, String collectionID, boolean isDigital){
		//reset the template for the current Faust-Objekt
		template.reset()
		//identifiers
		def String objId = objekt.Signatur.text()
		//def String objPID = objId
		def String mdLanguage = 'deu';
		def List<String> languageResources = objekt.Sprache*.text()
		if(!languageResources) languageResources = ['deu']
		def String repoObjId = (repoId+"::"+objId)
		//oai header
		def OAIHeader oaiheader = new OAIHeader(dateOfCollection:dateOfColl, repositoryId:repoId, setSpec:set, identifier:objId, objIdentifier:repoObjId, nonDigitalCollection:!isDigital)
		template.setAttribute("oaiheader", oaiheader)

		def src = "Archiv der sozialen Demokratie (AdsD)"
		def euroType = "IMAGE"
		if(collectionID.equals("ADAV")) euroType = "TEXT"

		def LidoIdentifiers lidoIds= new LidoIdentifiers(source:src, localID:objId, parentID:collectionID)

		template.setAttribute("lido", lidoIds)

		def List<String> titles = objekt.Titel*.text()+objekt.Originaltitel*.text()+objekt.Titel_x047x_Motiv*.text()
		def String besch = objekt.Inhaltliche_x032x_Beschreibung?.text()
		def String bemerk = objekt.Bemerkungen?.text()
		def String briefDescr=''
		if(besch) briefDescr+=besch+";"
		if(bemerk) briefDescr+= ' Bemerkungen: '+bemerk;
		def LidoDescription descr = new LidoDescription(langCode:mdLanguage,
		value:escapeXml(briefDescr), type:'brief description')
		def List<LidoTitle> lidoTitles = titles.collect {
			if(it) return new LidoTitle(langCode:mdLanguage, value:escapeXml(it))
		}
		def String hMeasure = objekt.H_x148x_he_x032x_in_x032x_cm?.text()
		def String bMeasure = objekt.Breite_x032x_in_x032x_cm?.text()
		def String aMeasure = objekt.Abmessungen_x032x__x040x_cm_x041x_?.text()
		def String xMeasure = objekt.X?.text()

		def List<String> measures = []
		if(hMeasure) measures.add("Höhe in cm: "+hMeasure)
		if(bMeasure) measures.add("Breite in cm: "+bMeasure)
		if(aMeasure && xMeasure) measures.add("Abmessung in cm: "+aMeasure+"x"+xMeasure)
		else{
			if(aMeasure) measures.add("Abmessung in cm: "+aMeasure)
			if(xMeasure) measures.add("Abmessung in cm: "+xMeasure)
		}

		def List<String> inscrs = objekt.Textwiedergabe*.text().collect{return escapeXml(it)}
		def List<LidoTitle> lidoInscrs = inscrs.collect {
			if(it) return new LidoTitle(value:escapeXml(it))
		}
		def List<TypedSubjects> theTypedSubjects = getTypedSubjects(objekt)

		def LidoDescriptiveMetadata lidoDescrMD = new LidoDescriptiveMetadata(lang:mdLanguage, titles:lidoTitles, descriptions:[descr],
		inscriptions:lidoInscrs, techAttributes:(objekt.Format*.text() + objekt.Farbe*.text() + objekt.Zustand*.text()).collect{return escapeXml(it)},
		workTypes:objekt.Typologie*.text(),
		objectMeasurements:measures,creationEvent:getCreationEvent(objekt),
		displaySubjects:objekt.Sachw_x148x_rter*.text()+objekt.thematische_x032x_Sachw_x148x_rter*.text()+objekt.Ikonographie*.text(),
		typedSubjects:theTypedSubjects,
		repositoryName:src, collectionItemNumber:objId, owners:objekt.Herkunft*.text(),
		europeanaType:euroType)

		def String rechte = escapeXml(objekt.Rechte?.text())
		def String benutz = escapeXml(objekt.Benutzerhinweise?.text())
		def String euroRights = objekt.Rechte?.text()
		if(!euroRights.equalsIgnoreCase('Rechteinhaber unbekannt') && !euroRights.equalsIgnoreCase('Frei')) euroRights = 'Rights Reserved - Restricted Access'

		def String lPage = objekt.Link_x032x_zur_x032x_Beschreibung?.text()
		def LandingPage lpage = new LandingPage(href:lPage, localID:lPage)
		def LidoAdminMetadata lidoAdminMD = new LidoAdminMetadata(lang:mdLanguage, rightsCreditLines:[
			new LidoCreditLine(creditLine:rechte),
			new LidoCreditLine(creditLine:benutz)
		], landingPage:lpage, recordType:"item", europeanaRights:euroRights)

		//only create digital resources if the item is digital.
		if(isDigital){
			def String resourceID = "DR_"+objId
			def theResourceLanguages = languageResources
			if(collectionID.equals("Fotosammlung")) theResourceLanguages = ['zxx']
			def String der2URL = objekt.Link_x032x_zum_x032x_Bild?.text()
			def List<Derivative> ders = [
				new Derivative(type:'derivative2', href:der2URL)
			]
			if(euroType == 'IMAGE') ders << new Derivative(type:'derivative3', href:der2URL)

			def LidoResourceWrap resWrap = new LidoResourceWrap(localID:resourceID, languages:theResourceLanguages,
			europeanaType:euroType, creditLine:euroRights,
			derivatives:ders)
			lidoAdminMD.setResources([resWrap])
		}

		template.setAttribute("lidoDescr", lidoDescrMD)
		template.setAttribute("lidoAdmin", lidoAdminMD)
		return template.toString();
	}

	def getCreationEvent = {Node objekt ->
		/*
		 * String preferredName
		 List<String> altNames
		 List<LidoActor> eventActors
		 List<String> eventDisplayDates
		 List<LidoPlace> eventPlaces
		 List<LidoMaterial> eventMaterialsTech
		 */

		//
		def List<LidoActor> creationOrgs = objekt.Druck_x047x_Verlag*.text().collect{
			if(it) return new LidoActor(type:'organisation', preferredName:escapeXml(it))
		}

		def List<LidoActor> creationActors = (objekt.UrheberIn + objekt.HerausgeberIn)*.text().collect{
			if(it) return new LidoActor(preferredName:escapeXml(it))
		}
		def LidoEvent creationEvt = new LidoEvent(type:'creation', eventPlaces:[], eventDisplayDates:objekt.Datum*.text(),
		eventActors:creationActors+creationOrgs,
		eventMaterialsTech:[
			new LidoMaterial(type:'technique', terms:objekt.Objektbeschreibung*.text())]
		)
		return creationEvt

	}
	def getTypedSubjects = {Node objekt ->
		def List<LidoActor> associatedOrgs = objekt.Organisationen*.text().collect{if(it) return new LidoActor(type:'organisation', preferredName:it)}
		def List<LidoActor> associatedPersons = objekt.betrifft_x032x_Personen*.text().collect{if(it) return new LidoActor(type:'person', preferredName:it)}
		def List<LidoEvent> associatedEvents = objekt.Anlass*.text().collect{if(it) return new LidoEvent(type:'association', preferredName:escapeXml(it))}
		def List<LidoActor> depictedPersons = objekt.abgebildete_x032x_Personen*.text().collect{if(it) return new LidoActor(type:'person', preferredName:it)}
		def List<LidoPlace> associatedPlaces = objekt.geographische_x032x_Namen*.text().collect{
			if(it) return new LidoPlace(preferredName:it)
		}
		def List<TypedSubjects> lidoSubjects = [
			new TypedSubjects(type:"association",actors:associatedOrgs + associatedPersons, events:associatedEvents, places:associatedPlaces),
			new TypedSubjects(type:'depiction', actors:depictedPersons)
		]
		return lidoSubjects
	}
}