import { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';
import { ActivatedRoute } from '@angular/router';
import { timeTypeEnum } from 'afw';
import { DateService, TextResourceService } from 'afw/generic-services';
import { FeedbackStoreService } from 'afw/store-services';
import { List } from 'linqts';
import { Observable, of, zip as observableZip } from 'rxjs';
import { map } from 'rxjs/operators';
import { Beroepsgroep } from 'zorroapiclient/models/beroepsgroep';
import { CertificateInfoResponse } from 'zorroapiclient/models/certificate-info-response';
import { Country } from 'zorroapiclient/models/country';
import { DuoDiplomaNiveau } from 'zorroapiclient/models/duo-diploma-niveau';
import { GetHcpDetailsResponse } from 'zorroapiclient/models/get-hcp-details-response';
import { GetRegistrationResponse } from 'zorroapiclient/models/get-registration-response';
import { Land } from 'zorroapiclient/models/land';
import { MyDataModel } from 'zorroapiclient/models/my-data-model';
import { Nationality } from 'zorroapiclient/models/nationality';
import { PersonDetailsResponse } from 'zorroapiclient/models/person-details-response';
import { ProfessionalGroup } from 'zorroapiclient/models/professional-group';
import { WorkExperienceModel } from 'zorroapiclient/models/work-experience-model';
import { ZaakModel } from 'zorroapiclient/models/zaak-model';
import { CaseApiService } from 'zorroapiclient/services/case-api.service';
import { HcpApiService } from 'zorroapiclient/services/hcp-api.service';
import { ReferenceDataService } from 'zorroshared/services/reference-data-service/reference-data.service';
import { SelfServiceUserService } from '../../../shared/services/self-service-user.service';
import { HcpInfoStoreService, RegistrationInfoStoreService } from '../../../store';
import { NewRegistrationService } from '../new-registration.service';
import { ProfessionalData } from '../professional-data/professional-data';
import { RequiredDocumentsCallbackModel } from './models/required-documents-callback.model';
import { RequiredDocumentsParameters } from './models/required-documents-request.model';

@Component({
    selector: 'ssp-required-documents',
    templateUrl: './required-documents.component.html'
})
export class RequiredDocumentsComponent implements OnInit {
    readonly infoFeedbackKey: string = 'documentsFeedback';
    requiredDocuments: any[] = [];
    isDutchCertificate = false;
    resources: any = {};
    needsUpload: any = false;

    private foreignExperience: boolean = null;
    private professionalGroupCode: string = null;

    private nationalityIsEer: boolean = null;
    private certificateOlderThan3Months: boolean = null;
    private certificateOlderThan1Year: boolean = null;
    private certificateCountryIsEer: boolean = null;
    private certificateOther: boolean = null;
    private hasVvOrEb: boolean = null;

    get isBigLogin() {
        return this.selfServiceUserService.isBigLogin();
    }

    get hasRequiredDocuments() {
        return this.requiredDocuments.length > 0;
    }

    get hasUploadBlock() {
        return this.needsUpload;
    }

    @Input() caseNr: number = null;
    @Input() appendixStyle = false;
    @Input() appendixBlockIndex = 1;
    @Output() messagesFilled: EventEmitter<RequiredDocumentsCallbackModel> = new EventEmitter<RequiredDocumentsCallbackModel>();

    constructor(
        private readonly textResourceService: TextResourceService,
        private readonly route: ActivatedRoute,
        private readonly referenceDataService: ReferenceDataService,
        private readonly registrationInfoStoreService: RegistrationInfoStoreService,
        private readonly newRegistrationService: NewRegistrationService,
        private readonly hcpInfoStoreService: HcpInfoStoreService,
        private readonly feedbackService: FeedbackStoreService,
        private readonly hcpApiService: HcpApiService,
        private readonly caseApiService: CaseApiService,
        private readonly selfServiceUserService: SelfServiceUserService) {
    }

    ngOnInit() {
        observableZip(
            this.referenceDataService.getActiveCountries(),
            this.referenceDataService.getNationalities(),
            this.referenceDataService.getProfessionalGroups(),
            this.hcpInfoStoreService.getState(),
            this.registrationInfoStoreService.getState())
            .subscribe(
                ([countries, nationalities, profGroups, hcpInfo, registrationInfo]:
                    [Country[], Nationality[], ProfessionalGroup[], GetHcpDetailsResponse, GetRegistrationResponse]) => {
                    this.setResources();

                    if (this.caseNr) {
                        this.getDataFromApi(countries, nationalities, profGroups, hcpInfo, registrationInfo)
                            .subscribe((data: RequiredDocumentsParameters) => this.determineRequiredDocs(data));
                    } else {
                        this.useDataFromMemory(countries, nationalities, profGroups, hcpInfo, registrationInfo)
                            .subscribe((data: RequiredDocumentsParameters) => this.determineRequiredDocs(data));
                    }
                }
            );
    }

    private setResources() {
        const resources = this.textResourceService.getComponentResources('RequiredDocumentsComponent', this.route.snapshot.data.routeName);
        if (this.appendixStyle) {
            this.resources = {
                ...resources,
                ...this.textResourceService.getComponentResources('AppendixComponent', this.route.snapshot.data.routeName)
            };
        } else {
            this.resources = resources;
        }
    }

    private determineRequiredDocs(params: RequiredDocumentsParameters): void {
        this.getRequiredDocuments(params)
            .subscribe((messages) => {
                this.requiredDocuments = messages;

                if (!this.appendixStyle) {
                    setTimeout(() => messages.forEach(item => {
                        this.feedbackService.addInfoMessage({
                            feedbackPortalKey: this.infoFeedbackKey,
                            message: { key: item.key, value: item.value }
                        });
                    }));
                }

                this.messagesFilled.emit({
                    isManualCertificate: params.isManualCertificate,
                    hasRequiredDocuments: messages.length > 0,
                    messages
                });
            });
    }

    private getDataFromApi(
        countries: Country[],
        nationalities: Nationality[],
        profGroups: ProfessionalGroup[],
        hcpInfo: GetHcpDetailsResponse,
        registrationInfo: GetRegistrationResponse) {
        return observableZip(
            this.hcpApiService.getPersonDetails(),
            this.hcpApiService.getCertificateInfo(this.caseNr),
            this.caseApiService.getCaseInfo(this.caseNr))
            .pipe(
                // tslint:disable-next-line: max-line-length
                map(([personDetails, certInfo, caseInfo]: [PersonDetailsResponse, CertificateInfoResponse, ZaakModel]) => {
                    this.isDutchCertificate = certInfo.certificateCountry === Land.nederland;

                    const params = new RequiredDocumentsParameters();

                    // refData
                    params.countries = countries;
                    params.hcpInfo = hcpInfo;
                    params.nationalities = nationalities;

                    // certificateData
                    params.certificateCountry = certInfo.certificateCountry;
                    params.certificateDate = certInfo.certificateDate;

                    // professionalGroup
                    params.professionalGroup = caseInfo.beroepsgroepCode;
                    params.professionalCompetenceRegistrations = registrationInfo.professionalCompetenceRegistrations;
                    this.determineNeedsUpload(profGroups, caseInfo.beroepsgroepCode, certInfo.isManualCertificate);

                    // bools
                    params.otherCertificate = certInfo.certificateName === null;
                    params.isManualCertificate = certInfo.isManualCertificate;
                    params.foreignExperience = caseInfo.foreignExperience;
                    params.hasPersonDetails = personDetails.hasPersonDetails;

                    // nationality
                    params.hasDutchNationality = personDetails.hasDutchNationality;

                    if (personDetails.hasPersonDetails) {
                        params.nationality1 = personDetails.nationality1;
                        params.nationality2 = personDetails.nationality2;
                        params.nationality3 = personDetails.nationality3;
                    }

                    return params;
                }));
    }

    private useDataFromMemory(
        countries: Country[],
        nationalities: Nationality[],
        profGroups: ProfessionalGroup[],
        hcpInfo: GetHcpDetailsResponse,
        registrationInfo: GetRegistrationResponse) {
        return observableZip(
            this.newRegistrationService.getDataModelForStep(1),
            this.newRegistrationService.getDataModelForStep(2),
            this.newRegistrationService.getDataModelForStep(3))
            .pipe(
                map(([profDataModel, workExpDataModel, myDataModel]: [ProfessionalData, WorkExperienceModel, MyDataModel]) => {
                    // if no duoCert, value null
                    // if duoCert == "Mijn diploma staat er niet tussen", value is -1
                    const isDuoCertificate = profDataModel.duoCertificateId > 0;
                    const isManualCert = profDataModel.duoCertificateId < 1;

                    this.isDutchCertificate = isDuoCertificate ||
                        (profDataModel.certificateCountry != null && profDataModel.certificateCountry.code === Land.nederland);

                    const params = new RequiredDocumentsParameters();

                    // refData
                    params.countries = countries;
                    params.hcpInfo = hcpInfo;
                    params.nationalities = nationalities;

                    // certificateData
                    params.certificateDate = isDuoCertificate ? profDataModel.duoCertificateDate : profDataModel.certificateDate;
                    params.certificateCountry = this.isDutchCertificate ? Land.nederland : profDataModel.certificateCountry.code;

                    // professionalGroup
                    params.professionalCompetenceRegistrations = registrationInfo.professionalCompetenceRegistrations;
                    params.professionalGroup = profDataModel.professionalGroup.code;
                    this.determineNeedsUpload(profGroups, profDataModel.professionalGroup.code, isManualCert);

                    // bools
                    // if no listedCertificate, value null
                    // if listedCertificateId == "Other", value is -1
                    params.otherCertificate = profDataModel.listedCertificateId === -1;
                    params.hasPersonDetails = myDataModel.personDetails != null;
                    params.foreignExperience = workExpDataModel.foreignExperienceOption;
                    params.isManualCertificate = isManualCert;

                    // nationality
                    if (myDataModel.personDetails != null) {
                        params.hasDutchNationality = myDataModel.personDetails.hasDutchNationality;
                        params.nationality1 = myDataModel.personDetails.nationality1;
                        params.nationality2 = myDataModel.personDetails.nationality2;
                        params.nationality3 = myDataModel.personDetails.nationality3;
                    }

                    return params;
                }));
    }

    private determineNeedsUpload(profGroups: ProfessionalGroup[], profGroupCode: string, isManual: boolean) {
        const pGroups = new List<ProfessionalGroup>(profGroups);
        const pGroup = pGroups.FirstOrDefault(p => p.code === profGroupCode);

        // Diplomaland = Nederland
        // EN	prgr_MinimaleDiplomaniveau != P (postacademisch diploma)
        // EN 	Er is geen diploma uit het diplomaregister geselecteerd
        this.needsUpload =
            this.isDutchCertificate &&
            (pGroup !== null && pGroup.minimalDuoCertificateLevel !== DuoDiplomaNiveau.p) &&
            isManual;
    }

    private getRequiredDocuments(params: RequiredDocumentsParameters): Observable<any[]> {
        this.setRequiredDocumentsSettings(params);

        const identDocs = this.getIdentityRequiredDocuments();
        const certDocs = this.getCertificateRequiredDocuments(params.isManualCertificate);
        const langDocs = this.getLanguageRequiredDocuments();
        const legalDocs = this.getLegalRequiredDocuments();

        return of([...identDocs, ...certDocs, ...langDocs, ...legalDocs]);
    }

    private setRequiredDocumentsSettings(params: RequiredDocumentsParameters) {
        this.requiredDocumentsSettingEerNationality(params);
        this.requiredDocumentsSettingCertificate(params);
        this.requiredDocumentsSettingProfession(params);
        this.foreignExperience = params.foreignExperience;
    }

    private requiredDocumentsSettingEerNationality(params: RequiredDocumentsParameters) {
        if (params.hcpInfo && params.hcpInfo.hcpDetails) {
            this.nationalityIsEer = params.hcpInfo.hcpDetails.hasEerNationality;
        } else if (params.hasPersonDetails) {
            this.nationalityIsEer = params.hasDutchNationality
                || (params.nationality1 &&
                    this.isEerNationality(params.nationalities, params.nationality1))
                || (params.nationality2 &&
                    this.isEerNationality(params.nationalities, params.nationality2))
                || (params.nationality3 &&
                    this.isEerNationality(params.nationalities, params.nationality3));
        }
    }

    private isEerNationality(nationalities: Nationality[], nationalityCodeStr: string): boolean {
        const nationalityCode = parseInt(nationalityCodeStr, 10);
        const nationality = nationalities.find(n => n.code === nationalityCode);
        return nationality && nationality.isEer;
    }

    private requiredDocumentsSettingCertificate(params: RequiredDocumentsParameters) {
        if (params.certificateDate != null) {
            const certDate = DateService.convertStringToDateObject(params.certificateDate);
            this.certificateOlderThan3Months =
                certDate < DateService.offsetTime(new Date(), { offset: -3, timeOffsetType: timeTypeEnum.Month });
            this.certificateOlderThan1Year =
                certDate < DateService.offsetTime(new Date(), { offset: -1, timeOffsetType: timeTypeEnum.Year });
        }

        this.isDutchCertificate = params.certificateCountry === Land.nederland;
        this.certificateCountryIsEer = params.countries
            .some(c =>
                c.isLidEer &&
                c.code === params.certificateCountry);
        this.certificateOther = params.otherCertificate;
    }

    private requiredDocumentsSettingProfession(params: RequiredDocumentsParameters) {
        this.hasVvOrEb = params.professionalCompetenceRegistrations.some(
            pcr => pcr.professionalGroupCode === params.professionalGroup && !pcr.expired
        );
        this.professionalGroupCode = params.professionalGroup;
    }

    private getIdentityRequiredDocuments(): any[] {
        const result = [];
        if (this.selfServiceUserService.isBigLogin()) {
            // [Preconditie: Ingelogd met BIG-login]
            result.push({ key: 'requiredDocumentsType1', value: this.resources.requiredDocumentsType1 });

            // [Preconditie: Ingelogd met BIG-login EN NIET VVofEB]
            if (!this.hasVvOrEb) {
                result.push({ key: 'requiredDocumentsType2', value: this.resources.requiredDocumentsType2 });
            }
        }

        if (!this.isDutchCertificate && !this.nationalityIsEer && !this.hasVvOrEb) {
            // [Preconditie: Diplomaland != Nederland EN Nationaliteit != EER EN NIET VVofEB]
            result.push({ key: 'requiredDocumentsType3', value: this.resources.requiredDocumentsType3 });
        }

        return result;
    }

    private getCertificateRequiredDocuments(isManualCertificate: boolean): any[] {
        const result = [];
        if (isManualCertificate) {
            if (this.isDutchCertificate) {
                // [Preconditie: Diplomaland=Nederland ]
                result.push({ key: 'requiredDocumentsType4', value: this.resources.requiredDocumentsType4 });
            }

            if (!this.isDutchCertificate && !this.hasVvOrEb) {
                // [Preconditie: Diplomaland != Nederland EN NIET VVofEB ]
                result.push({ key: 'requiredDocumentsType5', value: this.resources.requiredDocumentsType5 });
                // [Preconditie: Diplomaland != Nederland EN NIET VVofEB]
                result.push({ key: 'requiredDocumentsType6', value: this.resources.requiredDocumentsType6 });

                // [Preconditie: Diplomaland != Nederland EN Diplomaland=EER EN Diploma="Een ander diploma" EN NIET VVofEB ]
                if (this.certificateCountryIsEer && this.certificateOther) {
                    result.push({ key: 'requiredDocumentsType7', value: this.resources.requiredDocumentsType7 });
                }
            }
        }

        return result;
    }

    private getLanguageRequiredDocuments(): any[] {
        const result = [];

        if (!this.isDutchCertificate ||
            parseInt(this.professionalGroupCode, 10) === parseInt(Beroepsgroep.fysiotherapeuten.toString(), 10)) {
            // [Preconditie: Diplomaland ≠ Nederland OF Beroep != Fysiotherapeut]
            result.push({ key: 'requiredDocumentsType8', value: this.resources.requiredDocumentsType8 });
        }

        return result;
    }

    private getLegalRequiredDocuments(): any[] {
        const result = [];

        if ((this.isDutchCertificate && this.certificateOlderThan1Year && this.foreignExperience) ||
            (!this.isDutchCertificate && this.certificateOlderThan3Months)) {
            // [Preconditie:
            // ( Diplomaland=Nederland EN Diploma is ouder dan 1 jaar EN Werkervaring buitenland )
            // OF
            // ( Diplomaland ≠ Nederland EN Diploma is ouder dan 3 mnd )]
            result.push({ key: 'requiredDocumentsType9', value: this.resources.requiredDocumentsType9 });
        }

        if (!this.isDutchCertificate || this.foreignExperience) {
            // [Preconditie: Diplomaland Nederland OF WerkervaringBuitenland=Ja]
            result.push({ key: 'requiredDocumentsType10', value: this.resources.requiredDocumentsType10 });
            // [Preconditie: Diplomaland Nederland OF WerkervaringBuitenland=Ja]
            result.push({ key: 'requiredDocumentsType11', value: this.resources.requiredDocumentsType11 });
        }

        return result;
    }
}