/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License") +  you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.openmeetings.data.flvrecord.converter;

import java.io.File;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

import org.apache.commons.transaction.util.FileHelper;
import org.apache.openmeetings.OpenmeetingsVariables;
import org.apache.openmeetings.data.flvrecord.FlvRecordingDao;
import org.apache.openmeetings.data.flvrecord.FlvRecordingLogDao;
import org.apache.openmeetings.data.flvrecord.FlvRecordingMetaDataDao;
import org.apache.openmeetings.documents.GenerateThumbs;
import org.apache.openmeetings.documents.beans.ConverterProcessResult;
import org.apache.openmeetings.persistence.beans.flvrecord.FlvRecording;
import org.apache.openmeetings.persistence.beans.flvrecord.FlvRecordingMetaData;
import org.apache.openmeetings.utils.ProcessHelper;
import org.red5.logging.Red5LoggerFactory;
import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;

public class FlvInterviewConverter extends BaseConverter {
	private int leftSideLoud = 1;
	private int rightSideLoud = 1;
	private Integer leftSideTime = 0;
	private Integer rightSideTime = 0;

	private static final Logger log = Red5LoggerFactory.getLogger(
			FlvInterviewConverter.class,
			OpenmeetingsVariables.webAppRootKey);

	// Spring loaded Beans
	@Autowired
	private FlvRecordingDao flvRecordingDaoImpl = null;
	@Autowired
	private FlvRecordingMetaDataDao flvRecordingMetaDataDaoImpl = null;
	@Autowired
	private FlvRecordingLogDao flvRecordingLogDaoImpl;
	@Autowired
	private GenerateThumbs generateThumbs;

	public void startReConversion(Long flvRecordingId, Integer leftSideLoud,
			Integer rightSideLoud, Integer leftSideTime, Integer rightSideTime) {

		log.debug("++++++++++++ leftSideLoud :: " + leftSideLoud);
		log.debug("++++++++++++ rightSideLoud :: " + rightSideLoud);

		this.leftSideLoud += leftSideLoud;
		this.rightSideLoud += rightSideLoud;

		this.leftSideTime = leftSideTime;
		this.rightSideTime = rightSideTime;

		log.debug("++++++++++++ this.leftSideLoud :: " + this.leftSideLoud);
		log.debug("++++++++++++ this.rightSideLoud :: " + this.rightSideLoud);
		log.debug("++++++++++++ this.leftSideTime :: " + this.leftSideTime);
		log.debug("++++++++++++ this.rightSideTime :: " + this.rightSideTime);
		startConversion(flvRecordingId, true);
	}

	public void startConversion(Long flvRecordingId) {
		startConversion(flvRecordingId, false);
	}
	
	public void startConversion(Long flvRecordingId, boolean reconversion) {
		try {

			FlvRecording flvRecording = this.flvRecordingDaoImpl
					.getFlvRecordingById(flvRecordingId);
			log.debug("flvRecording " + flvRecording.getFlvRecordingId());

			// Strip Audio out of all Audio-FLVs
			stripAudioFromFLVs(flvRecording, reconversion);

			// Add empty pieces at the beginning and end of the wav

		} catch (Exception err) {
			log.error("[startConversion]", err);
		}
	}
	
	private String[] mergeAudioToWaves(List<String> listOfFullWaveFiles, String outputFullWav, List<FlvRecordingMetaData> metaDataList) {
		String[] argv_full_sox = new String[listOfFullWaveFiles.size() + 5];
		argv_full_sox[0] = this.getPathToSoX();
		argv_full_sox[1] = "-m";

		int counter = 2;
		for (int i = 0; i < listOfFullWaveFiles.size(); i++) {
			for (FlvRecordingMetaData flvRecordingMetaData : metaDataList) {
				String hashFileFullNameStored = flvRecordingMetaData
						.getFullWavAudioData();

				String fullFilePath = listOfFullWaveFiles.get(i);
				String fileNameOnly = new File(fullFilePath).getName();

				if (hashFileFullNameStored.equals(fileNameOnly)) {
					if (flvRecordingMetaData.getInteriewPodId() == 1) {
						argv_full_sox[counter] = "-v "
								+ this.leftSideLoud;
						counter++;
					}
					if (flvRecordingMetaData.getInteriewPodId() == 2) {
						argv_full_sox[counter] = "-v "
								+ this.rightSideLoud;
						counter++;
					}
				}
			}
			argv_full_sox[counter] = listOfFullWaveFiles.get(i);
			counter++;
		}

		argv_full_sox[counter] = outputFullWav;
		
		return argv_full_sox;
	}
	
	public void stripAudioFromFLVs(FlvRecording flvRecording, boolean reconversion) {
		List<ConverterProcessResult> returnLog = new ArrayList<ConverterProcessResult>();
		List<String> listOfFullWaveFiles = new LinkedList<String>();
		File streamFolder = getStreamFolder(flvRecording);
		List<FlvRecordingMetaData> metaDataList = flvRecordingMetaDataDaoImpl
				.getFlvRecordingMetaDataAudioFlvsByRecording(flvRecording
						.getFlvRecordingId());

		stripAudioFirstPass(flvRecording, returnLog, listOfFullWaveFiles,
				streamFolder, metaDataList);
		try {
			// Merge Wave to Full Length
			File streamFolderGeneral = getStreamFolder();

			String hashFileFullName = "INTERVIEW_"
					+ flvRecording.getFlvRecordingId() + "_FINAL_WAVE.wav";
			String outputFullWav = streamFolder.getAbsolutePath() + File.separatorChar + hashFileFullName;
			deleteFileIfExists(outputFullWav);

			if (listOfFullWaveFiles.size() == 1) {

				outputFullWav = listOfFullWaveFiles.get(0);

			} else if (listOfFullWaveFiles.size() > 0) {
				String[] argv_full_sox;
				if (reconversion) {
					argv_full_sox = mergeAudioToWaves(listOfFullWaveFiles, outputFullWav, metaDataList);
				} else {
					argv_full_sox = mergeAudioToWaves(listOfFullWaveFiles, outputFullWav);
				}

				log.debug("START mergeAudioToWaves ################# ");
				log.debug(argv_full_sox.toString());
				String iString = "";
				for (int i = 0; i < argv_full_sox.length; i++) {
					iString += argv_full_sox[i] + " ";
				}
				log.debug(iString);
				log.debug("END mergeAudioToWaves ################# ");

				returnLog.add(ProcessHelper.executeScript("mergeWave",
						argv_full_sox));
			} else {

				// create default Audio to merge it.
				// strip to content length
				File outputWav = new File(streamFolderGeneral, "one_second.wav");

				// Calculate delta at beginning
				Long deltaTimeMilliSeconds = flvRecording.getRecordEnd()
						.getTime() - flvRecording.getRecordStart().getTime();
				Float deltaPadding = (Float.parseFloat(deltaTimeMilliSeconds
						.toString()) / 1000) - 1;

				String[] argv_full_sox = new String[] { this.getPathToSoX(),
						outputWav.getCanonicalPath(), outputFullWav, "pad", "0",
						deltaPadding.toString() };

				log.debug("START generateSampleAudio ################# ");
				String tString = "";
				for (int i = 0; i < argv_full_sox.length; i++) {
					tString += argv_full_sox[i] + " ";
				}
				log.debug(tString);
				log.debug("END generateSampleAudio ################# ");

				returnLog.add(ProcessHelper.executeScript("mergeWave",
						argv_full_sox));

			}

			// Merge Audio with Video / Calculate resulting FLV

			// Start extracting image sequence
			int frameRate = 25;

			for (FlvRecordingMetaData flvRecordingMetaData : metaDataList) {

				// FLV to 24 FPS Sequence AVI
				String inputFlv = new File(streamFolder, flvRecordingMetaData.getStreamName() + ".flv").getCanonicalPath();

				File inputFlvFile = new File(inputFlv);

				if (inputFlvFile.exists()) {
					// TO Image Sequence

					// Image Folder
					File imageSequenceFolder = new File(streamFolder
						, "" + flvRecordingMetaData.getFlvRecordingMetaDataId());
					imageSequenceFolder.mkdir();
					
					String outputImages = new File(imageSequenceFolder, "image%d.png").getCanonicalPath();

					String[] argv_imageSeq = new String[] {
							this.getPathToFFMPEG(), "-i", inputFlv, "-r",
							"" + frameRate, "-s", "320x240", outputImages };

					log.debug("START generateImageSequence ################# ");
					String iString = "";
					for (int i = 0; i < argv_imageSeq.length; i++) {
						iString += argv_imageSeq[i] + " ";
					}
					log.debug(iString);
					log.debug("END generateImageSequence ################# ");

					returnLog.add(ProcessHelper.executeScript(
							"generateImageSequence", argv_imageSeq));

				}

			}

			// Default Image for empty interview video pods
			File defaultInterviewImageFile = new File(streamFolderGeneral, "default_interview_image.png");

			if (!defaultInterviewImageFile.exists()) {
				throw new Exception("defaultInterviewImageFile does not exist!");
			}
			String defaultInterviewImage = defaultInterviewImageFile.getCanonicalPath();

			// Create Folder for the output Image Sequence
			String outputImageMergedData = streamFolder.getAbsolutePath() + File.separatorChar 
					+ "INTERVIEW_"	+ flvRecording.getFlvRecordingId() 
					+ File.separatorChar;

			// Merged Image Folder
			File outputImageMergedDateFolder = new File(outputImageMergedData);
			outputImageMergedDateFolder.mkdir();

			// Generate the Single Image by sequencing
			boolean jobRunning = true;
			long currentTimeInMilliSeconds = 0;

			long completeLengthInSeconds = flvRecording.getRecordEnd()
					.getTime() - flvRecording.getRecordStart().getTime();

			log.debug("completeLengthInSeconds :: " + completeLengthInSeconds);

			int sequenceCounter = 0;

			while (jobRunning) {

				// Process one Second of Movie
				String[] interviewPod1Images = new String[frameRate];
				String[] interviewPod2Images = new String[frameRate];
				int[] outputFrameNumbers = new int[frameRate];

				for (FlvRecordingMetaData flvRecordingMetaData : metaDataList) {

					long deltaStartRecording = flvRecordingMetaData
							.getRecordStart().getTime()
							- flvRecording.getRecordStart().getTime();

					if (flvRecording.getRecordStart().getTime()
							+ currentTimeInMilliSeconds >= flvRecordingMetaData
							.getRecordStart().getTime()
							&& flvRecording.getRecordStart().getTime()
									+ currentTimeInMilliSeconds <= flvRecordingMetaData
									.getRecordEnd().getTime()) {

						// Calculate which images should be in here

						// Calculate the relative starting point
						long thisImageSequenceStartingPoint = currentTimeInMilliSeconds
								- deltaStartRecording;

						// Calculate the first and following frameRate FPS
						// Number
						int secondToStart = Long.valueOf(
								thisImageSequenceStartingPoint / 1000)
								.intValue();

						int firstFrame = secondToStart * frameRate;

						for (int i = 0; i < frameRate; i++) {

							int currentImageNumber = firstFrame + i;
							currentImageNumber -= (frameRate / 2); 
							// Remove the first half seconds and fill
							// it up with black screens

							// Remove the first period of Images, this is where
							// the user has started
							// to share his Video but does not have agreed in
							// the Flash Security Warning Dialogue
							Integer initialGapSeconds = flvRecordingMetaData
									.getInitialGapSeconds();
							if (initialGapSeconds != null) {
								int initialMissingImages = Double.valueOf(
										Math.floor((initialGapSeconds / 1000)
												* frameRate)).intValue();
								currentImageNumber -= initialMissingImages;
							}

							String imageName = "image" + currentImageNumber + ".png";

							File outputMetaImageFullDataFile = new File(streamFolder
								, "" + flvRecordingMetaData.getFlvRecordingMetaDataId()
									+ File.separatorChar + imageName);
							
							String outputMetaImageFullData = 
								!outputMetaImageFullDataFile.exists() ? defaultInterviewImage
								: outputMetaImageFullDataFile.getCanonicalPath();

							if (flvRecordingMetaData.getInteriewPodId() == 1) {
								interviewPod1Images[i] = outputMetaImageFullData;
							} else if (flvRecordingMetaData.getInteriewPodId() == 2) {
								interviewPod2Images[i] = outputMetaImageFullData;
							}

						}

					}

				}

				// Update Sequence Count
				for (int i = 0; i < frameRate; i++) {
					outputFrameNumbers[i] = sequenceCounter;
					sequenceCounter++;
				}

				// Now we should have found the needed Images to calculate, in
				// case not we add an empty black screen
				for (int i = 0; i < frameRate; i++) {
					String addZeros = "";

					String outputImageName = outputImageMergedData + "image"
							+ addZeros + outputFrameNumbers[i] + ".png";

					if (interviewPod1Images[i] == null) {
						interviewPod1Images[i] = defaultInterviewImage;
					}
					if (interviewPod2Images[i] == null) {
						interviewPod2Images[i] = defaultInterviewImage;
					}

					if (System.getProperty("os.name").toUpperCase()
							.indexOf("WINDOWS") == -1) {
						String[] argv_imageMagick = new String[] {
								this.getPathToImageMagick(), "+append",
								interviewPod1Images[i], interviewPod2Images[i],
								outputImageName };
						returnLog.add(ProcessHelper.executeScript(
								"generateImageSequence", argv_imageMagick));
					} else {
						returnLog.add(processImageWindows(
								interviewPod1Images[i], interviewPod2Images[i],
								outputImageName));
					}
				}

				currentTimeInMilliSeconds += 1000;

				double cLength = 100 * ((double) currentTimeInMilliSeconds)
						/ completeLengthInSeconds;

				int progress = Double.valueOf(cLength).intValue();

				log.debug("completeLengthInSeconds|currentTimeInMilliSeconds "
						+ completeLengthInSeconds + "|"
						+ currentTimeInMilliSeconds + "|" + progress + "|"
						+ cLength);

				flvRecordingDaoImpl.updateFlvRecordingProgress(
						flvRecording.getFlvRecordingId(), progress);

				if (currentTimeInMilliSeconds >= completeLengthInSeconds) {

					jobRunning = false;

				}

			}

			// Generate Movie by sequence of Images

			String imagescomplete = outputImageMergedData + "image%d.png";

			String[] argv_generatedMoview = null;

			String inputScreenFullFlv = streamFolder.getAbsolutePath() + File.separatorChar
					+ "COMPLETE_INTERVIEW_" + flvRecording.getFlvRecordingId()
					+ ".flv";
			deleteFileIfExists(inputScreenFullFlv);

			argv_generatedMoview = new String[] { this.getPathToFFMPEG(), "-i",
					imagescomplete, "-r", "" + frameRate, "-vcodec", "flv",
					"-qmax", "1", "-qmin", "1", inputScreenFullFlv };

			log.debug("START generateFullBySequenceFLV ################# ");
			String tString2 = "";
			for (int i = 0; i < argv_generatedMoview.length; i++) {
				tString2 += argv_generatedMoview[i] + " ";
			}
			log.debug(tString2);
			log.debug("END generateFullBySequenceFLV ################# ");

			returnLog.add(ProcessHelper.executeScript(
					"generateFullBySequenceFLV", argv_generatedMoview));

			String hashFileFullNameFlv = "flvRecording_"
					+ flvRecording.getFlvRecordingId() + ".flv";
			String outputFullFlv = new File(streamFolderGeneral, hashFileFullNameFlv).getCanonicalPath();
			deleteFileIfExists(outputFullFlv);

			// ffmpeg -vcodec flv -qscale 9.5 -r 25 -ar 22050 -ab 32k -s 320x240
			// -i
			// 65318fb5c54b1bc1b1bca077b493a914_28_12_2009_23_38_17_FINAL_WAVE.wav
			// -i 65318fb5c54b1bc1b1bca077b493a914_28_12_2009_23_38_17.flv
			// final1.flv

			int flvWidth = 640;
			int flvHeight = 240;

			flvRecording.setFlvWidth(flvWidth);
			flvRecording.setFlvHeight(flvHeight);

			String[] argv_fullFLV = new String[] {
					this.getPathToFFMPEG(), //
					"-i", inputScreenFullFlv, "-i", outputFullWav,
					"-ar",
					"22050", //
					"-ab",
					"32k", //
					"-s",
					flvWidth + "x" + flvHeight, //
					"-vcodec",
					"flv", //
					"-r", "" + frameRate, "-qmax", "1", "-qmin", "1",
					outputFullFlv };

			log.debug("START generateFullFLV ################# ");
			String tString = "";
			for (int i = 0; i < argv_fullFLV.length; i++) {
				tString += argv_fullFLV[i] + " ";
				// log.debug(" i " + i + " argv-i " + argv_fullFLV[i]);
			}
			log.debug(tString);
			log.debug("END generateFullFLV ################# ");

			returnLog.add(ProcessHelper.executeScript("generateFullFLV",
					argv_fullFLV));

			flvRecording.setFileHash(hashFileFullNameFlv);

			// Extract first Image for preview purpose
			// ffmpeg -i movie.flv -vcodec mjpeg -vframes 1 -an -f rawvideo -s
			// 320x240 movie.jpg

			String hashFileFullNameJPEG = "flvRecording_"
					+ flvRecording.getFlvRecordingId() + ".jpg";
			String outPutJpeg = new File(streamFolderGeneral, hashFileFullNameJPEG).getCanonicalPath();
			deleteFileIfExists(outPutJpeg);

			flvRecording.setPreviewImage(hashFileFullNameJPEG);

			String[] argv_previewFLV = new String[] { //
			this.getPathToFFMPEG(), //
					"-i", outputFullFlv, //
					"-vcodec", "mjpeg", //
					"-vframes", "100", "-an", //
					"-f", "rawvideo", //
					"-s", flvWidth + "x" + flvHeight, //
					outPutJpeg };

			log.debug("START previewFullFLV ################# ");
			log.debug(argv_previewFLV.toString());
			String kString = "";
			for (int i = 0; i < argv_previewFLV.length; i++) {
				kString += argv_previewFLV[i] + " ";
			}
			log.debug(kString);
			log.debug("END previewFullFLV ################# ");

			returnLog.add(ProcessHelper.executeScript("generateFullFLV",
					argv_previewFLV));

			String alternateDownloadName = "flvRecording_"
					+ flvRecording.getFlvRecordingId() + ".avi";
			String alternateDownloadFullName = new File(streamFolderGeneral, alternateDownloadName).getCanonicalPath();
			deleteFileIfExists(alternateDownloadFullName);

			String[] argv_alternateDownload = new String[] {
					this.getPathToFFMPEG(), "-i", outputFullFlv,
					alternateDownloadFullName };

			log.debug("START alternateDownLoad ################# ");
			log.debug(argv_previewFLV.toString());
			String sString = "";
			for (int i = 0; i < argv_alternateDownload.length; i++) {
				sString += argv_alternateDownload[i] + " ";
			}
			log.debug(sString);
			log.debug("END alternateDownLoad ################# ");

			returnLog.add(ProcessHelper.executeScript("alternateDownload",
					argv_alternateDownload));

			flvRecording.setAlternateDownload(alternateDownloadName);

			flvRecordingDaoImpl.updateFlvRecording(flvRecording);

			flvRecordingLogDaoImpl
					.deleteFLVRecordingLogByRecordingId(flvRecording
							.getFlvRecordingId());

			for (ConverterProcessResult returnMap : returnLog) {
				flvRecordingLogDaoImpl.addFLVRecordingLog("generateFFMPEG",
						flvRecording, returnMap);
			}

			// Delete Wave Files
			for (String fileName : listOfFullWaveFiles) {
				File audio = new File(fileName);
				if (audio.exists()) {
					audio.delete();
				}
			}

			// Delete all Image temp dirs
			for (FlvRecordingMetaData flvRecordingMetaData : metaDataList) {
				FileHelper.removeRec(new File(streamFolder, "" + flvRecordingMetaData.getFlvRecordingMetaDataId()));
			}

			FileHelper.removeRec(new File(outputImageMergedData));

		} catch (Exception err) {
			log.error("[stripAudioFromFLVs]", err);
		}
	}

	public ConverterProcessResult thumbProcessImageWindows(String file1,
			String file2, String file3) {

		// Init variables
		String[] cmd = { this.getPathToImageMagick(), file1, file2, "+append",
				file3 };

		return generateThumbs.processImageWindows(cmd);
	}

	public ConverterProcessResult processImageWindows(String file1,
			String file2, String file3) {
		return ProcessHelper.executeScriptWindows("processImageWindows"
			, new String[]{getPathToImageMagick(), file1, file2, "+append", file3});
	}
}