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

class MSHUtilsGeme {

	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 titleStm = xmlRoot.'**'.filedesc?.titlestmt
		def String altTitle = "";
		def subTitle = titleStm?.subtitle?.text()
		if(subTitle) altTitle += subTitle+" "
		def titleProper = titleStm?.titleproper?.text()
		if(titleProper) altTitle += titleProper

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

		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]?.toUpperCase()
		def String defaultEuropeanaRights = europeanaRights?.toUpperCase()

		def scopeContent = archDescNode.scopecontent.p*.text().join(" ")
		def bioghist =  archDescNode.bioghist.p*.text().join(' ')

		def EadArchDesc eadArchDesc = new EadArchDesc(level:'collection',
				landingPage:collectionLandingPage, thumbnail:collectionThumbnail, did:collectionDid,
				temporalCoverages:[
					archDescNode.did.unitdate.'@normal'[0]
				],
				spatialCoverages:[],
				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:[],
				userrestrictPars:[
					new LanguagedValue(value:userRes)
				],

				accessrestrictPars:archDescNode.accessrestrict.legalstatus*.text().collect{
					return 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, true)
			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 ->

		def String euroRights = currentC.accessrestrict.legalstatus.'@type'[0]
		if(!euroRights) euroRights = defaultEuroRights
		eadC.setEuropeanaType('TEXT')
		eadC.setEuropeanaRights(euroRights)

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

		def acqPars = archDescNode.acqinfo.p*.text().collect{return new LanguagedValue(value:it)}
		eadC.setAcquinfoPars(acqPars)

		def oddList = currentC.odd.collect{return it.head?.text()+" "+it.p?.text()}
		def scopes = oddList.join(' // ')

		def scopeContentPars = [
			new LanguagedValue(value:scopes)
			//			new LanguagedValue(value:currentC.odd?.findAll{it.'@type'.equals('remarquestitrefrancais')}.p*.text().join(' // ')),
			//			new LanguagedValue(value:currentC.odd?.findAll{it.'@type'.equals('remarquestraduction')}.p*.text().join(' // ')),
			//			new LanguagedValue(value:currentC.odd?.findAll{it.'@type'.equals('remarquesedition')}.p*.text().join(' // ')),
			//			new LanguagedValue(value:currentC.odd?.findAll{it.'@type'.equals('textessupplementaires')}.p*.text().join(' // ')),
			//			new LanguagedValue(value:currentC.odd?.findAll{it.'@type'.equals('appareilcritique')}.p*.text().join(' // ')),
			//			new LanguagedValue(value:currentC.odd?.findAll{it.'@type'.equals('contexte')}.p*.text().join(' // '))
		]
		eadC.setScopecontentPars(scopeContentPars)


		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)

		eadC.setOriginalsLocs(currentC.originalsloc*.text().collect{return new LanguagedValue(value:it)})

		def imprintNode = currentC.bibliography.bibref.imprint
		def ville = imprintNode?.geogname?.find{it.'@role'.equals('VilleEdition')}
		//		println "ville == "+ville
		//		println "ville.value().toString() == "+ville?.value()?.toString()
		//		println "ville.text() == "+ville?.text()
		def imprint1 = ville?.text()
		def imprint2 = imprintNode?.publisher[0]?.text()
		def imprint3 = imprintNode?.date?.find{it.'@type'.equals('DateEditionFrancaise')}?.text()

		def String biblio = imprint1
		if(imprint1) biblio += " : "
		biblio += imprint2
		if(imprint2) biblio += ", "
		biblio += imprint3
		if(imprint3) biblio += "."
		eadC.setBibliographies([
			new LanguagedValue(value:biblio)
		])
		//println biblio

		def accesses = currentC.controlaccess
		def List<EadControlAccess> accessList = accesses.collect{
			return new EadControlAccess(
			persNames:currentC.bibliography.bibref.persname.'@normal'.collect{return new LanguagedValue(value:it)},
			corpNames: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, boolean useDefaultIfNone ->
		def langs = cNode.did.langmaterial*.language*.'@langcode'
		if(langs.isEmpty() && useDefaultIfNone) 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 titleNode = cElement.bibliography?.bibref?.title.find{it.'@type'.equals('titrepropre')}
		def String title = titleNode?.text()
		def String titleDate = cElement.bibliography?.bibref?.imprint?.date?.find{it.'@type'.equals('DateEditionFrancaise')}?.'@normal'
		if(!titleDate) titleDate = cElement.bibliography?.bibref?.imprint?.date?.find{it.'@type'.equals('DateEditionEtrangere')}?.'@normal'
		def numNodes = cElement.bibliography?.bibref?.num
		def collation = numNodes?.find{it.'@type'.equals('collation')}?.text()
		def format = numNodes?.find{it.'@type'.equals('format')}?.text()
		def EadPhysDesc physDesc = new EadPhysDesc(
				extents:[
					new LanguagedValue(value:collation +" // "+format)
				],
				genreforms:archDescElement.did.physdesc?.genreform*.text().collect{
					return new LanguagedValue(value:it)}
				)

		def EadOrigination origination = new EadOrigination(
				persnames:cElement.bibliography?.bibref?.persname.'@normal'.collect{return new LanguagedValue(value:it)},
				)

		def eadDid = new EadDid(callNumber:cElement.did.unitid?.text(), localId:cElement.@id,
				langmaterials:[
					new Language(code:"fra", text:'fra')
				],
				unitdates:[
					new EadDate(normal:titleDate, value:titleDate)
				],
				repository:dataProvider ,
				originations:[origination],
				physicalDescriptions:[physDesc],
				unittitles:[
					new UnitTitle(title:title)
				]
				)

		return eadDid;
	}
}