import java.util.List
import java.util.concurrent.BlockingQueue

import org.antlr.stringtemplate.StringTemplate
import org.antlr.stringtemplate.StringTemplateGroup
import org.antlr.stringtemplate.language.DefaultTemplateLexer

import eu.dnetlib.enabling.manager.msro.hope.groovy.RunnableGroovy
import eu.dnetlib.hope.domains.archive.*
import eu.dnetlib.hope.domains.common.*

class CGILPhotosEAD implements RunnableGroovy {

	def String templatePath = "/var/lib/hope-scripts/templates"
	def BlockingQueue<String> resultsQueue, inputQueue;
	/**
	 * Driver namespace for elements in the OAI header.
	 */
	def dri = new groovy.xml.Namespace("http://www.driver-repository.eu/namespace/dri", 'dri')

	def String dataProvider = "Confederazione Generale Italiana del Lavoro"
	def String datasetName = "CGILPhotographs"
	def String repositoryId

	@Override
	public void run() {
		def StringTemplateGroup group =  new StringTemplateGroup("archiveGroup", templatePath, DefaultTemplateLexer.class);
		def StringTemplate archiveTemplate = group.getInstanceOf("archiveTemplate");
		println "got template at path "+templatePath
		def parser = new XmlParser(false, true)
		println "got parser"
		def input;
		while(!((input = this.inputQueue.take()).equals("END"))){
			def Node xmlRoot = parser.parseText(input)
			def Node oaiHeaderNode = xmlRoot.'**'.header[0]
			def String repoId = oaiHeaderNode.'dri:repositoryId'.text()
			def OAIHeader oaiheader = new OAIHeader()
			oaiheader.setDateOfCollection(oaiHeaderNode.'dri:dateOfCollection'.text())
			oaiheader.setIdentifier(oaiHeaderNode.identifier.text())
			oaiheader.setObjIdentifier(oaiHeaderNode.'dri:objIdentifier'.text())
			oaiheader.setRepositoryId(repoId)
			oaiheader.setSetSpec(oaiHeaderNode.setSpec.text())
			def header = generateEadHeader() as EadHeader
			def Node metadataNode = xmlRoot.'**'.metadata[0]
			def archDesc = generateEadArchDesc(metadataNode) as EadArchDesc
			archiveTemplate.setAttribute("oaiheader", oaiheader)
			archiveTemplate.setAttribute("header", header)
			archiveTemplate.setAttribute("archdescs", [archDesc])
			def String res = archiveTemplate.toString()
			res = res.replaceAll("&", "&amp;")
			resultsQueue.put(res)
			archiveTemplate.reset()
		}
		println "consumed input queue"
		this.resultsQueue.put("END")
	}

	def generateEadHeader = {
		def EadHeader eadHeader = new EadHeader(
				mainagencycode:"HOPE - Heritage of the People's Europe", 	eadid:this.datasetName,
				titleproper:new UnitTitle(title:datasetName),
				creationProvider:this.dataProvider, languages:[
					new Language(code:'ita', text:'Italian')
				])
		return eadHeader
	}

	/* xmlRoot points to the start of ead, that is it is on the 'oai:metadata' tag, just before any ead tag*/
	def generateEadArchDesc= {Node container ->
		def String description = '''
Photgraphs relating to CGIL and working class mouvement. 
The original core is the photographic archive of "Lavoro" an illustrated magazine edited by Cgil and pictures illustrates a winde number of aspect of social and culturali life of postwar Italy.
'''
		def EadArchDesc eadArchDesc = new EadArchDesc(dateCreated:new EadDate(normal:'1920-1980', value:'1920-1980'),
				dateAccumulated:new EadDate(normal:'1948-1990', value:'1948-1990'),
				temporalCoverages:['1920-1980'], spatialCoverages:['IT'],
				europeanaType:'IMAGE', europeanaRights:'Rights Reserved - Free Access',
				level:'collection', scopecontentPars:[
					new LanguagedValue(language:'eng',
					value:description)
				],
				accessrestrictPars:[
					new LanguagedValue(value:'free')
				],
				did:new EadDid(localId:this.datasetName,
				unittitles:[
					new UnitTitle(title:'CGIL Photo Archive', language:'eng')
				],
				repository:this.dataProvider,
				physicalDescriptions:[
					new EadPhysDesc(extents:[
						new LanguagedValue(value:'25000')
					])
				])
				)
		def items = generateItemList(container)
		eadArchDesc.setItems(items)
		return eadArchDesc
	}

	def generateItemList = {Node container ->

		def List<Node> itemNodes = container.'**'.c.findAll{it.'@level' == 'item'}
		def List<EadItem> items = itemNodes.collect{
			EadDid did = generateDid(it)
			def EadItem eadItem =  new EadItem(type:"IMAGE", rights:"Rights Reserved - Free Access", languages:['ita'])
			eadItem = generateCFields(eadItem, it) as EadItem
			eadItem.setDid(did)

			def int numberOfEntries = 3
			eadItem.setNumberOfEntries(numberOfEntries)
			//daolocs:
			def Node daoGrpNode = it.daogrp[0]
			if(daoGrpNode != null){
				def dao = daoGrpNode.daoloc[0] as Node

				if(dao != null){
					def String href = dao.'@href'
					//	def String daoGrpId = href.substring(0, href.indexOf('.'))
					def String der2URL = "http://cgil.maas.ccr.it/cgilfotografico/AJAXAttachment.ashx?resource="+href
					def EadDaoLoc der2 = new EadDaoLoc(href:der2URL, label:"derivative2")
					eadItem.setDaolocs([der2])
					eadItem.setDaogrpId(href)
				}
			}
			return eadItem
		}

		return items
	}

	def generateCFields = {eadC,  cElement ->
		def String cId = cElement.did.unitid.find{it.'@type' .equals("nrecord")}.text()
		//eadC.setId(cId)
		eadC.setLevel(cElement.@level)

		def bioghistPars = cElement.bioghist.p*.text().collect{new LanguagedValue(value:it, language:'ita')}
		eadC.setBioghistPars(bioghistPars)
		def custodHistPars = cElement.custodhist.p*.text().collect{new LanguagedValue(value:it, language:'ita')}
		eadC.setCustodHistPars(custodHistPars)
		def acqInfoPars = cElement.acqinfo.p*.text().collect{new LanguagedValue(value:it, language:'ita')}
		eadC.setAcquinfoPars(acqInfoPars)
		def scopeContentNodes = cElement.scopecontent
		def List<String> scopeContents = []
		scopeContentNodes .each{
			def String head = it?.head.text()
			if(head){
				it?.p .each{
					if(it?.text()) scopeContents.add(head+": "+it.text())
				}
			}
			else scopeContents.addAll(it?.p*.text())
		}

		eadC.setScopecontentPars(scopeContents.collect{new LanguagedValue(value:escapeXml(it), language:'ita')})
		def arrPars = cElement.arrangement.p*.text().collect{new LanguagedValue(value:it, language:'ita')}
		eadC.setArrangmentPars(arrPars)
		def accessPars = cElement.accessrestrict.p*.text().collect{new LanguagedValue(value:it, language:'ita')}
		eadC.setAccessrestrictPars(accessPars)
		def phystechPars = cElement.phystech.p*.text().collect{new LanguagedValue(value:it, language:'ita')}
		eadC.setPhystechPars(phystechPars)
		//otherfindaids
		def otherfindaids = cElement.otherfindaid.p*.text().collect{new LanguagedValue(value:it, language:'ita')}
		eadC.setOtherfindaids(otherfindaids)

		def relMaterials = cElement.relatedmaterial*.text().collect{new LanguagedValue(value:it, language:'ita')}
		eadC.setRelatedmaterials(relMaterials)
		def sepMaterials = cElement.separatedmaterial*.text().collect{new LanguagedValue(value:it, language:'ita')}
		eadC.setSeparatedmaterials(sepMaterials)
		def biblios = cElement.bibliography*.text().collect{new LanguagedValue(value:it, language:'ita')}
		eadC.setBibliographies(biblios)

		def persnames = cElement.'**'.controlaccess.'**'.persname*.text() + cElement.'**'.scopecontent.'**'.persname*.text() as Set
		def corpnames = cElement.'**'.controlaccess.'**'.corpname*.text() + cElement.'**'.scopecontent.'**'.corpname*.text() as Set
		def EadControlAccess caAgents = new EadControlAccess(corpNames:corpnames.asList().collect{new LanguagedValue(value:it, language:'ita')},
		persNames:persnames.asList().collect{new LanguagedValue(value:it, language:'ita')})
		def accesses = cElement.controlaccess
		def List<EadControlAccess> accessList = accesses.collect{
			def EadControlAccess controlAccess = new EadControlAccess(controlaccess:it.text())
			controlAccess.setSubjects(it.subject*.text().collect{new LanguagedValue(value:it, language:'ita')})
			controlAccess.setGeognames(it.geogname*.text().collect{new LanguagedValue(value:it, language:'ita')})
			return controlAccess
		}
		accessList.add(caAgents)
		eadC.setControlAccesses(accessList)


		//no landing page:

		eadC.setEuropeanaType('IMAGE');
		eadC.setEuropeanaRights("Rights Reserved - Free Access")
		return eadC;
	}

	def generateDid = {cElement ->
		def Node unitidNode = cElement.did.unitid.find{it.'@type' .equals("nrecord")}
		def cId = unitidNode.text()
		//def callNumber = cElement.did.unitid.find{it.'@type' .equals("call number")}.text().normalize()

		def List<UnitTitle> cUnitTitles = cElement.did.unittitle.collect{new UnitTitle(title:it?.text(), date:it.unitdate?.text(), normalDate:it.unitdate?.find{it.'@normal'}?.text())}
		////c/did/note[@type="genealogia"]
		def List<UnitTitle> genealogiaTitles = []
		def notes = cElement.did?.note?.find{it?.'@type' == 'genealogia'}?.'**'?.unittitle*.text()
		if(notes && notes != []){
			def String notesJoined = notes.join('.  ')
			genealogiaTitles.add(new UnitTitle(title:notesJoined))
		}
		else genealogiaTitles.addAll(cElement.parent()?.unittitle*.text().collect{new UnitTitle(title:it)})

		def List<EadDate> dates = cElement.did.unitdate.findAll{it.'@label' != 'note alla data'}.collect{
			def String normalised = it.'@normal'
			def String date = it?.text()
			if(!normalised) normalised = date
			if(!date) date= normalised
			return new EadDate(value:date, normal:normalised)
		}
		def physNodes = cElement.did.physdesc
		def physDescrs = physNodes.physfacet.findAll{it.'@label' == 'supporto' || it.'@label' == 'cromatismo' || it.'@label' == 'polarita'}*.text()
		def List<EadPhysDesc> eadPhysDescrs = physDescrs.collect{
			return new EadPhysDesc(physdesc:it)
		}
		def String width = physNodes.dimension?.find{it.'@type' == 'width'}
		def String height = physNodes.dimension?.find{it.'@type' == 'height'}
		def String extentValue = null
		if(width && height){
			extentValue = width+', '+height
		}
		else{
			if(width)	extentValue = width
			if(height)	extentValue = height
		}
		if(extentValue)
			eadPhysDescrs << new EadPhysDesc(extents:[
				new LanguagedValue(value:extentValue)
			])

		def langMaterials = cElement.did.langmaterial?.language
		def List<Language> languages
		if(langMaterials){
			languages = langMaterials.collect{
				if(it.text()?.normalize())
					def Language l= new Language(code:"", text:it.text().normalize())
				else def Language ldefault = new Language(code:"ita", text:'Italian')
			}
		}
		else languages = [
				new Language(code:"ita", text:'Italian')
			]

		def notesList = cElement.note.findAll{it.'@label' .equals("note") || it.'@label' .equals("osservazioni")}.p*.text().collect{new LanguagedValue(value:escapeXml(it), language:'ita')}
		def oddsList = cElement.odd.p*.text().collect{new LanguagedValue(value:it, language:'ita')}

		def eadDid = new EadDid(localId:cId, langmaterials:languages,
				repository:unitidNode.'@repositorycode', unitdates:dates,
				originations:[
					new EadOrigination(origination:cElement.did.origination?.find{it.'@label'.equals('literal')}?.text())
				],
				physicalDescriptions:eadPhysDescrs, unittitles:cUnitTitles, parentTitles:genealogiaTitles, odds:[], notes:notesList+oddsList)

		return eadDid;
	}

	def escapeXml = { String s ->
		if(s)
			return s.replaceAll("&", "&amp;")
		else return ''
	}
	@Override
	public void setResultsQueue(BlockingQueue<String> queue) {
		this.resultsQueue = queue
	}

	@Override
	public void setInputQueue(BlockingQueue<String> queue) {
		this.inputQueue = queue
	}

	@Override
	public void closeResultQueue() {
		this.resultsQueue.put("END")
	}
	@Override
	public void setRepositoryId(String repoId) {this.repositoryId = repoId}
}