package scripts.warner

import com.google.common.base.Stopwatch
import com.google.common.collect.Lists
import com.google.common.collect.Sets
import com.zina.console.export.FingerprintUtil
import com.zina.console.export.ImportUtil
import com.zina.console.export.UnbendedFingerprintUtil
import com.zina.domain.*
import com.zina.domain.album.Album
import com.zina.domain.album.AlbumItem
import com.zina.domain.artist.Artist
import com.zina.domain.dao.ArtistDao
import com.zina.domain.dao.AudioTrackDao
import com.zina.domain.dao.ProtectedAudioTrackDao
import com.zina.domain.dao.CopyrightDao
import com.zina.domain.dao.ProtectedCopyrightDao
import com.zina.domain.dao.PersonDao
import com.zina.domain.dao.TagDao
import com.zina.domain.dao.album.AlbumDao
import com.zina.domain.dao.album.AlbumItemDao
import com.zina.domain.dao.rightpossessor.RightPossessorDao
import com.zina.fingerprint.HashShift
import com.zina.fprocessing.domain.Entry
import com.zina.fprocessing.domain.EntryAddress
import com.zina.fprocessing.worker.IAudioEncodeWorker
import com.zina.fprocessing.worker.exception.WorkerError
import com.zina.fprocessing.worker.local.*
import com.zina.service.CopyrightService
import com.zina.service.artist.ArtistService
import com.zina.service.audiotrack.AudioTrackService
import com.zina.service.audiotrack.AudioTrackUnionService
import com.zina.service.fileRestriction.FileRestrictionAddRuleBean
import com.zina.service.fileRestriction.FileRestrictionService
import com.zina.service.mail.MailService
import com.zina.service.warner.WarnerFileRestrictionService
import com.zina.util.DKeyGenerationUtil
import com.zina.util.EntryAddressUtil
import com.zina.util.StringUtil
import com.zina.warner.FillWarnerMetaDB
import com.zina.warner.WarnerModelBeanMapper
import com.zina.warner.connector.SSHConnector
import com.zina.warner.historian.Historian
import com.zina.warner.marshall.WarnerModelBean
import groovy.sql.Sql
import net.schmizz.sshj.sftp.SFTPClient
import org.apache.ibatis.session.SqlSession
import org.apache.ibatis.session.SqlSessionFactory
import org.apache.ibatis.session.SqlSessionFactoryBuilder
import org.codehaus.jackson.map.ObjectMapper
import org.mapdb.DBMaker
import org.springframework.orm.jpa.EntityManagerHolder
import org.springframework.transaction.support.TransactionCallback
import org.springframework.transaction.support.TransactionSynchronizationManager
import org.springframework.transaction.support.TransactionTemplate

import java.io.File
import java.sql.Time
import java.text.SimpleDateFormat
import static com.google.common.base.Strings.isNullOrEmpty
import static com.zina.fingerprint.util.TransformUtil.sortCodes
import static com.zina.fingerprint.util.TransformUtil.splitCodes
import static java.util.concurrent.TimeUnit.SECONDS

/**
 * User: vad
 * Date: 3/31/15
 * импорт каталога от WB. Без использования ранее сохранённой метаинформации
 *
 * бывший directLoad2MogileRetry2.groovy
 *
 */

version = "0.2.11.2015.12.23"
println "start {$version} at " + new SimpleDateFormat("yyyy.MM.dd HH:mm:ss").format(new Date())
sqlM = Sql.newInstance("jdbc:mysql://95.183.15.191:3306/zaycev_new", "zaycev_net", "BNdS3D7g", "com.mysql.jdbc.Driver")
println args
// ---------------------------------------------------------------------------------------------------------------------
processMatching = true
processToFtp = true

//DELIMITER = "\t"
RESOURCES = "resources"
SUFFIX = ".dfugv"
FP = "fp"
ORIGINAL_TRACK_POSTFIX = ".otmbm";

DEFAULT_SHARE = 200.0f
RP_ID = 8919L

SIZE_LIMIT = 100000

NAME_LIMIT = 255 - 3

FORBIDDEN_GENRES = ["Spoken Word"]

// ---------------------------------------------------------------------------------------------------------------------
workDir = System.getProperty("user.home") + "/zina/warner-retry2/catalog"
workerDir = workDir + "/worker"
workerStoreDir = workDir + "/tmp"
workMp3Dir = workDir + "/mp3"

(new File(workDir)).mkdirs()
(new File(workerDir)).mkdirs()
(new File(workerStoreDir)).mkdirs()
(new File(workMp3Dir)).mkdirs()

emf = ctx.getBean("entityManagerFactory")
em = emf.createEntityManager()
TransactionSynchronizationManager.bindResource(emf, new EntityManagerHolder(em))

withTx = { TransactionTemplate txt, Closure c ->
	return txt.execute(c as TransactionCallback)
}

warnerFileRestrictionService = ctx.getBean(WarnerFileRestrictionService)
fileRestrictionService = ctx.getBean(FileRestrictionService)
rightPossessorDao = ctx.getBean(RightPossessorDao)
audioTrackDao = ctx.getBean(AudioTrackDao)
protectedAudioTrackDao = ctx.getBean(ProtectedAudioTrackDao)
audioTrackQueryService = ctx.getBean("audioTrackQueryService")
artistDao = ctx.getBean(ArtistDao)
artistService = ctx.getBean(ArtistService)
audioTrackService = ctx.getBean(AudioTrackService)
audioTrackUnionService = ctx.getBean(AudioTrackUnionService)
copyrightDao = ctx.getBean(CopyrightDao)
protectedCopyrightDao = ctx.getBean(ProtectedCopyrightDao)
albumDao = ctx.getBean(AlbumDao)
albumItemDao = ctx.getBean(AlbumItemDao)
entryAddressUtil = ctx.getBean(EntryAddressUtil)
tagDao = ctx.getBean(TagDao)
mailService = ctx.getBean(MailService)
idDesc = Long.valueOf(2000000000000L)
personDao = ctx.getBean(PersonDao)
сopyrightService = ctx.getBean(CopyrightService)
//idDesc = Long.valueOf(propertiesUtil.getProperty("global.idDesc.futureDate"))

// ---------------------------------------------------------------------------------------------------------------------
final sdp = new SimpleDateFormat("yyyy.MM.dd_HH:mm:ss")
final sdf = new SimpleDateFormat("yyyy.MM.dd.HH.mm.ss")
final logFileName = workDir + "/${sdf.format(new Date())}.log"
final logFile = new File(logFileName)
log = { msg ->
	println msg
	logFile.append("${sdp.format(new Date())}: ${msg}\n")
}

final eventFreq = [done:0, alreadyProcessedFail:0, emptyFileNameFail:0, emptyArtistNameFail:0, emptyTrackNameFail:0, copyrightsAlreadyExistFail:0, downloadFail:0, sizeLimitFail: 0, forbiddenGenre: 0]
incrementEvent = { eventName ->
	def curFreq = eventFreq.get(eventName)
	curFreq++
	eventFreq.put(eventName, curFreq)
}

// ---------------------------------------------------------------------------------------------------------------------
sftpHost = "bak5.serv"
sftpPort = 22
sftpUser = "interakt"
sftpPrivateKeyPath = System.getProperty("user.home") + "/.ssh/id_dsa"
historianStorePath = workDir + "/historian"

// ---------------------------------------------------------------------------------------------------------------------
InputStream inputStream = FillWarnerMetaDB.class.getClass().getResourceAsStream("/mybatis-config.xml")
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
modelBeanMapper = sqlSession.getMapper(WarnerModelBeanMapper.class);

println "В modelBeanMapper ${modelBeanMapper.count()} записей"
println "В modelBeanMapper ${modelBeanMapper.countIsrc()} уникальных isrc"

copyrightCatIdSet = DBMaker.newTempHashSet()
rightCatIdSet = DBMaker.newTempTreeSet()
absentCatIdSet = Sets.newHashSet()

packageDirSet = Sets.newHashSet()
// ---------------------------------------------------------------------------------------------------------------------
codegenPath = System.getProperty("user.home") + "/bin/echoprint-codegen"

om = new ObjectMapper()

inputDirPath = "warner"

// ---------------------------------------------------------------------------------------------------------------------
stopwatch = new Stopwatch().start()

count = 0

RightPossessor rightPossessor = rightPossessorDao.find(RP_ID)
if (rightPossessor == null) {
	println "не найден ПО ${RP_ID}"
	System.exit(0)
}

Person person = personDao.find(10902590L)

if (person == null) {
	println "не найден Пользователь для ${RP_ID}"
	System.exit(0)
}

historian = new Historian(historianStorePath)
println "already pass ${historian.okSet.size()} row"

sshConnector = new SSHConnector(sftpHost, sftpPort, sftpUser, sftpPrivateKeyPath);
client = sshConnector.getClient()
try {
	absentCatIdSet = ImportUtil.buildAbsentCatId(em, modelBeanMapper)
	packageDirSet = ImportUtil.buildPackageDirList(client, inputDirPath)
	process(rightPossessor, person)
} catch (Throwable t) {
	log("Some crazy exception occurred, can not continue process: " + t.getLocalizedMessage())
	t.printStackTrace()
}
def message =
		"Обработано: ${eventFreq.get("done")},\n" +
//                "Не обработано ${eventFreq.values().sum()} :" +
				"уже обрабатывались: ${eventFreq.get("alreadyProcessedFail")},\n" +
				"пустое имя файла: ${eventFreq.get("emptyFileNameFail")},\n" +
				"пустое поле имени артиста: ${eventFreq.get("emptyArtistNameFail")},\n" +
				"пустое поле названия трека: ${eventFreq.get("emptyTrackNameFail")},\n" +
				"копирайты уже проставлены: ${eventFreq.get("copyrightsAlreadyExistFail")}," +
				"ошибка скачки файла: ${eventFreq.get("downloadFail")},\n" +
				"размер файла меньше лимита: ${eventFreq.get("sizeLimitFail")},\n" +
				"содержит запрещённый жанр: ${eventFreq.get("forbiddenGenre")}"
mailFromAddress = "report-generator@zaycev.net"
mailToAddress = "zina-warn@mailman.z-inc.net"
subject="Отчет по импорту Warner"
mailService.sendTextMessage(mailFromAddress, subject, mailToAddress, message)

println "Done " + stopwatch.elapsedTime(SECONDS) + "s"
System.exit(0)

// ---------------------------------------------------------------------------------------------------------------------
def process(RightPossessor rightPossessor, Person person) {
	for (String catId : absentCatIdSet) {
		println "## catId: " + catId

		List<WarnerModelBean> restock = modelBeanMapper.findByIsrc(catId)

		def found = false

		for (int i = 0; i <= restock.size() - 1; i++) {
			// с начала
			WarnerModelBean modelBean = restock.get(i)
			def releaseDate = modelBean.getReleaseDisplayStartDate()
			def now = new Date()
			if (releaseDate == null || releaseDate.before(now)) { // если дата релиза в прошлом, то импортируем
				if (!found && modelBean.trackPath != null && modelBean.trackPath.contains("mp3") && packageExist(modelBean.src)) {
					found = true
					withTx(txTemplate, {
						processOriginal(rightPossessor, person, modelBean, restock.get(0).countryRightMapAsMap)
					})
				}
			}
		}

		if(!found) {
			log("${catId} not found")
		}
	}
}

File retreiveFile(String trackPath, String ext) {
	if (!client.isConnected()) {
		log "client not connected. reget client"
		client.close()
		client = sshConnector.getClient()
	}

	File tmpFile = new File(workMp3Dir, StringUtil.uidStringWODash() + "." + ext)
	SFTPClient sftp = client.newSFTPClient()
	try {
		sftp.get(trackPath, tmpFile.absolutePath)
	} catch (Exception e) {
		e.printStackTrace()
	} finally {
		sftp.close()
	}

	return tmpFile
}

def limitString(String str, size) {
	str.substring(0, Math.min(str.length(), size))
}

// ---------------------------------------------------------------------------------------------------------------------
def processOriginal(RightPossessor rightPossessor, Person person, WarnerModelBean modelBean, Map<String, Boolean> lastCountryRightMap) {
	log "processOriginal ${modelBean}"
	def src = modelBean.src
	def update = modelBean.upd
	def catId = modelBean.getIsrc()
	def trackName = modelBean.trackName
	def artistName = modelBean.artistName
	def durationInMillis = modelBean.durationInMillis
	def rightPossessorSubName = "(" + modelBean.rightPossessorName + ")"
	def trackPath = (inputDirPath.equals(".") ? "" : inputDirPath + "/") + src.substring(1, src.lastIndexOf("/")) + "/" + RESOURCES + "/" + modelBean.getTrackPath()
	List<String> genreList = modelBean.getGenreListAsList()
	def albumId = modelBean.getAlbumId()
	def albumName = modelBean.getAlbumName()
	def albumYear = modelBean.getAlbumYear() != null ? modelBean.getAlbumYear() : 0
	def countryRightMap = lastCountryRightMap

	if (isPass(catId)) {
		log "### ${catId} уже обрабатывался"
		incrementEvent("alreadyProcessedFail")
		return
	}

	if (isNullOrEmpty(trackPath)) {
		log "### ${modelBean} пустое поле имени файла"
		incrementEvent("emptyFileNameFail")
		return
	}

	if (isNullOrEmpty(artistName)) {
		log("### ${catId}. поле артиста пусто")
		incrementEvent("emptyArtistNameFail")
		return
	}

	if (isNullOrEmpty(trackName)) {
		log("### ${catId}. поле трека пусто")
		incrementEvent("emptyTrackNameFail")
		return
	}

	if (!Collections.disjoint(genreList, FORBIDDEN_GENRES)) {
		log("### ${catId}. содержит нежелательный жанр")
		incrementEvent("forbiddenGenre")
		return
	}

	if (trackName.length() > NAME_LIMIT) {
		trackName = refactorLongName(trackName)
		log("### ${catId}. поле trackName более ${NAME_LIMIT} символов. усекаем до ${trackName}")
	}

	if (artistName.length() > NAME_LIMIT) {
		artistName = refactorLongName(artistName)
		log("### ${catId}. поле artistName более ${NAME_LIMIT} символов. усекаем до ${artistName}")
	}

	Album album = findOrCreateAlbum(albumId, albumName, albumYear)

	log "\nprocessData ->"

	def workers = ImportUtil.getWorkers(workerStoreDir, codegenPath, om)

	log "findOrCreateArtist ->"
	Artist artist = artistService.findOrCreateArtist(artistName)
	artistDao.flush()
	log("artist: " + artist)
	log "findOrCreateArtist <-"


	File trackFile = null
	// качаем трек
	log "retreiveFile -> ${trackPath}"
	trackFile = retreiveFile(trackPath, "mp3")
	log "retreiveFile <-"

	if (trackFile == null || !trackFile.exists()) {
		log("### ${catId}. ошибка скачки файла ${trackPath}. pass")
		incrementEvent("downloadFail")
		return false
	}

	if (!(trackFile.isFile() && trackFile.length() > 0)) {
		log("### ${catId}. ошибка скачки файла ${trackPath}. pass")
		incrementEvent("downloadFail")
		trackFile.delete()

		return false
	} else {
		log "# ${catId}. Загружено ${trackFile.length()}"
	}

	if (trackFile.length() < SIZE_LIMIT) {
		log("!!!#5 трек ${catId}. Загружено ${trackFile.length()}. ограничение по размеру")
		keep(catId)
		trackFile.delete()
		incrementEvent("sizeLimitFail")
		return false
	}

	log "createTrack ->"
	AudioTrack createdTrack = createTrack(person, artist, trackName, new Date(durationInMillis), genreList, catId, rightPossessorSubName, src, countryRightMap, modelBean.releaseDisplayStartDate)
	//в альбом суём только эталон
	if (album != null) {
		AlbumItem albumItem = albumItemDao.findByAlbumAudioTrack(album, createdTrack)
		if (albumItem == null) {
			albumItemDao.persist(new AlbumItem(0, createdTrack, album))
		}
	}
	log "created: ${createdTrack.getId()}"
	log "createTrack <-"

	log "find tracks by artist and track ->"
	Set<AbstractAudioTrack> foundByArtistAndTrackList = Sets.newHashSet()
	List<Long> tmp1 = ImportUtil.findByArtistAndTrack(audioTrackDao, artist.getName(), trackName)
	for(Long id : tmp1){
		AudioTrack tmp1at = audioTrackDao.find(id) as AudioTrack

		if (tmp1at != null && !tmp1at.getPossessorsIdList().contains(RP_ID)){
			foundByArtistAndTrackList.add(tmp1at)
		}
		else {
			ProtectedAudioTrack pat = protectedAudioTrackDao.find(id) as ProtectedAudioTrack
			if (pat != null && !pat.getPossessorsIdList().contains(RP_ID)){
				foundByArtistAndTrackList.add(pat)
			}
		}
	}
	log "found: " + foundByArtistAndTrackList.size()
	log "find tracks by artist and track <-"

	Set<AbstractAudioTrack> foundByFingerprintList = Sets.newHashSet()
	try {
		List<HashShift> unbendedHash = workers.localFingerprintCorpusWorker.codegen(trackFile.absolutePath)

		//bending
		List<List<HashShift>> splitedCodes = splitCodes(sortCodes(unbendedHash), 60)
		List<HashShift> bendedHash = new ArrayList()
		for (List<HashShift> hf : splitedCodes) {
			bendedHash.addAll(hf)
		}

		FingerprintUtil.save(bendedHash, createdTrack.id, workers.localMogileWorker, workerDir, em)

		UnbendedFingerprintUtil.save(unbendedHash, createdTrack.id, workers.localMogileWorker, workerDir, em)

		log "find tracks by fingerprint ->"

		List<Long> tmp2 = FingerprintUtil.findByFingerprint(bendedHash, workers.localFingerprintCorpusWorker)
		log "find: "  + tmp2.size()
		for (Long id : tmp2) {
			AudioTrack at = audioTrackDao.find(id) as AudioTrack
			if (at != null && !at.getPossessorsIdList().contains(RP_ID)) {
				foundByFingerprintList.add(at)
			} else {
				ProtectedAudioTrack pat = protectedAudioTrackDao.find(id) as ProtectedAudioTrack
				if (pat != null && !pat.getPossessorsIdList().contains(RP_ID)){
					foundByFingerprintList.add(pat)
				}
			}
		}
		log "found: " + foundByFingerprintList.size()
		log "find tracks by fingerprint <-"
	} catch(IllegalArgumentException e) {
		//"empty code" nothing to do, just log it and keep going
		log "codegen returned EMPTY code"
	}

	Set<AbstractAudioTrack> createdWithByFingerprintFoundList = Sets.newHashSet()
	createdWithByFingerprintFoundList.add(createdTrack)
	createdWithByFingerprintFoundList.addAll(foundByFingerprintList)

	log "marking all found tracks ->"
	updateFoundTracks(rightPossessor,createdWithByFingerprintFoundList, genreList, catId, rightPossessorSubName, src, countryRightMap, false)
	updateFoundTracks(rightPossessor,foundByArtistAndTrackList, genreList, catId, rightPossessorSubName, src, countryRightMap, true)
	log "marking all found tracks <-"

	for (AbstractAudioTrack aat: createdWithByFingerprintFoundList) {
		String toFilePath = "encoder/not_encoded_${aat.id}.raw.mp3"
		log " ${trackFile.canonicalPath} copy to ${toFilePath}"
		Entry encoderEncoded = workers.localFileWorker.copy(trackFile.canonicalPath, toFilePath, null)
		try{
			log "Getting meta..."
			encoderEncoded.meta(workers.localAudioEncoder.getMeta(encoderEncoded.address.path))
		} catch(WorkerError e) {
			log("Error while fetching metadata of file, will use default bitrate")
		}

		// Перемещение пользовательского аудиотрека в могиле
		/*workers.localMogileWorker.rename(
				entryAddressUtil.getMogileAddressForAudioTrack(aat),
				entryAddressUtil.getMogileAddressForAudioTrack(aat).path,
				entryAddressUtil.getMogileAddressForAudioTrack(aat).path + ORIGINAL_TRACK_POSTFIX
		)*/

		//удаляем старый трек из FTP
		//workers.localFtpWorker.delete(entryAddressUtil.getFtpAddressForAudioTrack(aat))

		if(aat.id == createdTrack.id) {
			// добавляем новый
			def (encodedSize, bitrate, duration) = upload(catId, aat, trackFile.canonicalPath, encoderEncoded, workers)

			updateTrack(aat, encodedSize, bitrate, duration, AbstractAudioTrack.SRC_FILE_IMPORT, null)
		}

		// TODO: Оставлен до реализации takedown
		// checkBlock(workers.localMogileWorker, aat)

		/*if(aat.id != createdTrack.id) {
			// Заменяем отпечаток пользовательского трека на отпечаток мэйджора
			log "replacing fingerprints generated for user tracks ->"
			FingerprintUtil.replaceUserFingerprintByMajor(aat.id, createdTrack.id, em)
			UnbendedFingerprintUtil.replaceUserFingerprintByMajor(aat.id, createdTrack.id, em)
			log "replacing fingerprints generated for user tracks <-"
		}*/

		// Удаляем
		 workers.localFileWorker.delete(encoderEncoded.address.path)
	}

	log("localFileWorker.delete")
	workers.localFileWorker.delete(trackFile.canonicalPath)

	log("resetInane")
	artist.resetInane()

	//теперь когда всё сделано - помечаем как промодерированный
	createdTrack.setActive(true)
	audioTrackDao.merge(createdTrack)
	audioTrackDao.flush()

	keep(catId)

	log("&&& track ref ${catId}: done\n")
	incrementEvent("done")

	if (++count % 100 == 0) {
		em.clear()
		log "### FLASH! ${count}"
	}
}

// ---------------------------------------------------------------------------------------------------------------------
def updateFoundTracks(RightPossessor rightPossessor, Set<AbstractAudioTrack> list, List<String> newTags, String catId, String rightPossessorSubName, String src, Map<String, Boolean> countryRightMap, Boolean shady) {
	if (!shady){
		for (AbstractAudioTrack aat : list) {

			if (aat instanceof AudioTrack){
				AudioTrack at = aat as AudioTrack

				def copyrights = at.getCopyrightSet()
				List<Long> idsForRemove = Lists.newArrayList()

				copyrights.each { copyright ->
					idsForRemove.add(copyright.id)
				}

				idsForRemove.each { id ->
					Copyright copyright = copyrightDao.find(id) as Copyright
					if (copyright != null) {
						at.getCopyrightSet().remove(copyright)
						copyrightDao.remove(copyright)
					}
				}
				copyrightDao.flush()
			}

			if (aat instanceof ProtectedAudioTrack){
				ProtectedAudioTrack at = aat as ProtectedAudioTrack

				def copyrights = at.getCopyrightSet()
				List<Long> idsForRemove = Lists.newArrayList()

				copyrights.each { copyright ->
					idsForRemove.add(copyright.id)
				}

				idsForRemove.each { id ->
					ProtectedCopyright copyright = protectedCopyrightDao.find(id) as ProtectedCopyright
					if (copyright != null) {
						at.getCopyrightSet().remove(copyright)
						protectedCopyrightDao.remove(copyright)
					}
				}

				protectedCopyrightDao.flush()
			}
		}
	}

	for (AbstractAudioTrack aat : list) {
		if (aat instanceof AudioTrack){
			AudioTrack at = aat as AudioTrack

			Long id = at.getId()

			//прежде чем поставить копирайт ставим правило в filezmeta
			putToMongo(catId, id, countryRightMap)

			//теги
			if (newTags != null) {
				for (String tag : newTags) {
					attachTags(at, tag)
				}
			}

			log "catId: ${catId} create copyright on ${id}"

			//записываем в копирайт
			сopyrightService.createOrUpdateCopyright(at, rightPossessor, rightPossessorSubName, DEFAULT_SHARE, catId, shady, limitString(src, 99))

			audioTrackDao.merge(at)
			copyrightDao.flush()
			audioTrackDao.flush()
		}
		if (aat instanceof ProtectedAudioTrack){
			ProtectedAudioTrack at = aat as ProtectedAudioTrack

			Long id = at.getId()

			//прежде чем поставить копирайт ставим правило в filezmeta
			putToMongo(catId, id, countryRightMap)

			//теги
			if (newTags != null) {
				for (String tag : newTags) {
					attachTags(at, tag)
				}
			}

			log "catId: ${catId} create copyright on ${id}"

			//записываем в копирайт
			def cp = new ProtectedCopyright(at, rightPossessor)
			cp.setPossessorShare(DEFAULT_SHARE)
			cp.setCatalogId(catId)
			cp.setSubName(rightPossessorSubName)
			cp.setComment(limitString(src, 99))
			cp.setShady(shady)
			protectedCopyrightDao.persist(cp)
			protectedCopyrightDao.flush()

			protectedAudioTrackDao.merge(at)
			protectedAudioTrackDao.flush()
		}
	}
}

AudioTrack createTrack(Person person, Artist artist, String trackName, Date duration, List newTags, String catId, String rightPossessorSubName, String src, Map<String,Boolean> countryRightMap, Date releaseDate) {

	final AudioTrack targetAT = audioTrackService.createAudioTrack(person, trackName, artist.id, artist.name, "localhost", releaseDate)
	targetAT.setDuration(duration)
	targetAT.setBlock(false)
	audioTrackDao.merge(targetAT)

	//прежде чем поставить копирайт ставим правило в filezmeta
	putToMongo(catId, targetAT.getId(), countryRightMap)

	//записываем в копирайт
	def copyrights = targetAT.getCopyrightSet()
	copyrights.each { cp ->
		cp.setPossessorShare(DEFAULT_SHARE)
		cp.setCatalogId(catId)
		cp.setSubName(rightPossessorSubName)
		cp.setComment(src)
		copyrightDao.merge(cp)
	}

	copyrightDao.flush()

	//теги
	if (newTags != null) {
		for (String tag : newTags) {
			attachTags(targetAT, tag)
		}
	}

	audioTrackDao.merge(targetAT)
	audioTrackDao.flush()

	return targetAT
}

def attachTags(AudioTrack track, String tagsString) {
	log("AudioTrack: attaching tags")
	tagsString.split(";").each { tagName ->
		if (!isNullOrEmpty(tagName)) {
			log("process $tagName")
			Tag tag = tagDao.findByName(tagName) ?: tagDao.findByLowerName(tagName)
			if (tag == null) {
				log("tag with name $tagName not found. Persist new Tag")
				tag = tagDao.persist(new Tag(tagName, tagName))
			}
			log("add tag with id ${tag.id} to track")
			track.addTag(tag)
		}
	}

	audioTrackDao.merge(track)
}

def attachTags(ProtectedAudioTrack track, String tagsString) {
	log("ProtectedAudioTrack: attaching tags")
	tagsString.split(";").each { tagName ->
		if (!isNullOrEmpty(tagName)) {
			log("process $tagName")
			Tag tag = tagDao.findByName(tagName) ?: tagDao.findByLowerName(tagName)
			if (tag == null) {
				log("tag with name $tagName not found. Persist new Tag")
				tag = tagDao.persist(new Tag(tagName, tagName))
			}
			log("add tag with id ${tag.id} to track")
			track.addTag(tag)
		}
	}

	protectedAudioTrackDao.merge(track)
}


/**
 * Закачка обжатого трека в могилу и ФТП
 */
def upload(
		def catId, AbstractAudioTrack aat, String localPath, Entry encoderEncoded, def workers) {
	log("track ref ${catId}: begin upload")

	workers.localMogileWorker.put(entryAddressUtil.getMogileAddressForAudioTrack(aat), encoderEncoded.address.path, encoderEncoded.getMd5())

	if (processToFtp) {
		EntryAddress toFtpAddress = entryAddressUtil.getFtpAddressForAudioTrack(aat)
		log("track ref ${catId}: upload to ftp: " + toFtpAddress)
		workers.localFtpWorker.put(toFtpAddress, localPath, null)
	}

	def size = encoderEncoded.size
	def bitrate = encoderEncoded.getMeta().containsKey(IAudioEncodeWorker.META_TRACK_CALCULATED_BITRATE_NORMALIZED) ?
			encoderEncoded.meta(IAudioEncodeWorker.META_TRACK_CALCULATED_BITRATE_NORMALIZED) : 320
	def duration = encoderEncoded.getMeta().containsKey(IAudioEncodeWorker.META_TRACK_LENGTH) ?
			(Integer) encoderEncoded.meta(IAudioEncodeWorker.META_TRACK_LENGTH) : 180

	return [size, bitrate, duration]
}

/**
 * выставляем флажки для трека, меняем битрейт и т.п.
 */
def updateTrack(AbstractAudioTrack aat, def encodedSize, def bitrate, def duration, def src, def fpId) {
	if (aat instanceof AudioTrack){
		AudioTrack at = aat as AudioTrack

		at.uploadFtp = 1
		at.uploadMogile = 1
		at.size = encodedSize * 1.0 / (1000.0 * 1000.0)
		at.bitrate = bitrate
		at.phantom = false
		at.active = true
		at.duration = new Time(0, (Integer) (duration / 60), duration % 60);
		at.src = src
		at.countIdDesc(idDesc)
		at.fingerprintId = fpId
		at.touch()
		return audioTrackDao.merge(at)
	}

	if (aat instanceof ProtectedAudioTrack){
		ProtectedAudioTrack at = aat as ProtectedAudioTrack

		at.uploadFtp = 1
		at.uploadMogile = 1
		at.size = encodedSize * 1.0 / (1000.0 * 1000.0)
		at.bitrate = bitrate
		at.phantom = false
		at.active = true
		at.duration = new Time(0, (Integer) (duration / 60), duration % 60);
		at.src = src
		at.countIdDesc(idDesc)
		at.fingerprintId = fpId

		return protectedAudioTrackDao.merge(at)
	}
}

def checkBlock(LocalMogileWorker mogileWorker, AbstractAudioTrack aat) {
	EntryAddress mogileAddressForAudioTrack = entryAddressUtil.getMogileAddressForAudioTrack(aat)
	EntryAddress blockMogileTrackAddr = new EntryAddress(mogileAddressForAudioTrack.getDomain(), mogileAddressForAudioTrack.getPath() + SUFFIX)

	long trackSize = mogileWorker.checkSize(mogileAddressForAudioTrack)
	long blockTrackSize = mogileWorker.checkSize(blockMogileTrackAddr)

	if (aat.getBlock()) {
		if (trackSize > 0) {
			if (blockTrackSize > 0) {
				log "# удаляем существующий ${blockMogileTrackAddr}"
				mogileWorker.delete(blockMogileTrackAddr)
			}
			log "# rename ${mogileAddressForAudioTrack} -> ${blockMogileTrackAddr}"
			mogileWorker.rename(mogileAddressForAudioTrack, mogileAddressForAudioTrack.getPath(), blockMogileTrackAddr.getPath())
		}
	} else {
		if (blockTrackSize > 0) {
			aat.setBlock(true)
			if (trackSize > 0) {
				log "# удаляем существующий ${blockMogileTrackAddr}"
				mogileWorker.delete(blockMogileTrackAddr)
				log "# rename ${mogileAddressForAudioTrack} -> ${blockMogileTrackAddr}"
				mogileWorker.rename(mogileAddressForAudioTrack, mogileAddressForAudioTrack.getPath(), blockMogileTrackAddr.getPath())
			}
		}
	}
}

String refactorLongName(String longName) {
	String[] subNameArr = longName.split("\\s")

	StringBuilder sb = new StringBuilder()

	def currentLen = 0
	for (String subName : subNameArr) {
		if (currentLen + subName.length() + 1 > NAME_LIMIT) {
			return sb.toString().trim() + "..."
		}
		sb.append(" ").append(subName)
		currentLen += subName.length() + 1
	}

	return sb.toString()
}

String normalizePath(String path) {
	if (isNullOrEmpty(path)) return path;

	if (path.contains(inputDirPath)) {
		return path.substring(inputDirPath.length());
	} else {
		return path
	}
}

Boolean isPass(String path) {
	return historian.isPass(normalizePath(path));
}

void keep(String path) throws IOException {
	historian.keep(normalizePath(path))
}

def putToMongo(String catId, Long trackId, Map<String, Boolean> lastMap) {
	def ruleList = lastMap.collect { state, value ->
		new FileRestrictionAddRuleBean("*", -1L, -1L, state, "*", value.toString())
	}

	fileRestrictionService.putSequential(DKeyGenerationUtil.trackKey(trackId), ruleList, "585273ee8d0494d6e968b0e0", catId)
}

Album findOrCreateAlbum(String albumId, String albumName, Integer albumYear) {
	log("findOrCreateAlbum: ${albumId} ${albumName} ${albumYear}")
	Album album = null
	if (!isNullOrEmpty(albumId)) {
		album = albumDao.findByUid(albumId)
		if (album == null) {
			album = albumDao.persist(new Album(albumName, "", albumYear, albumId))
		}
	} else {
		if (!isNullOrEmpty(albumName) && albumYear != null) {
			albumId = "${albumYear}|${albumName}"

			album = albumDao.findByUid(albumId)
			if (album == null) {
				album = albumDao.persist(new Album(albumName, "", albumYear, albumId))
			}
		}
	}
	return album
}

def packageExist(def path) {
	if (!isNullOrEmpty(path)) {
		for (String dir : packageDirSet) {
			if (path.contains(dir)) return true
		}
	}
	log "!!! пакета не существует на сервере ${path}"
	return false
}