import { Component, OnInit } from '@angular/core';
import { AbstractControl, FormArray, FormControl, FormGroup } from '@angular/forms';
import { MatSnackBar } from '@angular/material';
import { ActivatedRoute, Params, Router } from '@angular/router';
import { TdDialogService } from '@covalent/core';
import { TranslateService } from '@ngx-translate/core';
import { Observable } from 'rxjs';
import { takeUntil } from 'rxjs/operators';
import { environment } from '../../../environments/environment';
import { BaseComponent } from '../../core/common/base/base.component';
import { BaseErrorModel } from '../../models/error/BaseErrorModel';
import { ProjectModel, ProjectType } from '../../models/projects/ProjectModel';
import { ProjectFileUploaderService } from '../../services/files/project-file-uploader.service';
import { LanguageResolverService } from '../../services/language-resolver/language-resolver.service';
import { ProjectService } from '../../services/project/project.service';
import { BreadcrumbItem } from '../../shared/components/breadcrumb/definition/breadcrumb-item';
import { IBreadCrumbComponent } from '../../shared/components/breadcrumb/definition/IBreadCrumbComponent';
import { SnackBarNotificationComponent } from '../../shared/components/notificaiton/snack-bar-notification.component';
import { JsonSerializer } from '../../utilities/JsonSerializer';

@Component({
	selector: 'app-project-editor-component',
	templateUrl: 'project-editor.component.html',
	styleUrls: ['./project-editor.component.scss']
})
export class ProjectEditorComponent extends BaseComponent implements OnInit, IBreadCrumbComponent {

	breadCrumbs: Observable<BreadcrumbItem[]> = Observable.of([]);
	isNew = true;
	project: ProjectModel;
	formGroup: FormGroup = null;
	host = environment.Server;
	editMode = false;
	constructor(
		private projectService: ProjectService,
		private route: ActivatedRoute,
		public snackBar: MatSnackBar,
		public router: Router,
		public language: TranslateService,
		private dialogService: TdDialogService,
		private uploaderService: ProjectFileUploaderService,
		private languageResolverService: LanguageResolverService
	) {
		super();
	}

	ngOnInit() {
		this.route.params
			.pipe(takeUntil(this._destroyed))
			.subscribe((params: Params) => {
				const itemId = params['id'];

				if (itemId != null) {
					this.isNew = false;
					this.projectService.getSingle(itemId).map(data => data as ProjectModel)
						.pipe(takeUntil(this._destroyed))
						.subscribe(data => {
							this.project = JsonSerializer.fromJSONObject(data, ProjectModel);
							this.formGroup = this.project.buildForm(null, this.project.type === ProjectType.External || !this.editMode);
							this.breadCrumbs = Observable.of([
								{ parentComponentName: 'ProjectListingComponent', label: 'Projects', url: '/projects' },
							]);
						});
				} else {
					this.breadCrumbs = Observable.of([
						{ parentComponentName: 'ProjectListingComponent', label: 'Projects', url: '/projects' },
					]);
					this.project = new ProjectModel();
					setTimeout(() => {
						this.formGroup = this.project.buildForm();
					});
				}
			});
	}

	formSubmit(): void {
		this.touchAllFormFields(this.formGroup);
		if (!this.isFormValid()) { return; }
		this.onSubmit();
	}

	public isFormValid() {
		return this.formGroup.valid;
	}

	onSubmit(): void {
		this.projectService.createProject(this.formGroup.value)
			.pipe(takeUntil(this._destroyed))
			.subscribe(
				complete => this.onCallbackSuccess(),
				error => this.onCallbackError(error)
			);
	}

	onCallbackSuccess(): void {
		this.snackBar.openFromComponent(SnackBarNotificationComponent, {
			data: { message: this.isNew ? 'GENERAL.SNACK-BAR.SUCCESSFUL-CREATION' : 'GENERAL.SNACK-BAR.SUCCESSFUL-UPDATE', language: this.language },
			duration: 3000,
		});
		this.router.navigate(['/projects']);
	}

	onCallbackError(errorResponse: any) {
		this.setErrorModel(errorResponse.error.payload);
		this.validateAllFormFields(this.formGroup);
	}

	public setErrorModel(errorModel: BaseErrorModel) {
		Object.keys(errorModel).forEach(item => {
			(<any>this.project.errorModel)[item] = (<any>errorModel)[item];
		});
	}

	public cancel(): void {
		this.router.navigate(['/projects']);
	}

	public delete(): void {
		this.language.get('GENERAL.DELETE-CONFIRMATION')
			.pipe(takeUntil(this._destroyed))
			.subscribe((messages: any) => {
				this.dialogService.openConfirm({
					message: messages.MESSAGE,
					title: messages.TITLE,
					cancelButton: messages.NEGATIVE,
					acceptButton: messages.POSITIVE
				}).afterClosed()
					.pipe(takeUntil(this._destroyed))
					.subscribe((accept: boolean) => {
						if (accept) {
							this.projectService.inactivate(this.project.id)
								.pipe(takeUntil(this._destroyed))
								.subscribe(
									complete => { this.router.navigate(['/projects']); },
									error => this.onCallbackError(error)
								);
						}
					});
			});
	}

	public touchAllFormFields(formControl: AbstractControl) {
		if (formControl instanceof FormControl) {
			formControl.markAsTouched();
		} else if (formControl instanceof FormGroup) {
			Object.keys(formControl.controls).forEach(item => {
				const control = formControl.get(item);
				this.touchAllFormFields(control);
			});
		} else if (formControl instanceof FormArray) {
			formControl.controls.forEach(item => {
				this.touchAllFormFields(item);
			});
		}
	}

	public validateAllFormFields(formControl: AbstractControl) {
		if (formControl instanceof FormControl) {
			formControl.updateValueAndValidity({ emitEvent: false });
		} else if (formControl instanceof FormGroup) {
			Object.keys(formControl.controls).forEach(item => {
				const control = formControl.get(item);
				this.validateAllFormFields(control);
			});
		} else if (formControl instanceof FormArray) {
			formControl.controls.forEach(item => {
				this.validateAllFormFields(item);
			});
		}
	}

	public enableForm() {
		if (!this.isExternalProject()) {
			this.editMode = true;
			this.formGroup.enable();
		}
	}

	public disableForm() {
		this.editMode = false;
		this.formGroup.disable();
	}

	public goToProjectDmps() {
		this.router.navigate(['dmps/project/' + this.project.id], { queryParams: { projectLabel: this.project.label } });
	}

	public isExternalProject() {
		return this.project.type === ProjectType.External;
	}

	public previewImage(event): void {
		const fileList: FileList | File = event.target.files;

		const formdata: FormData = new FormData();

		if (fileList instanceof FileList) {
			for (let i = 0; i < fileList.length; i++) {
				formdata.append('file', fileList[i]);
			}
		} else {
			formdata.append('file', fileList);
		}
		this.uploaderService.uploadFile(formdata)
			.pipe(takeUntil(this._destroyed))
			.subscribe(files => this.formGroup.get('files').patchValue(files));
	}
}