import { Component, Inject, OnInit } from '@angular/core';
import { MAT_DIALOG_DATA, MatDialogRef } from '@angular/material/dialog';
import { Router } from '@angular/router';
import { DescriptionStatus } from '@app/core/common/enum/description-status';
import { DmpAccessType } from '@app/core/common/enum/dmp-access-type';
import { Dmp } from '@app/core/model/dmp/dmp';
import { DescriptionService } from '@app/core/services/description/description.service';
import { DmpService } from '@app/core/services/dmp/dmp.service';
import { BaseComponent } from '@common/base/base.component';
import { Guid } from '@common/types/guid';
import { takeUntil } from 'rxjs/operators';


@Component({
	selector: 'app-dmp-finalize-dialog-component',
	templateUrl: 'dmp-finalize-dialog.component.html',
	styleUrls: ['./dmp-finalize-dialog.component.scss']
})
export class DmpFinalizeDialogComponent extends BaseComponent implements OnInit {

	dmp: Dmp;
	isDmpValid: boolean;
	dmpErrors: string[];
	dmpAccessTypeEnum = DmpAccessType;
	descriptionStatusEnum = DescriptionStatus;
	descriptionValidationOutputEnum = DescriptionValidationOutput;
	validationResults: DescriptionValidationResult[] = [];
	descriptionsToBeFinalized: Guid[] = [];
	descriptionValidationOutputMap = new Map<Guid, DescriptionValidationOutput>();

	constructor(
		public router: Router,
		public dialogRef: MatDialogRef<DmpFinalizeDialogComponent>,
		public descriptionService: DescriptionService,
		private dmpService: DmpService,
		@Inject(MAT_DIALOG_DATA) public data: any
	) {
		super();
		this.dmp = data.dmp;
	}

	ngOnInit(): void {
		this.dmpService.validate(this.dmp.id).pipe(takeUntil(this._destroyed),
		).subscribe(result => {
			if (result.result === DmpValidationOutput.Valid){
				this.validateDescriptions(this.dmp);
				this.isDmpValid = true;
			}else{
				this.isDmpValid = false;
				this.dmpErrors = result.errors;
			}
		});
	}

	isDescriptionValid(descriptionId: Guid): boolean {
		const result = this.validationResults.find(x => x.descriptionId == descriptionId)?.result === DescriptionValidationOutput.Valid;
		if (result){
			this.descriptionValidationOutputMap.set(descriptionId, DescriptionValidationOutput.Valid);
		} else{
			this.descriptionValidationOutputMap.set(descriptionId, DescriptionValidationOutput.Invalid);
		}
		return result;
	}

	onSubmit() {
		this.dialogRef.close({ descriptionsToBeFinalized: this.descriptionsToBeFinalized } as DmpFinalizeDialogOutput);
	}

	getFinalizedDescriptions() {
		if (!this.dmp.descriptions) return [];
		const finalizedDescriptions = this.dmp.descriptions.filter(x => x.status === DescriptionStatus.Finalized);
		if (finalizedDescriptions?.length > 0){
			finalizedDescriptions.forEach(finalize => {
				this.descriptionValidationOutputMap.set(finalize.id, DescriptionValidationOutput.Valid);
			})
		}
		return finalizedDescriptions;
	}

	close() {
		this.dialogRef.close({ cancelled: true } as DmpFinalizeDialogOutput);
	}

	validateDescriptions(dmp: Dmp) {
		if (!dmp.descriptions?.some(x => x.status == DescriptionStatus.Draft)) return;

		const draftDescriptions = this.dmp.descriptions.filter(x => x.status == DescriptionStatus.Draft) || [];
		if ( draftDescriptions.length > 0){
			draftDescriptions.forEach(draft => {
				this.descriptionValidationOutputMap.set(draft.id, DescriptionValidationOutput.Pending);
			});
		}

		this.descriptionService.validate(dmp.descriptions.filter(x => x.status == DescriptionStatus.Draft).map(x => x.id)).pipe(takeUntil(this._destroyed),
		).subscribe(result => {
			this.validationResults = result;
		});
	}

	get validDraftDescriptions() {
		if (!this.dmp.descriptions) return [];
		return this.dmp.descriptions.filter(x => this.validationResults.some(y => y.descriptionId == x.id && y.result == DescriptionValidationOutput.Valid));
	}
}

export interface DescriptionValidationResult {
	descriptionId: Guid;
	result: DescriptionValidationOutput;
}

export enum DescriptionValidationOutput {
	Valid = 1,
	Invalid = 2,
	Pending = 3
}

export interface DmpValidationResult {
	id: Guid;
	result: DmpValidationOutput;
	errors: string[];
}

export enum DmpValidationOutput {
	Valid = 1,
	Invalid = 2
}


export interface DmpFinalizeDialogOutput {
	cancelled?: boolean;
	descriptionsToBeFinalized?: Guid[];
}