import java.util.List

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 PersMuseumLidoUtils {

	def String cpCompleteName = "Persmuseum"
	def String defaultLanguage = "nld"

	def escapeXml = {String s ->
		if(s)
			return s.replaceAll("&", "&amp;").replaceAll(">", "&gt;").replaceAll("<", "&lt;")
		else return ''
	}

	def transformMarcRecord = {Node marcRecord, StringTemplate template, String dateOfColl, String repoId, String set, String collectionPID ->
		//reset the template for the current Faust-Objekt
		template.reset()
		//identifiers
		def String objId = marcRecord.'**'.'marc:controlfield'.find{it.'@tag'.equals('001')}?.text()
		//concat('http://hdl.handle.net/',//marc:datafield[@tag='902']/marc:subfield[@code='a'])
		def String objPID ='http://hdl.handle.net/'+marcRecord.'**'.'marc:datafield'.find{it.'@tag'.equals('902')}?.'marc:subfield'.find{it.'@code'.equals('a')}?.text()

		def String repoObjId = (repoId+"::"+objId)
		//oai header
		def OAIHeader oaiheader = new OAIHeader(dateOfCollection:dateOfColl, repositoryId:repoId, setSpec:set, identifier:objId, objIdentifier:repoObjId)
		template.setAttribute("oaiheader", oaiheader)

		def src = cpCompleteName

		def LidoIdentifiers lidoIds= getLidoIdentifiers(src,objId,objPID, collectionPID)
		def LidoDescriptiveMetadata lidoDescrMD = getLidoDescr(marcRecord)
		def LidoAdminMetadata lidoAdminMD = getLidoAdmin(marcRecord, objId)

		template.setAttribute("lido", lidoIds)
		template.setAttribute("lidoDescr", lidoDescrMD)
		template.setAttribute("lidoAdmin", lidoAdminMD)

		return template.toString();
	}

	def getLidoIdentifiers = {String src, String objId, String pid, String parentPid ->
		new LidoIdentifiers(source:src, localID:objId, pid:pid, parentID: parentPid, parentPID: parentPid)
	}

	def getLidoDescr = {Node marcRecord ->

		def List<String> wt =
				marcRecord.'**'.'marc:datafield'.findAll{it.'@tag'.equals('655')}*.'marc:subfield'*.find{it.'@code'.equals('a')}*.text()

		def List<String> titles = getTitles(marcRecord)

		def List<LidoTitle> lidoTitles = titles .collect {
			LidoTitle lt1 = new LidoTitle(langCode:"", value:escapeXml(it))
		}
		def String idItem = marcRecord.'**'.'marc:datafield'?.find{it.'@tag'.equals('852')}?.'marc:subfield'?.find{it.'@code'.equals('p')}?.text()
		def List<String> descriptions = marcRecord.'marc:datafield'.findAll {it.'@tag'.equals('500')}*.'marc:subfield'*.find{it.'@code'.equals('a')}*.text()
		def List<LidoDescription> descrs = descriptions.collect{
			new LidoDescription(langCode:defaultLanguage, value:escapeXml(it), type:'brief description')
		}
		def List<String> objMeasures = marcRecord.'**'.'marc:datafield'?.findAll{it.'@tag'.equals('300')}*.'marc:subfield'*.find{it.'@code'.equals('g')}*.text()
		def List<String> extents = objMeasures.collect{
			if(it?.contains('; ')) return it.split('; ')[1]
			else return it
		}

		def List<String> objOwners = getOwners(marcRecord)
		def LidoEvent creationEvnt = getCreationEvent(marcRecord)

		def List<String> genericSubjects = marcRecord.'**'.'marc:datafield'.findAll{it.'@tag'.equals('650')}?.'marc:subfield'?.findAll{it.'@code'.equals('a')}*.text()

		def List<TypedSubjects> specificSubjects = getLidoSubjects(marcRecord)


		def LidoDescriptiveMetadata lidoDescrMD = new LidoDescriptiveMetadata(lang:defaultLanguage, workTypes:wt, europeanaType:'IMAGE', titles:lidoTitles,
				repositoryName:cpCompleteName, collectionItemNumber:idItem, descriptions:descrs, objectMeasurements:objMeasures,owners:objOwners,
				creationEvent:creationEvnt,  displaySubjects:genericSubjects, typedSubjects:specificSubjects )

		return lidoDescrMD
	}

	def getTitles = {Node marcRecord ->
		def List<String> titles
		def nodes245 = marcRecord.'marc:datafield'.findAll {it.'@tag'.equals('245')}
		titles = nodes245*.'marc:subfield'*.find{it.'@code'.equals('a')}*.text()
		if(titles && titles != [null]) return titles
		titles = marcRecord.'marc:datafield'.findAll {it.'@tag'.equals('500')}*.'marc:subfield'*.find{it.'@code'.equals('a')}*.text()
		if(titles && titles != [null]) return titles
		titles = marcRecord.'marc:datafield'.findAll {it.'@tag'.equals('600')}*.'marc:subfield'*.find{it.'@code'.equals('a')}*.text()
		if(titles && titles != [null]) return titles
		titles = marcRecord.'marc:datafield'.findAll {it.'@tag'.equals('610')}*.'marc:subfield'*.find{it.'@code'.equals('a')}*.text()
		if(titles && titles != [null]) return titles
		titles = marcRecord.'marc:datafield'.findAll {it.'@tag'.equals('650')}*.'marc:subfield'*.find{it.'@code'.equals('a')}*.text()
		if(titles && titles != [null]) return titles
		titles = marcRecord.'marc:datafield'.findAll {it.'@tag'.equals('651')}*.'marc:subfield'*.find{it.'@code'.equals('a')}*.text()
		if(titles && titles != [null]) return titles
		return nodes245*.'marc:subfield'*.find{it.'@code'.equals('k')}*.text()
		//def List<String> titles = marcRecord.'marc:datafield'.findAll {it.'@tag'.equals('245')}*.'marc:subfield'*.find{it.'@code'.equals('k')}*.text()
	}

	def getOwners = {Node marcRecord ->
		def List<String> owners = []
		def List<String> finalOwners = []
		def node700s = marcRecord.'**'.'marc:datafield'.findAll{it.'@tag'.equals('700')}
		//&& it.'marc:subfield'?.find{it.'@code'.equals('e') && it.text().equals('collector')}}
		def collector700s = node700s.collect {if(it.'marc:subfield'?.find{it.'@code'.equals('e') && it.text().equals('collector')}) return it}

		if(collector700s){
			owners = collector700s.collect{
				String collectorName = it?.'marc:subfield'?.find{it.'@code'.equals('a')}?.text()
				//println "700 collector name: "+collectorName
				if(collectorName) return collectorName
			}
		}

		if(!owners){
			def node710s = marcRecord.'**'.'marc:datafield'?.findAll{it.'@tag'.equals('710')}
			def collector710s = node710s.collect {if(it?.'marc:subfield'.find{it.'@code'.equals('e') && it.text()?.equals('collector')}) return it}
			owners = collector710s?.collect{return it?.'marc:subfield'?.find{it.'@code'.equals('a')}?.text()}
		}

		finalOwners = owners?.findAll{it != null}
		return owners
	}

	def getLidoSubjects = {Node marcRecord ->

		def List<String> persons = marcRecord.'**'.'marc:datafield'.findAll{it.'@tag'.equals('600')}*.'marc:subfield'*.find{it.'@code'.equals('a')}*.text()
		def List<LidoActor> personActor = persons.collect{new LidoActor(type:'person', preferredName:escapeXml(it))}
		def orgNodes = marcRecord.'**'.'marc:datafield'.findAll{it.'@tag'.equals('610')}
		def orgs = orgNodes*.'marc:subfield'*.find{it.'@code'.equals('a')}*.text() + orgNodes*.'marc:subfield'*.find{it.'@code'.equals('b')}*.text()
		def List<LidoActor> orgActors = orgs.collect{
			new LidoActor(type:'organisation', preferredName:escapeXml(it))
		}

		def List<String> subjectEventNames = marcRecord.'**'.'marc:datafield'.findAll{it.'@tag'.equals('611')}*.'marc:subfield'*.find{it.'@code'.equals('a')}*.text()
		def List<LidoEvent> subjectEvents = subjectEventNames.collect{
			new LidoEvent(type:"depiction", preferredName:escapeXml(it));
		}

		def List<String> subjectPlaceNames = marcRecord.'**'.'marc:datafield'.findAll{it.'@tag'.equals('651')}*.'marc:subfield'*.find{it.'@code'.equals('a')}*.text()
		def List<LidoPlace> subjectPlaces = subjectPlaceNames.collect{
			new LidoPlace(preferredName:escapeXml(it));
		}

		def TypedSubjects depictedSubject = new TypedSubjects(type:"depiction",
				dates:marcRecord.'**'.'marc:datafield'.findAll{it.'@tag'.equals('648')}*.'marc:subfield'*.find{it.'@code'.equals('a')}*.text(),
				objects:marcRecord.'**'.'marc:datafield'.findAll{it.'@tag'.equals('650')}*.'marc:subfield'*.find{it.'@code'.equals('a')}*.text(),
				actors:personActor+orgActors, events:subjectEvents, places:subjectPlaces)

		return [depictedSubject]
	}

	def getLidoAdmin = {Node marcRecord, String  objId->

		def LandingPage lpage = new LandingPage(
				localID:'http://search.socialhistory.org/Record/'+marcRecord.'**'.'marc:controlfield'.find{it.'@tag'.equals('001')}?.text(),
				href:'http://hdl.handle.net/'+marcRecord.'**'.'marc:datafield'.find{it.'@tag'.equals('902')}?.'marc:subfield'.find{it.'@code'.equals('a')}?.text())

		def String euroRights = "Public Domain"
		def LidoCreditLine cl;
		def creditLines = marcRecord.'**'.'marc:datafield'.find{it.'@tag'.equals('540')}?.find{it.'@code'.equals('b')}?.text()
		if(creditLines)
		{
			euroRights = "Rights reserved - Restricted access"
			cl = new LidoCreditLine(creditLine:creditLines)
		}
		else{
			cl = new LidoCreditLine(creditLine:'Public Domain')
		}
		def LidoAdminMetadata lidoAdminMD = new LidoAdminMetadata(lang:defaultLanguage, landingPage:lpage, recordType:"item",
				europeanaRights:euroRights, rightsCreditLines:[cl])


		//marc:datafield[@tag='852']/marc:subfield[@code='p']
		def String resourceID = marcRecord.'**'.'marc:datafield'.find{it.'@tag'.equals('852')}?.'marc:subfield'?.find{it.'@code'.equals('p')}?.text()
		def String resourcePID = marcRecord.'**'.'marc:datafield'.find{it.'@tag'.equals('856')}?.'marc:subfield'?.find{it.'@code'.equals('u')}?.text()
		if(resourcePID){
			//concat(//marc:datafield[@tag='856']/marc:subfield[@code='u'], '?locatt=view:level2')
			def String der2Link = resourcePID+'?locatt=view:level2'
			def Derivative der2 = new Derivative(type:'derivative2', href:der2Link, pid:der2Link, localID:der2Link)
			def String der3Link = resourcePID+'?locatt=view:level3'
			def Derivative der3 = new Derivative(type:'derivative3', href:der3Link, pid:der3Link, localID:der3Link)

			def LidoResourceWrap resWrap = new LidoResourceWrap(pid:resourcePID, localID:resourcePID, languages:[
				marcRecord.'**'.'marc:datafield'?.find{it.'@tag'.equals('041')}?.'marc:subfield'?.find{it.'@code'.equals('a')}?.text()
			],
			europeanaType:"IMAGE", creditLine:euroRights, derivatives:[der2, der3])
			lidoAdminMD.setResources([resWrap])
		}
		return lidoAdminMD
	}

	def getDepictionEvents = {Node marcRecord ->
		def depictedPersNodes = marcRecord.'marc:datafield'.findAll {it.'@tag'.equals('600')}*.'marc:subfield'*.find{it.'@code'.equals('a')}
		List<LidoActor> depictedPersons = depictedPersNodes .collect{
			new LidoActor(type:"person", preferredName:escapeXml(it.text()))
		}
		//concat(//marc:datafield[@tag='610'/marc:subfield[@code='a'], ', ' ,//marc:datafield[@tag='610'/marc:subfield[@code='b'] )
		def depictedOrgNodes = marcRecord.'marc:datafield'.findAll{it.'@tag'.equals('610')}
		List<LidoActor> depictedOrgs = depictedOrgNodes .collect{
			new LidoActor(type:"organisation", preferredName:escapeXml(it.'marc:subfield'?.find{it.'@code'.equals('a')}?.text())+', '+escapeXml(it.'marc:subfield'?.find{it.'@code'.equals('b')}?.text()))
		}

		/*
		 *String source, localID, preferredName
		 List<String> altNames
		 */
		def depictedPlaceNodes = marcRecord.'marc:datafield'?.findAll {it.'@tag'.equals('651')}*.'marc:subfield'*.find{it.'@code'.equals('a')}
		List<LidoPlace> depictedPlaces = depictedPlaceNodes .collect{
			new LidoPlace(localID:'', preferredName:escapeXml(it.text()))
		}

		def LidoEvent depictionEvent = new LidoEvent(type:"depiction", preferredName:'',altNames:[],
		eventDisplayDates:marcRecord.'marc:datafield'.findAll {it.'@tag'.equals('648')}*.'marc:subfield'*.find{it.'@code'.equals('a')}*.text(),
		places:depictedPlaces, materialsTech:[], eventActors:depictedPersons+depictedOrgs)
		return [depictionEvent]
	}

	def getCreationEvent = {Node marcRecord ->

		def creationPersNodes = marcRecord.'marc:datafield'.findAll{it.'@tag'.equals('100')}*.'marc:subfield'*.find{it.'@code'.equals('a')}*.text()
		List<LidoActor> creationPers = creationPersNodes .collect{
			new LidoActor(type:"person", preferredName:escapeXml(it))
		}
		def creationOrgNodes = marcRecord.'marc:datafield'?.findAll {it.'@tag'.equals('110')}*.'marc:subfield'*.find{it.'@code'.equals('a')}*.text()
		List<LidoActor> creationOrgs = creationOrgNodes .collect{
			new LidoActor(type:"organisation", preferredName:escapeXml(it))
		}

		def creationPlaceNodes = marcRecord.'marc:datafield'?.findAll {it.'@tag'.equals('260')}*.'marc:subfield'*.find{it.'@code'.equals('a')}*.text()
		def List<LidoPlace> creationPlaces = creationPlaceNodes .collect{
			new LidoPlace(preferredName:escapeXml(it))
		}

		def materialsNodes = marcRecord.'marc:datafield'?.findAll {it.'@tag'.equals('300')}*.'marc:subfield'*.find{it.'@code'.equals('g')}*.text()

		def List<LidoMaterial> materials = materialsNodes .collect{
			def String mat
			if(it?.contains('; ')) mat= it.split('; ')[0]
			new LidoMaterial(type:'material', terms:[escapeXml(mat)])
		}
		//		def List<LidoMaterial> materials = materialsNodes .collect{
		//			new LidoMaterial(type:'material', terms:[escapeXml(it)])
		//		}
		//		def List<LidoMaterial> techniques = materialsNodes .collect{
		//			new LidoMaterial(type:'technique', terms:[escapeXml(it)])
		//		}
		def List<LidoMaterial> techniques = []

		def LidoEvent creationEvent = new LidoEvent(type:"creation", eventActors:creationOrgs+creationPers,
				eventDisplayDates:marcRecord.'marc:datafield'?.findAll {it.'@tag'.equals('260')}*.'marc:subfield'*.find{it.'@code'.equals('c')}*.text(),
				eventPlaces:creationPlaces, eventMaterialsTech:materials+techniques);

		return creationEvent
	}

}