//UUID Manager Builder
function UUIDManager(){
	var uploadSuccessFileUUIDList;
	return {
		build : function(){
			this.uploadSuccessFileUUIDList = [];
			
			//return object
			let uuidManager = {
				uploadSuccessFileUUIDList : this.uploadSuccessFileUUIDList,
				addSuccessFileUUID : function(UUID){return addSuccessFileUUID(this.uploadSuccessFileUUIDList, UUID)},
				deleteSuccessFileUUID : function(UUID){return deleteSuccessFileUUID(this.uploadSuccessFileUUIDList, UUID)},
				getSuccessFileUUID : function(){return getSuccessFileUUID(this)},
				insertUUIDintoForm : function(formId){return insertEditorUUIDintoForm(this.uploadSuccessFileUUIDList, formId)},
				setUUIDFromNaverEditor : function(editorWrapperId){this.uploadSuccessFileUUIDList = setUUIDFromNaverEditor(this.uploadSuccessFileUUIDList, editorWrapperId)},
				setUUIDFromFroalaEditor : function(editorWrapperId){this.uploadSuccessFileUUIDList = setUUIDFromFroalaEditor(this.uploadSuccessFileUUIDList, editorWrapperId)},
				getFroalaKey : function(){return 'GPD2tA2A2C3B2B1F2sGXh1WWTDSGXYOUKc1KINLe1OC1c1D-17D2E2F2C1E4F1A1B8C7E6=='}
			};
			
			return uuidManager;
			
		}
	}
}
//End UUID Manager Builder

//Builder
function fileUploaderBuilder(){
	let wrapperElementID,
		uploadEndPoint,
		deleteEndPoint,
		autoUpload,
		debug,
		allowedExtensions,
		itemLimit,
		sizeLimit,
		onProgress,
		onComplete,
		fineUploader,
		csrfToken,
		csrfHeader,
		params,
		isValidationPassed,
		uploadSuccessFileUUIDList,
		acceptFiles,
		isEnableS3;
	
	return {
		setWrapperElementID : function(wrapperElementID){
			this.wrapperElementID = wrapperElementID;
			return this;
		},
		setUploadEndPoint : function(uploadEndPoint){
			this.uploadEndPoint = uploadEndPoint;
			return this;
		},
		setDeleteEndPoint : function(deleteEndPoint){
			this.deleteEndPoint = deleteEndPoint;
			return this;
		},
		setAutoUpload : function(autoUpload){
			this.autoUpload = autoUpload;
			return this;
		},
		setDebug : function(debug){
			this.debug = debug;
			return this;
		},
		setAllowedExtensions : function(allowedExtensions){
			this.allowedExtensions = allowedExtensions;
			return this;
		},
		setItemLimit : function(itemLimit){
			this.itemLimit = itemLimit;
			return this;
		},
		setSizeLimit : function(sizeLimit){
			this.sizeLimit = sizeLimit;
			return this;
		},
		setOnProgress : function(onProgress){
			this.onProgress = onProgress;
			return this;
		},
		setOnComplete : function(onComplete){
			this.onComplete = onComplete;
			return this;
		},
		setCsrf : function(csrfHeader, csrfToken) {
			this.csrfToken = csrfToken;
			this.csrfHeader = csrfHeader;
			return this;
		},
		addParams : function(name, value){
			let params = this.params;
			if(params == undefined) {
				params = {};
			}
			params[name] = value;
			
			this.params = params;
			return this;
		},
		setAcceptFiles :  function(acceptFiles){
			this.acceptFiles = acceptFiles;
			return this;
		},
		enableS3 : function(enableS3){
			this.isEnableS3 = enableS3;
			return this;
		},
		build : function(){
			this.uploadSuccessFileUUIDList = [];
			let optionSet = {
					wrapperElementID : this.wrapperElementID,
					uploadEndPoint : this.uploadEndPoint,
					autoUpload : this.autoUpload,
					debug : this.debug,
					allowedExtensions : this.allowedExtensions,
					itemLimit : this.itemLimit,
					sizeLimit : this.sizeLimit, 
					onProgress : this.onProgress,
					onComplete : this.onComplete,
					csrfHeader : this.csrfHeader,
					csrfToken : this.csrfToken,
					params : this.params,
					acceptFiles : this.acceptFiles,
					isEnableS3 : this.isEnableS3
			};
			
			//valid check
			validationOptions(optionSet);
			
			if(!optionSet.isValidationPassed){
				return null;
			}
			
			//create uploader object
			this.fineUploader = createFineUploader(optionSet);
			
			//set csrf
			if(optionSet.csrfToken != undefined && optionSet.csrfHeader != undefined) {
				if(optionSet.csrfHeader == 'X-CSRF-TOKEN') {
					this.fineUploader.setCustomHeaders({
						'X-CSRF-TOKEN' : optionSet.csrfToken
					});
					this.fineUploader.setDeleteFileCustomHeaders({
						'X-CSRF-TOKEN' : optionSet.csrfToken
					});
				}
			}
			
			//set params
			if(optionSet.params != undefined) {
				this.fineUploader.setParams(optionSet.params)
			}
			
			//return object
			let fileUploader = {
				uploadSuccessFileUUIDList : this.uploadSuccessFileUUIDList,
				optionSet : optionSet,
				fineUploader : this.fineUploader,
				upload : function(){return upload(this.fineUploader)},
				reset : function(){return reset(this)},
				getFileCount : function(){return getFileCount(this.fineUploader)},
				addInitialFiles : function(initialFiles){return addInitialFiles(this.uploadSuccessFileUUIDList, initialFiles, this.fineUploader)},
				addSuccessFileUUID : function(UUID){return addSuccessFileUUID(this.uploadSuccessFileUUIDList, UUID)},
				deleteSuccessFileUUID : function(UUID){return deleteSuccessFileUUID(this.uploadSuccessFileUUIDList, UUID)},
				getSuccessFileUUID : function(){return getSuccessFileUUID(this)},
				insertUUIDintoForm : function(formId){return insertUUIDintoForm(this.uploadSuccessFileUUIDList, formId)},
				deleteFile : function(UUID, onSuccessFunction){return deleteFile(UUID, this.optionSet, onSuccessFunction)},
				clearStoredFiles : function(){return clearStoredFiles(this)}
			};
			
			//delete event listener
			addDeleteButtonClickEvent(fileUploader);
			
			return fileUploader;
			
		}
	}
}
//End Builder

//append Div
function addDiv(elementId) {
	var newDiv = document.createElement("div");
		newDiv.id = elementId;
	document.body.appendChild(newDiv);
}

//validation
function validationOptions(optionSet) {
	optionSet.isValidationPassed = true;
	
	//enable S3
	if(optionSet.isEnableS3 == undefined) {
		optionSet.isEnableS3 = false;
	}
	
	//Wrapper Element Check
	if(optionSet.wrapperElementID == undefined) {
		optionSet.wrapperElementID = 'file-upload-wrapper';
	}
	//입력된 요소가 없을경우 새로운 DIV를 삽입
	let elementCheck = document.getElementById(optionSet.wrapperElementID);
	if(elementCheck == null) {
		addDiv(optionSet.wrapperElementID);
	}
	
	//upload end point check
	if(optionSet.uploadEndPoint == undefined) {
		if(optionSet.isEnableS3) {
			optionSet.uploadEndPoint = '/file/s3FileUpload';
		} else {
			optionSet.uploadEndPoint = '/file/ajaxMultiFileUpload';
		}
	}
	
	//delete end point check
	if(optionSet.deleteEndPoint == undefined) {
		if(optionSet.isEnableS3) {
			optionSet.deleteEndPoint = '/file/s3FileDelete';
		} else {
			optionSet.deleteEndPoint = '/file/deleteFile';
		}
	}
	
	//autoUpload check
	if(optionSet.autoUpload == undefined) {
		optionSet.autoUpload = false;
	}
	//debug point check
	if(optionSet.debug == undefined) {
		optionSet.debug = false;
	}
	//allowedExtensions point check
	if(optionSet.allowedExtensions == undefined) {
		optionSet.allowedExtensions = ['jpg','jpeg','png'];
	}
	//itemLimit point check
	if(optionSet.itemLimit == undefined) {
		optionSet.itemLimit = 10;
	}
	//sizeLimit point check
	if(optionSet.sizeLimit == undefined) {
		optionSet.sizeLimit = 10485760;
	}
	//onComplete point check
	if(optionSet.onComplete == undefined) {
		optionSet.onComplete = function(){
			swal('업로드 성공','업로드에 성공하였습니다.','success');
		}
	}
	//onProgress point check
	if(optionSet.onProgress == undefined) {
		optionSet.onProgress = function(id, name, uploadedBytes, totalBytes){}
	}
	
}
//End valid

//create fine uploader
function createFineUploader(optionSet){
	return new qq.FineUploader({
		element: document.getElementById(optionSet.wrapperElementID),
		template: 'qq-template-manual-trigger',
		request: {
			endpoint: optionSet.uploadEndPoint,
			method: 'POST'
		},
		deleteFile: {
	        enabled: true,
	        method: "post",
	        endpoint: optionSet.deleteEndPoint
	    },
		thumbnails: {
			placeholders: {
				waitingPath: '/assets/fine-uploader/placeholders/waiting-generic.png',
				notAvailablePath: '/assets/fine-uploader/placeholders/not_available-generic.png'
			}
		},
		autoUpload: optionSet.autoUpload,
		debug: optionSet.debug,
		validation: {
			allowedExtensions: optionSet.allowedExtensions,
			itemLimit: optionSet.itemLimit,
			sizeLimit: optionSet.sizeLimit,
			acceptFiles: optionSet.acceptFiles
		},
		callbacks: {
			onComplete: function(data, responseJSON, maybeXhr) {
				optionSet.onComplete(data, responseJSON, maybeXhr);
			},
			onCancel: function(id, name) {
			},
			onError: function(id, name, reason, maybeXhrOrXdr) {
			},
			onAllComplete: function(successful, failed) {
			},
			onDelete: function(id, xhr, isError) {
			},
			onProgress: function(id, name, uploadedBytes, totalBytes) {
				optionSet.onProgress(id, name, uploadedBytes, totalBytes);
			},
		}
//	    ,scaling: {
//	          sendOriginal: false,
//	          orient: false,
//	          sizes: [
//	              {name: "medium", maxSize: 2048}
//	          ]
//	      }
      
	});
}

//Reset
function reset(fileUploader) {
	fileUploader.fineUploader.reset();
	fileUploader.uploadSuccessFileUUIDList = [];
}

function clearStoredFiles(fileUploader) {
	fileUploader.fineUploader.clearStoredFiles();
	fileUploader.uploadSuccessFileUUIDList = [];
}

//get file count
function getFileCount(fineUploader){
	let fileCount = 0;
	files = fineUploader.getUploads();
	for(key in files) {
		if(files[key].status != 'deleted'){
			fileCount++;
		}
	}
	return fileCount;
}

//run upload
function upload(fineUploader){
	fineUploader.uploadStoredFiles();
}

//addInitialFiles
function addInitialFiles(uploadSuccessFileUUIDList, initialFiles, fineUploader){
	for(key in initialFiles){
		addSuccessFileUUID(uploadSuccessFileUUIDList, initialFiles[key].uuid);
	}
	fineUploader.addInitialFiles(initialFiles);
}

//add SuccessFileUUID
function addSuccessFileUUID(uploadSuccessFileUUIDList, addSuccessFileUUID) {
	uploadSuccessFileUUIDList.push(addSuccessFileUUID);
}

//delete SuccessFileUUID
function deleteSuccessFileUUID(uploadSuccessFileUUIDList, deleteSuccessFileUUID){
	let deleteIndex = uploadSuccessFileUUIDList.indexOf(deleteSuccessFileUUID);
	if(deleteIndex != -1) {
		uploadSuccessFileUUIDList.splice(deleteIndex, 1);
	}
}

//get successFileUUID
function getSuccessFileUUID(fileUploader){
	return fileUploader.uploadSuccessFileUUIDList;
}

//add Delete Button Click Event
function addDeleteButtonClickEvent(fileUploader){
	$(document).on('click', '.qq-upload-delete-selector', function(){
		let fileId = $(this).parents('li').attr('qq-file-id');
		let deletedUUID = fileUploader.fineUploader.getUploads()[fileId].uuid;

		deleteSuccessFileUUID(fileUploader.uploadSuccessFileUUIDList, deletedUUID);
	})
}

//insert uuid list into the form (File uploader)
function insertUUIDintoForm(uploadSuccessFileUUIDList, formId){
	for(key in uploadSuccessFileUUIDList) {
		var elementCheck = document.querySelectorAll('input[value="'+ uploadSuccessFileUUIDList[key] +'"]');
		if(elementCheck.length == 0) {
			var newInput = document.createElement("input");
			newInput.name = "uuidList";
			newInput.type = "hidden";
			newInput.value = uploadSuccessFileUUIDList[key];
			document.getElementById(formId).appendChild(newInput);  
		}
	}
}

//insert uuid list into the form (Editor)
function insertEditorUUIDintoForm(uploadSuccessFileUUIDList, formId){
	for(key in uploadSuccessFileUUIDList) {
		var elementCheck = document.querySelectorAll('input[value="'+ uploadSuccessFileUUIDList[key] +'"]');
		if(elementCheck.length == 0) {
			var newInput = document.createElement("input");
			newInput.name = "editorUuidList";
			newInput.type = "hidden";
			newInput.value = uploadSuccessFileUUIDList[key];
			document.getElementById(formId).appendChild(newInput);  
		}
	}
}

// delete File
function deleteFile(uuid, optionSet, onSuccessFunction){
	
	var url = '/file/deleteFile';
	var sendData = {};
	sendData.qquuid = uuid;
	
	$.ajax({
		type : "post",
		url  : url,
		async: false,
		beforeSend : function(xhr){
			if(optionSet.csrfHeader != undefined && optionSet.csrfToken != undefined){
				xhr.setRequestHeader(optionSet.csrfHeader, optionSet.csrfToken);
			} 
	    },
		data : JSON.stringify(sendData),
		dataType: "json",
		contentType:"application/json;charset=UTF-8",
		success : function(data){
			onSuccessFunction(data);
		}
	})
}


//Set uploadSuccessFileUUIDList From Naver Editor
var setUUIDFromNaverEditor = (uploadSuccessFileUUIDList, editorWrapperId) => {
	uploadSuccessFileUUIDList = [];
	var editorWrapper = document.getElementById(editorWrapperId);
	var selectElements = editorWrapper
						.getElementsByTagName('iframe')[0].contentWindow.document
						.getElementsByTagName('iframe')[0].contentWindow.document.body
						.getElementsByTagName('img');
	
	if(selectElements.length > 0) {
		for(i=0; i<selectElements.length; i++) {
			var uuid = selectElements[i].getAttribute('data-uuid')
			uploadSuccessFileUUIDList.push(uuid);
		}
	} else {
		uploadSuccessFileUUIDList = [];
	}
	return uploadSuccessFileUUIDList;
}

//Set uploadSuccessFileUUIDList From Froala Editor
var setUUIDFromFroalaEditor = (uploadSuccessFileUUIDList, editorWrapperId) => {
	
	uploadSuccessFileUUIDList = [];
	
	var editorWrapper = document.getElementById(editorWrapperId);
	var selectElements = editorWrapper.getElementsByTagName('img');
	
	if(selectElements.length > 0) {
		for(i=0; i<selectElements.length; i++) {
			var uuid = selectElements[i].getAttribute('data-uuid');
			if(uuid != null && uuid != '') {
				uploadSuccessFileUUIDList.push(uuid);
			}
		}
	} else {
		uploadSuccessFileUUIDList = [];
	}
	return uploadSuccessFileUUIDList;
}