//by @xeviff
/* HARDCODED */
def relocation = false
def relocationFrom=null
def skipAudioCheck = true
/*************/

/** RUTAS **/
def root = '/pelis/'
def ruta2000 = root+"Pelis/plain/"
def ruta = ruta2000
def ruta_docu = root+"Documentales/plain/"
def ruta_anime = root+"Pelis_anime/"
def ruta_animacion = root+"Pelis_animacion/"
def ruta_infantil = root+"Pelis_infantiles/"
def ruta_familiar = root+"Pelis_familiar/"
def ruta_esp = root+"Pelis_esp/plain/"
def ruta_latina = root+"Pelis_lat/"
def ruta_cat = root+"Pelis_cat/"
def ruta_retro = root+"Pelis_retro/plain/"
def ruta_estrenos = root+"Pelis_estrenos/plain/"
def ruta_classic = root+"Pelis_classic/"
def ruta_asiaticas = root+"Pelis_asiaticas/"
def rutaKO = root+"error/"
/**********/


try { //empieza el script

	/** Tipo de archivo incorrecto **/
	if (ext==~/jpg|nfo|png|url/) {
		return fn
	}
	else if (ext!="mkv" && ext!="avi" && ext!="mp4") {
		throw new Exception("[formato_fichero_noestarndar]")
	}
	
	try {
		video
	} catch (e) {
		throw new Exception("[video_roto]")
	}
	try {
		genres
	} catch (err) {
		throw new Exception("[genero_no_especificado]")
	}
	
	//*** Relocate Remux and UHD to Transcode input folder
	def peso = bytes.toString().before(' ').toDouble()
	def numericBps = (mbps.toString().before(' ').toDouble()*1000000).round()
	def es1080 = vf ==~ '1080.'
	def es1080Remux = peso > 15 && numericBps >= 18000000
	if (!relocation && (vf ==~ '2160.' || (es1080 && es1080Remux))) return root+"/to Transcode/"+fn

	/* otras validaciones */
	if (relocation && !sanityCheck(tmdbid)) return '@@@@@@ Names Sanity Check KO @@@@@@@ --> New name: '+localize.Spanish.n+' with tmdb='+tmdbid
	
	return 'hi'
	/********************************/

	/** Codec Vídeo: en nombre fichero **/
	def codecVideo = (any{vc}{0} =~ /HEVC|265|ATEME/ ) ? 'HEVC' :
	    			 (any{vc}{0} =~ /264/) ? 'AVC' : vc
	/**************/

	/******* Calidad ******/
	def calidad = 
		(vf =~ '2160.') ? //4K
			(peso > 30 && numericBps >= 26000000)
				? "UHDRemux"
				: (peso > 15) 
					? "UHDRip"
					: "microUHD"
		: es1080 ? //1080
			es1080Remux
				? vf+" BDRemux"
				: (numericBps > 8000000)
					? vf
					: "microHD"
		: vf
	def fuente = {try{ source } catch(err){null}}()
	if (fuente!=null) calidad = calidad.startsWith("micro") ? calidad : vf 

	/***************************/
	/** Formato distribución **/
	formato_distribucion = fuente!=null ? fuente : relocation ? '' :
		fn=~/(?i)\bblu.?ray\b|\bbdrip\b/ ? (calidad=~/(?i).+rip/ ? '' : 'BDRip') :
		fn=~/(?i)remux/ ? (calidad=~/(?i).+remux/ ? '' : 'BDRemux') :
		fn=~/(?i)\bWEB.??(DL|RIP)\b/ ? 'WEB-DL' :
		''
	if (formato_distribucion=='WEB-DL') {
		def plataforma = fn.find( //coge el contenido que encaja
			/(?i)\bAMZN?\b|\bNF\b|\bHBO\b|\bHBO.?MAX\b|\bHMAX\b|\bHULU\b|\bA3P\b|\bDPLY\b|\bSTARZ\b|\bFILMIN\b|\bFLMN\b|\bNETFLIX\b|\bDSN.?\b|\bDSP+?\b|\bRTVE\b|\bFLIXOL.\b|\bM\+\b/ )
		if (plataforma!=null) plataforma = plataforma.replace("MVPLUS","MV+")
		formato_distribucion = formato_distribucion+(plataforma!=null?(' '+plataforma.toUpperCase()):'')
	}
	if (formato_distribucion!='') formato_distribucion=' '+formato_distribucion
	/**********************************/	

	/**** HDR ********/
	def hdr_info=''
	try{
		def mHDRCol = ["BT.709" : "NO", "BT.2020" : "YES"]
		def _HDRMap = ["HDR10": "HDR10", "SMPTE ST 2086": "HDR10", "SMPTE ST 2094 App 4": "HDR10+", "Dolby Vision / SMPTE ST 2086": "Dolby Vision", "Dolby Vision / HDR10": "Dolby Vision",]
		def vid = video.first()
		String _HDR
		switch (bitdepth) {
			case { it > 8 }:
				_HDR = any
					{ vid["HDR_Format_Commercial"] }
					{ vid["HDR_Format"] }
					{ hdr }
					{ null }
				break
			default:
				"$bitdepth-bit"
			break
		}
		hdr_info = _HDRMap.find { k, v -> k =~ _HDR }?.value
		if (hdr_info!=null) hdr_info=' '+hdr_info
		else hdr_info=''
	} catch (err) {}
	/*****************/

	/**** Profundidad vídeo ****/
	def myBitrate = 'noBRdef'
	try{ myBitrate = mbps.replace(/.0/,'').replace(' Mbps','M') }catch(err){}
	def myFps = ' FRvar'
	try { myFps = ' '+fps.replace(/.0/,'').replace(' fps','f') }catch(err){}
	/***************************/

	/* BLOQUE VIDEO */
	def bloqueCalidadVideo = calidad + formato_distribucion
	def bloqueDescVideo = myBitrate + myFps + hdr_info
	def bloqueVideo = ' ['+codecVideo+' '+bloqueCalidadVideo+' '+bloqueDescVideo+']'
	/**********************************************************************************************************/

	/** AUDIO (ejecución) **/
	def bloqueAudio=''
	def audiosMap = [:]
	for (aud in audio) {
		def shortDesc = aud.Language_String3 !=null ? aud.Language_String3 
        	: aud.Title!=null ? (aud.Title=~/(?i).+spa.+/?'spa': aud.Title.substring(0,3).toLowerCase()) : 'und' 
		if (aud.Title!=null && aud.Title=~/(?i).*latin.*/) shortDesc='lat'
		audiosMap[shortDesc] = audiosMap[shortDesc] ?: [:]
		audiosMap[shortDesc][aud.Format] = audiosMap[shortDesc][aud.Format] ?: []
		audiosMap[shortDesc][aud.Format] << aud
	}
	def groupedAudiosMap = [:]
	for (audioElms in audiosMap) {
		def k = audioElms.key
		def v = audioElms.value
		if (!k.contains('+') && countAudiosInMap(v)>1) k += '+'
		def mQ = getMaxQuality(v)
		def mQstr = (mQ==null || mQ.isEmpty()) ? 'und' : printAudio(mQ)
		if (groupedAudiosMap.containsKey(mQstr)) groupedAudiosMap[mQstr].add(k)
		else groupedAudiosMap[mQstr] = [k]
	}
	audiosMap=null
	def temp=''
	for (audioGroup in groupedAudiosMap) {
		def k = audioGroup.key
		def v = audioGroup.value
		def gS = v.size()
		def str=''
		for (int i=0; i<gS; i++) {
			str += (v[i]!=null?v[i]:'und') +', '
			if (i==gS-1) {
				str = removeLastComa(str)+' '
				str += k+', '
			}
		}
		bloqueAudio += str
	}
	groupedAudiosMap=null
	bloqueAudio = '['+removeLastComa(bloqueAudio)+']'


	/***** subtitulos *******/
	def bloqueSubs
	try {
		def capturedSubs = [:]
		bloqueSubs = '['
		for (int s; s<text.size(); s++){ 
			if (text[s]==null || s>10) break; 
			handleSub(text[s], capturedSubs); 
		}
		def keysList = capturedSubs.keySet().toList()
        for (index in 0..< keysList.size()) {
            if (index>3){ bloqueSubs+='etc  '; break; }
            bloqueSubs += capturedSubs.get(keysList[index]).replace('null','und').replace(" F+","+F").replace("+ F","+F") + ', '
        }
		bloqueSubs = removeLastComa(bloqueSubs)+']'
	}catch(err){bloqueSubs=''}
	/************************/


	/*************************************************************************************************************/
	/****  Carpeta / tipo contenido ******************************************************************************/
	/*************************************************************************************************************/

	//inits
	def tipoYaSeteado=false
	def prodCountries=info.ProductionCountries
	def certifications=info.Certifications
	def numPaises = prodCountries.size()
	def llengu = {try {def langs=[]; for (lan in languages) langs.add(lan.toString()); return langs } catch(err) {[]}}()
	//def audioLlengu = {try {def langs=[]; for (lan in audioLanguages) langs.add(lan.toString()); return langs } catch(err) {[]}}()

	//animacion (no concluyente)
	def tieneAnimacion = genres.any{ it =~ /Anima.i.n/}
	//familiar (no conclud)
	def tieneFamiliar = genres.any{ it =~ /Familia|Family/}
	//docu
	def esDocu = genres.any{ it =~ /Documental|Documentary|Reality/} && !(localize.English.n =~ /Jackass/)
	//Anime ---------- (Animacion encara no es pot perquè depen del infantil)
	def esAnime = false
	if (tieneAnimacion && prodCountries.contains("JP") && (!llengu.isEmpty() ? llengu.contains('jpn') : true)) {
		esAnime = (numPaises==1 || anime || country=="JP") 
		&& ["nemo"].any{!localize.English.n.toLowerCase().contains(it)}
	}
	tipoYaSeteado = esDocu || esAnime

	//***** familiar vs infantil ****
	def esFamiliar = tieneFamiliar
	def	infantil = false

	if (!tipoYaSeteado) {
		def tieneCertificacion = certifications!=null && certifications.size()!=0

		if (tieneFamiliar && tieneAnimacion) {
			def noTanInfantil = certifications.US ==~/PG-13/ && certifications.ES!="7"
			if (!noTanInfantil) infantil = true
		}
		else if (tieneAnimacion) {
			if (tieneCertificacion) {
					infantil = certifications.US=="G"
						|| certifications.ES==~/Ai|APTA/
						|| certifications.DE==~/0/
						|| certifications.IT=="T" 
						|| certifications.IE=="G" 
						|| certifications.LT=="V" || certifications.RU ==~ /6.+/
						|| certifications.BR=="L"
						|| certifications.NO=="A"
						|| certifications.FR=="U"
			} else {
				def titulosInfantiles = ['boonie bears', 'the jungle bunch']
				if (titulosInfantiles.any { localize.English.n.toLowerCase().contains(it) })
					infantil = true
			}
		} else if (!esFamiliar) {
			if (tieneCertificacion && (
				 certifications.US=="G"
				)) {
				esFamiliar = true //posem a familiar pelis de nens que no son animacio
			}
		}
		tipoYaSeteado = tipoYaSeteado || esFamiliar || infantil
	}

	//animacion
	def esAnimacion = tieneAnimacion && !infantil
	tipoYaSeteado = tipoYaSeteado || esAnimacion

	//***  española ***
	def espanyola = false
	def catalana = false
	if (!tipoYaSeteado && prodCountries.contains("ES")) {
		espanyola=
				(numPaises==1 || (numPaises==2 && prodCountries.any{ it=~/AR|PT/ }))
			||	{ try { info.Network =~ /(?i)\bFLIXOL.\b|\b.?TVE\b/ } catch (e) { false } }()
			||	({ try { info.ProductionCompanies.any{it =~ /.?TVE|ESDIP|Canal Sur|Canal\+|Telecinco/}}catch(e){false}}() && llengu.size()==1?llengu[0]=="spa":false)
			||	(info.Certifications.size()==1 && info.Certifications.ES!=null) 
			||	llengu.size()==1 && llengu[0]=="spa"
			||	(movie.alternativeTitles.size()==1 && movie.alternativeTitles.ES!=null)
			||	(country=="ES" && (!llengu.isEmpty() ? llengu.size()==1 && llengu[0]!="eng" : true))
		if (espanyola) catalana = llengu.contains('cat')
		tipoYaSeteado = tipoYaSeteado || espanyola
	}

	//asiaticas
	def asiatica = false
	if (!tipoYaSeteado) {
		def paisesAsiaticos = ["CN", "HK", "JP", "KP", "KR", "TH", "NP", "TW", "PH", "MO"]
		def paisesIntersec=0
		def languajAsia = ["zho", "kor", "thai", "vie", "jpn", "ind"]
		asiatica = languajAsia.intersect(llengu).size() == languajAsia.size()
				|| paisesAsiaticos.any{ country==it }
				|| (numPaises != 0 && {((paisesIntersec=paisesAsiaticos.intersect(prodCountries).size()) == numPaises || (/*en observacion*/paisesIntersec!=0 && !llengu.contains('eng')) ) }())
				|| (languajAsia.any{bloqueAudio.contains(it)} && prodCountries.any{paisesAsiaticos.contains(it)} && llengu.any{languajAsia.contains(it)} )
				|| {try {director.contains("Takeshi Kitano")} catch (e) {false}}()
			
		tipoYaSeteado = tipoYaSeteado || asiatica
	}

	//***  latina ***
	def latina = false
	if (!tipoYaSeteado) {
		def paisesLatinos = ["MX", "AR"]
		latina = {try {paisesLatinos.contains(country)} catch (e) {false}}()
			    || (numPaises != 0 && paisesLatinos.intersect(prodCountries).size() == numPaises)
                || info.productionCompanies.any{it=~/Corazón Films/}
	}

	//////////////////////////////////////////////
		//tria
	if (esDocu) ruta = ruta_docu
	else if (esAnime) ruta = ruta_anime
	else if (infantil) ruta = ruta_infantil
	else if (esAnimacion) ruta = ruta_animacion
	else if (catalana) ruta = ruta_cat
	else if (espanyola) ruta = ruta_esp
	else if (latina) ruta = ruta_latina
	else if (asiatica) ruta = ruta_asiaticas
	else if (esFamiliar) ruta = ruta_familiar
	else if (y<1980) ruta = ruta_classic
	else if (y<2000) ruta = ruta_retro
	if (ruta==ruta2000 && y>=2021) ruta = ruta_estrenos
	/********************************************/
	//Relocation possible failures
	if (relocation && relocationFrom!=null) {
		if (!ruta.contains(relocationFrom)) {
			ruta = relocationFrom + "to_observe/"
		}
	}
	//**//

	/*** RESULTADO FINAL ***/
	def nombrePelicula_formatoPlex =  {try { catalana ? localize.Catalan.n : localize.Spanish.plex.name } catch (err) {localize.Spanish.plex.name} }()
	def inicial = (ruta==ruta2000 || ruta==ruta_retro) ? getInicial() : ''
	def tmdb = "{tmdb-"+tmdbid+"}"
	def carpetaPeli = localize.Spanish.plex.name + ' ' + tmdb + '/'
	def nomPrincipal = nombrePelicula_formatoPlex + bloqueVideo + bloqueAudio + bloqueSubs
	def trackerCatch = fn.find(/(?i)\bHDO(limpo)?\b|\bRedBits\b/)
	def tracker = trackerCatch != null ? '['+trackerCatch.replace("HDOlimpo", "HDO")+']' : ''

	return ruta + inicial + carpetaPeli + nomPrincipal + tracker + tmdb
///////////////////////////////////////////////////////////////////////////
} catch (err) {	
	def msgErr = err.getMessage()

	String str= err.getStackTrace().toString()
	def pattern = ( str =~ /groovy.(\d+)./   )
	return " Error at line number = " + pattern[0][1] + ". more: "+msgErr

	def rutaMotivoErr
	
	if (msgErr=="[formato_fichero_noestarndar]" || msgErr=="[video_roto]")
		rutaMotivoErr="/fichero/"
	else if (msgErr=="[genero_no_especificado]" || msgErr=="[certificado_edad_no_especificado]") {
		rutaMotivoErr="/themoviedb/"
	} else if (msgErr.startsWith("[idioma_audio")) {
		rutaMotivoErr="/audio/"
	} else {
		def errSplitted = msgErr.split("\\-")
		return msgErr
		if (errSplitted==null) {
			rutaMotivoErr="/error_desconocido/"
		} else  {
			def errType = errSplitted[0]
			if (errType=="[formato_audio_no_encontrado")
				rutaMotivoErr="/audio/"
			else if (errType.startsWith("[idioma_audio"))
				rutaMotivoErr="/idioma/"
			else {
				String str2= err.getStackTrace().toString()
				def pattern2 = ( str2 =~ /groovy.(\d+)./   )
				return " Error at line number = " + pattern2[0][1]
			}
		}
	}
	
	def resultado = rutaKO + rutaMotivoErr + msgErr + '/' + localize.English.plex.name + '/' + fn
	
	return resultado
}



/********************************************************/
/********************************************************/
/************** FUNCIONES *******************************/
/********************************************************/
/********************************************************/


/********* AUDIO *****************/
def removeLastComa(txt) {
    return txt.substring(0, txt.size()-2)
}
def getMaxQuality (mapAudioIndexedByFormat) { 
    def formatSet = ["PCM", "MLP FBA" ,"DTS", "FLAC", "AC-3", "E-AC-3", "EAC3", "AAC", "MPEG Audio", "MP3"]
	for (cFormat in formatSet) {
        if (mapAudioIndexedByFormat.containsKey(cFormat)){
            def difChannelsList = mapAudioIndexedByFormat[cFormat]
            return difChannelsList.size()==1 ? difChannelsList[0] : getBestChannelFromList(difChannelsList)
        }
	}
    return null
}
def printAudio (audio2Print) {
	def format = audio2Print.Format
    def fCom = audio2Print.Format_Commercial
	switch (format) {
		case "AC-3"	-> fCom = "DD"
		case "E-AC-3" -> fCom = "DD+"
		case "MPEG Audio" -> fCom = "MPEG"
		case "DTS" -> { if (fCom.contains("Master Audio")) fCom="DTS_MA"
                        else if (fCom.contains("DTS-HD High Resolution Audio")) fCom="DTS_HRA"
						else if (fCom.contains("DTS-ES")) fCom="DTS-ES"
					}
        case "MLP FBA" -> {def tmp = "D_HD"; if (fCom.contains("Atmos")) tmp+="_Atmos"; fCom = tmp}
	}
	def canales = audio2Print.Channels.replace(2:'2.0', 6:'5.1', 7:'6.1', 8:'7.1')
	return fCom + ' ' + canales
}
def getBestChannelFromList (audiosFormatFound) {
	def bestChanel
	def currentValue=0
	for (myAudio2 in audiosFormatFound) {
		if (myAudio2.Channels>currentValue) {
			currentValue = myAudio2.Channels
			bestChanel = myAudio2
		}
	}
	return bestChanel
}
def countAudiosInMap(audMap){
    int count=0
    for (aud in audMap) count += aud.value.size()
    return count
}
/********* SUBS ***************/
def handleSub(sub, capturedSubs) {
	def lang = sub.Language_String3 !=null ? sub.Language_String3 
		: (sub.Title=~/(?i).+spa.+/?'spa': sub.Title.substring(0,3).toLowerCase())
	if (sub.Title!=null && sub.Title=~/(?i).*latin.*/) lang='lat'
	def forced = sub.title!=null ? sub.title.toLowerCase().contains("forzado") : false
	if (!capturedSubs.containsKey(lang)) {
		capturedSubs[lang] = lang+(forced?' F':'') 
	} else {
		def existing=capturedSubs[lang]
		def newTxt=''+existing
		if (!existing.contains('+')) newTxt += '+'
		if (forced && !existing.contains('F')) newTxt += ' F'
		capturedSubs[lang]=newTxt
	}
}

/***********/
/* otras funciones */
def getInicial () {
	def nomIngles = localize.English.n
	if (nomIngles.startsWith("The ") || nomIngles.startsWith("A "))
		nomIngles = nomIngles.replaceFirst("The ",'').replaceFirst("A ",'')
	def ini0 = nomIngles[0].toUpperCase()
	def iniClear = nomIngles.size()>1 ? ini0.replaceAll(/[¡¿'#*\(]/,nomIngles[1].toUpperCase()) : ini0
	def inicial = iniClear.replaceAll(/[0-9]/,'#')+'/'
	return inicial
}
def sanityCheck(newId) {
	def oldId = fn.find(/\{tmdb-\d+\}/)?.find(/\d+/)
	return oldId!=null ? oldId  == newId.toString() : true
}
/***********/
