import eu.dnetlib.hope.domains.archive.*
import eu.dnetlib.hope.domains.common.*

class MSHUtils {

	def String aggregator = 'Centre de ressources numériques thématique'
	def String dataProvider = "Maison des Sciences de l'Homme de Dijon (MSH Dijon), USR CNRS-uB 3516"

	def generateHeader= { Node xmlRoot ->
		def eadHeaderElement = xmlRoot.'**'.eadheader
		def EadHeader eadHeader = new EadHeader(
				mainagencycode:aggregator, eadid:eadHeaderElement.eadid.text(),
				creationProvider:dataProvider, languages:[
					new Language(code:'fra', text:'fra')]
				)
		return eadHeader
	}

	def generateArchivalCollection = { xmlRoot, repoId ->
		def Node archDescNode = xmlRoot.'**'.archdesc[0]
		def collectionID = archDescNode.'@id'
		def landingPageURL = archDescNode.prefercite.p[0]?.text()
		println "Collection landing page is: "+landingPageURL
		def EadDaoLoc collectionLandingPage = new EadDaoLoc(href:landingPageURL, label:"landing_page");
		def String collectionThumbnail

		def Node archDescDid = archDescNode.did[0]
		def List<Language> languages = getLanguages(archDescNode)
		def EadDid collectionDid = new EadDid(localId:collectionID, repository:dataProvider,
				unittitles:archDescDid.unittitle*.text().collect{return new UnitTitle(title:it)},
				physicalDescriptions:[
					new EadPhysDesc(genreforms:[
						new LanguagedValue(value:archDescDid?.physdesc?.genreform?.text())
					], extents:[
						new LanguagedValue(value:archDescDid?.physdesc?.extent?.text())
					])
				], langmaterials:languages
				)

		def dateC = archDescNode.did.unitdate?.text()
		def dateA = xmlRoot.'**'.eadheader.filedesc.publicationstmt?.date?.text()
		def userRestricts = archDescNode.userestrict?.p*.text()
		def userRes = userRestricts.join(' ')
		def String europeanaRights  = archDescNode.accessrestrict.legalstatus?.'@type'[0]
		def String defaultEuropeanaRights = europeanaRights?.toUpperCase()

		def EadArchDesc eadArchDesc = new EadArchDesc(level:'collection',
				landingPage:collectionLandingPage, thumbnail:collectionThumbnail, did:collectionDid,
				dateCreated:new EadDate(normal:dateC , value:dateC ),
				dateAccumulated:new EadDate(normal:dateA , value:dateA ),
				scopecontentPars:[
					new LanguagedValue(
					value:archDescNode.scopecontent.p*.text().join(' - '))
				],
				custodHistPars:archDescNode.acqinfo*.text().collect{return new LanguagedValue(value:it)},
				controlAccesses:[
					new EadControlAccess(subjects:[
						new LanguagedValue(value:'XXe siècle')
					])
				],
				userrestrictPars:[
					new LanguagedValue(value:userRes)
				],
				accessrestrictPars:archDescNode.accessrestrict?.legalstatus*.text().collect{
					new LanguagedValue(value:it)
				},
				europeanaType:'TEXT', europeanaRights:defaultEuropeanaRights)
		fillArchDescSons(archDescNode, eadArchDesc, repoId, defaultEuropeanaRights)
		return eadArchDesc
	}

	def fillArchDescSons = { Node archDescElement, EadArchDesc eadArchDesc, String repoId, String defaultEuropeanaRights ->
		def List<EadMidLevel> midLevels = generateMidLevels(archDescElement, repoId, true, defaultEuropeanaRights)
		eadArchDesc.setNestedLevels(midLevels)
		def items = generateItemList(archDescElement.dsc[0], archDescElement, repoId, defaultEuropeanaRights)
		eadArchDesc.setItems(items)
	}

	def generateMidLevels = { cNode, repoId, isArchdesc, defaultEuroRights ->
		def List<Node> midNodes = cNode.c
		if(isArchdesc) midNodes = cNode.dsc[0].c
		//println 'counted '+midNodes.size() + " nested c elements"
		def List<EadMidLevel> midLevels = midNodes.collect {
			if(!it.'@level' .equals('item')){
				def EadMidLevel eadMidLevel = new EadMidLevel()
				def EadDid eadDid = generateDid(it, cNode, repoId)
				eadMidLevel.setDid(eadDid);
				fillCFields(eadMidLevel, cNode, it, repoId, false, defaultEuroRights)
				def items = generateItemList(it, cNode, repoId, defaultEuroRights)
				eadMidLevel.setItems(items)
				def List<EadMidLevel> nestedLevels = generateMidLevels(it, repoId, false, defaultEuroRights);
				eadMidLevel.setNestedLevels(nestedLevels)
				return eadMidLevel
			}
		}
		return midLevels;
	}

	def generateItemList={ Node currentC, Node containerC, String repoId, String defaultEuroRights ->
		//No digital resource generated because they only have thumbnails and isShownAt
		def String localID = currentC.'@id'
		def List<Node> itemNodes = currentC.c.findAll{it.'@level' .equals('item')}

		def List<EadItem> items = itemNodes.collect{
			def EadDid did = generateDid(it, containerC, repoId)
			def EadItem eadItem =  new EadItem(did:did, type:"TEXT")
			fillCFields(eadItem, containerC, it, repoId,false, defaultEuroRights)
			def int numberOfEntries = 3
			def List<Language> languages= getLanguages(it)
			eadItem.setLanguages(languages)
			numberOfEntries += languages.size()
			eadItem.setNumberOfEntries(numberOfEntries)
			return eadItem
		}
		return items
	}

	def fillCFields = { EadCElement eadC, Node archDescNode, Node currentC, String repoId, boolean isArchdesc, String defaultEuroRights ->
		//eadC.setThumbnail('TODO')
		def String euroRights = currentC.accessrestrict.legalstatus.'@type'[0]
		if(!euroRights) euroRights = defaultEuroRights
		eadC.setEuropeanaType('TEXT')
		eadC.setEuropeanaRights(euroRights)

		eadC.setLevel(currentC.@level.toUpperCase())

		def bioghistPars = currentC.bioghist.p*.text().collect{return new LanguagedValue(value:it)}
		eadC.setBioghistPars(bioghistPars)
		def acqPars = archDescNode.acqinfo.p*.text().collect{return new LanguagedValue(value:it)}
		eadC.setBioghistPars(bioghistPars)
		def scopeContentPars = [
			new LanguagedValue(value:currentC.scopecontent.p*.text().join(' - '))
		]
		eadC.setScopecontentPars(scopeContentPars)
		def arrangmentPars = [
			new LanguagedValue(value:archDescNode.arrangement.p*.text().join(' - '))
		]
		eadC.setArrangmentPars(arrangmentPars)

		def accessPars = currentC.accessrestrict.legalstatus*.text().collect{return new LanguagedValue(value:it)}
		eadC.setAccessrestrictPars(accessPars)

		def String usePars1 = currentC.userestrict.p*.text().join(' ')
		def usePars = [
			new LanguagedValue(value:usePars1)
		]
		eadC.setUserrestrictPars(usePars)

		def accesses = currentC.controlaccess
		def List<EadControlAccess> accessList = accesses.collect{
			return new EadControlAccess(
			persNames:accesses.persname*.text().collect{return new LanguagedValue(value:it)},
			subjects:accesses.subject*.text().collect{
				return new LanguagedValue(value:it)}
			)
		}
		eadC.setControlAccesses(accessList)

		//landing page:
		def EadDaoLoc landingPage = new EadDaoLoc(label:'landing_page', href:currentC.prefercite?.p?.text().replaceAll("&", "&amp;"))
		eadC.setLandingPage(landingPage)
	}

	def getLanguages = { Node cNode ->
		def langs = cNode.did.langmaterial*.language*.'@langcode'
		if(langs.isEmpty()) return [
				new Language(code:"fre", text:'FRE')
			]
		else
			return langs.collect{new Language(code:it.text().toUpperCase(), text:it.text().toUpperCase() )}
	}


	def generateDid = {Node cElement, Node archDescElement, String repoId ->

		def List<Language> languages = getLanguages(cElement)
		def String title = cElement.did.unittitle?.text()
		if(!title) title = cElement.did.unittitle?.unitdate?.text()

		def String date1 = cElement.did.unitdate?.'@normal'
		def String date2 = cElement.did.unittitle?.unitdate?.'@normal'
		def String date3 = cElement.did.unittitle?.imprint?.date?.'@normal'
		def String theDate = ''
		if(!date1 && !date2) theDate= date3
		else{
			if(!date2 && !date3) theDate = date1
			else if(!date1 && !date3) theDate = date2
		}

		def Node physNode = cElement.did.physdesc[0]
		def EadPhysDesc physDesc = new EadPhysDesc(extents:physNode?.extent*.text().collect{ return new LanguagedValue(value:it)},
		genreforms:archDescElement.did.physdesc?.genreform*.text().collect{
			return new LanguagedValue(value:it)}
		)

		def EadOrigination origination = new EadOrigination(
				persnames:cElement.controlaccess?.persname*.text().collect{return new LanguagedValue(value:it)},
				corpnames:cElement.did.origination?.name*.text().collect{
					return new LanguagedValue(value:it)}
				)

		def List<String> oddsItem = cElement.odd.list.item*.text()
		def List<String> oddsPars = cElement.odd.p*.text()
		def odds = [
			oddsItem.join(' '),
			oddsPars.join(' ')
		]

		def eadDid = new EadDid(callNumber:cElement.did.unitid?.text(), localId:cElement.@id,
				langmaterials:languages,
				unitdates:[
					new EadDate(normal:theDate, value:theDate)
				],
				repository:"Maison des Sciences de l'Homme de Dijon" ,
				originations:[origination],
				physicalDescriptions:[physDesc],
				unittitles:[
					new UnitTitle(title:title)]
				)
		if(!odds.isEmpty()) eadDid.setOdds([
			new LanguagedValue(value:odds.join(' // '))
		])
		return eadDid;
	}
}