import Controller from '@ember/controller';
import { inject as service } from '@ember/service';

import config from '../../config/environment';
import Ember from 'ember';

const { get, set } = Ember;

export default Controller.extend({
	newsManagement : service(),
	newsManagementData : service(),
	coreUserGroupData : service(),
	statusData : service(),
	coreAttachmentData : service(),
	dealerData : service(),
	newsManagementDealerData : service(),
	session : service(),
	errors : service(),
	didValidate: false,
	rightActionInProgress: false,
    disabled: false,
	sendTos: Array(),
	statuss: Array(),
	images: Array(),
	fileAttachments: Array(),
	dealers: Array(),

	formConfig : {
		tittle : { isEditable : true }, 
		sendTo : { isEditable : true }, 
		startTime : { isEditable : true }, 
		endTime : { isEditable : true }, 
		status : { isEditable : true }, 
		message : { isEditable : true }, 
		image : { isEditable : true }, 
		fileAttachment : { isEditable : true }, 
		videoURL : { isEditable : true }, 
		newsManagementDealer : { 
			newsManagement : { isEditable : true }, 
			dealer : { isEditable : true }, 
		},
	},
	init() {
		this._super(...arguments);
		var sendTos = this.coreUserGroupData.getList();
		this.set("sendTos", sendTos);

        let filter='';
        filter = JSON.parse("{\"is_combo_news\" : \"" + true + "\"}");
		var statuss = this.statusData.getList({
            filter: filter
        });
		this.set("statuss", statuss);

		var dealers = this.dealerData.getList();
		this.set("dealers", dealers);

	},

	actions: {
		onChangeCombo(propertyName, itemCollection) {
			this.set(propertyName, itemCollection);
		},

		async saveNewsManagement(changeset) {
			this.set("rightActionInProgress", true);
			this.get('model')
				.validate()
				.then(async ({ validations }) => {
					this.set('didValidate', true); 
					if (validations.get('isValid')) {
						let imageDoc = get(changeset, 'image');
						if (imageDoc) {
							let fileImage = imageDoc;
							let currentModel = this.get('model');

							let imageAttachment = this.store.createRecord('core-attachment', {
								currentModel,
								originalFilename: get(fileImage, 'name'), 
								fileSize: get(fileImage, 'size')
							});
							if (fileImage.state != undefined && fileImage.state != "uploaded") {
								await fileImage.upload(config.APP.api.uploadPath, {
									headers: {Authorization: `Bearer ${this.session.data.authenticated.access_token}`}
								})
								.then(async response=> {
									set(imageAttachment, 'fileExtension', response.body.file_extension);
									set(imageAttachment, 'uploadedFilename', response.body.uploaded_filename);
									set(imageAttachment, 'originalFilename', response.body.original_filename);
									set(imageAttachment, 'url', response.headers.Location);

									await imageAttachment.save().then(() => {
										this.set('model.image', imageAttachment);
									});

								})
								.catch((error)=>{
									this.set("rightActionInProgress", false);
									console.log(error);
									alert("Failed to upload image");
								});
								console.log("image uploaded");
							}
						}

						let fileAttachmentDoc = get(changeset, 'fileAttachment');
						if (fileAttachmentDoc) {
							let fileFileAttachment = fileAttachmentDoc;
							let currentModel = this.get('model');

							let fileAttachmentAttachment = this.store.createRecord('core-attachment', {
								currentModel,
								originalFilename: get(fileFileAttachment, 'name'), 
								fileSize: get(fileFileAttachment, 'size')
							});
							if (fileFileAttachment.state != undefined && fileFileAttachment.state != "uploaded") {
								await fileFileAttachment.upload(config.APP.api.uploadPath, {
									headers: {Authorization: `Bearer ${this.session.data.authenticated.access_token}`}
								})
								.then(async response=> {
									set(fileAttachmentAttachment, 'fileExtension', response.body.file_extension);
									set(fileAttachmentAttachment, 'uploadedFilename', response.body.uploaded_filename);
									set(fileAttachmentAttachment, 'originalFilename', response.body.original_filename);
									set(fileAttachmentAttachment, 'url', response.headers.Location);

									await fileAttachmentAttachment.save().then(() => {
										this.set('model.fileAttachment', fileAttachmentAttachment);
									});

								})
								.catch((error)=>{
									this.set("rightActionInProgress", false);
									console.log(error);
									alert("Failed to upload fileAttachment");
								});
								console.log("fileAttachment uploaded");
							}
						}

						this.set('newsManagement.model.isApprovalData', false);
						this.newsManagementData.save(this.newsManagement.model).then(response => {
							if (response != undefined) {
								this.set("rightActionInProgress", false);
								this.transitionToRoute('news-management.detail', response.id); 
							}
						})
						.catch((e) => {
							this.set("rightActionInProgress", false);
							this.set('errorMessages', this.errors.getErrorMessages(e));
							window.scrollTo(0, 0);
						});
					} else {
						this.set("rightActionInProgress", false);
					}
			}); 
		},

		addRowData(modal_type) {
			if (modal_type == "news-management-dealer") {
				let data = this.newsManagementDealerData.createRecord();
				this.newsManagement.addRow(data, "newsManagementDealer");
			}
		},
		deleteRowData(modal_type, data) {
			if (modal_type == "news-management-dealer") {
				this.newsManagement.deleteRow(data, "newsManagementDealer");
			}
		},
		uploadImage(changeset, propName, file) {
			changeset.set(propName, file);
		},
	},
});