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.common.*
import eu.dnetlib.hope.domains.generic.*
import eu.dnetlib.miscutils.datetime.DateUtils


class BDICImmigrationRusse implements RunnableGroovy {

	def String templatePath = "/var/lib/hope-scripts/templates"
	def BlockingQueue<String> resultsQueue, inputQueue
	def String repositoryId
	def String setName = 'default.NOTICES.IMMIGRATION_RUSSE'

	/**
	 * Driver namespace for elements in the OAI header.
	 */
	def dri = new groovy.xml.Namespace("http://www.driver-repository.eu/namespace/dri", 'dri')
	def oai_dc = new groovy.xml.Namespace("http://www.openarchives.org/OAI/2.0/oai_dc/", 'oai_dc')
	def dc = new groovy.xml.Namespace("http://purl.org/dc/elements/1.1/", 'dc')
	def xml = new groovy.xml.Namespace("http://www.w3.org/XML/1998/namespace", 'xml')

	def BDICUtils utils = new BDICUtils()

	@Override
	public void run() {
		def StringTemplateGroup group =  new StringTemplateGroup("genericGroup", templatePath, DefaultTemplateLexer.class)
		def StringTemplate genericTemplate = group.getInstanceOf("genericTemplate")
		println "got template at path "+templatePath
		def parser = new XmlParser(false, true)
		println "got parser"
		def input
		int count = 0
		while(!((input = this.inputQueue.take()).equals("END"))){
			genericTemplate.reset()
			def Node xmlRoot = parser.parseText(input)
			def OAIHeader oaiheader = utils.getOAIHeader(xmlRoot, this.repositoryId)
			def Node dcNode = xmlRoot.'**'.'oai_dc:dc'[0]
			def DCObject dcObject = utils.processDCRecord(dcNode, oaiheader.identifier, oaiheader.setSpec, false, this.setName)
			if(dcObject){
				genericTemplate.setAttribute("oaiheader", oaiheader)
				genericTemplate.setAttribute("dc", dcObject)
				def String res = genericTemplate.toString()
				//println res
				resultsQueue.put(res)
				count++
			}
		}
		println "consumed input queue"
		genericTemplate.reset()
		def String collectionRecord = this.generateCollectionRecord(genericTemplate, count)
		resultsQueue.put(collectionRecord)
		println "enqueued collection"
		this.resultsQueue.put("END")
	}

	def generateCollectionRecord = { StringTemplate genericTemplate, int numberOfItems ->

		def OAIHeader oaiheader = new OAIHeader()
		oaiheader.setDateOfCollection(DateUtils.now_ISO8601())
		oaiheader.setIdentifier(this.setName)
		oaiheader.setObjIdentifier(this.repositoryId+'::'+this.setName)
		oaiheader.setRepositoryId(this.repositoryId)
		oaiheader.setSetSpec(this.setName)

		genericTemplate.setAttribute("oaiheader", oaiheader)

		def String dataProvider = "Bibliothèque de Documentation Internationale Contemporaine (BDIC)"
		def String metadataLanguage = 'fre'
		def LandingPage landingPage = new LandingPage(localID:this.setName, href:'http://www.bdic.fr/collections/quels-documents/archives')
		def List<LanguagedValue> theSpatials = [
			new LanguagedValue(value:'FR'),
			new LanguagedValue(value:'Russian Federation')
		]
		def List<LanguagedValue> theTemporals = [
			new LanguagedValue(value:'1919-1983')
		]
		def List<LanguagedValue> theProvenances = [
			new LanguagedValue(value:dataProvider)
		]
		def List<LanguagedValue> theRights = [
			new LanguagedValue(language:'eng', value:'Negotiated right, public domain'),
			new LanguagedValue(language:'eng', value:'Free Access')
		]

		def DCMetadata duMD = new DCMetadata(localID:this.setName,
				language:metadataLanguage,descriptionLevel:'collection',
				creationDates:['1919-1983'],issueDates:[],
				landingPage:landingPage, extents:[
					new LanguagedValue(value:numberOfItems.toString())
				], mediums:[],subjects:[], spatials:theSpatials, temporals:theTemporals,
				relations:[],  provenances:theProvenances, rights:theRights )

		def List<LanguagedValue> theTitles = [
			new LanguagedValue(language:'eng', value:'Russian immigration')
		]
		def List<LanguagedValue> theAltTitles = [
			new LanguagedValue(language:metadataLanguage, value:'Immigration russe')
		]

		def LanguagedValue collectionAbstract = new LanguagedValue(language:metadataLanguage,
				value:'Fonds d’archives de l’immigration russe, en russe ou français : archives du Comité de secours aux savants russes en France,  de la Colonie russe de Bordeaux, de la Société des étudiants russes de Paris ou encore de Victor Bulin.')

		def List<String> itemLanguages = ['fre']
		def DCObject dcObject = new DCObject(europeanaType:'TEXT', europeanaRights:'NEGOTIATED RIGHTS', cpName:dataProvider,
				titles:theTitles, altTitles:theAltTitles, theAbstract:collectionAbstract, descriptions:[], creators:[], contributors:[], publishers:[],
				du:duMD, dr:new DCResource(languages:itemLanguages) )

		genericTemplate.setAttribute("dc", dcObject)
		def String collectionRes = genericTemplate.toString()
		//println collectionRes
		return collectionRes
	}

	@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
	}
}