import { Component, Inject, OnInit } from '@angular/core';
import { NgbActiveModal } from '@ng-bootstrap/ng-bootstrap';
import { UnsubscribableComponent } from '../../../../../services/common/self-unsubscribable';
import { IdNamePair, SecurityDepositCreateModel } from '../../../../../services/gateway/domain.models';
import { ICallSessionService } from '../../../../../services/common/call-session.service';
import { ISecurityDepositClient } from '../../../../../services/gateway/security-deposit.client';
import { FormBuilder, FormControl, FormGroup, Validators } from '@angular/forms';
import { Observable } from 'rxjs/Observable';
import { ISecurityDepositOptionClient } from '../../../../../services/gateway/security-deposit-option.client';
import { shouldControlDisplayErrorMessage, validatorPositive } from '../../../../../services/utils/validatorBuilder';
import { IAccountClassClient } from '../../../../../services/gateway/account-class.client';

@Component({
    selector: 'create-security-deposit',
    templateUrl: './create-security-deposit.component.html',
    styleUrls: ['./create-security-deposit.component.less']
})

export class CreateSecurityDepositComponent extends UnsubscribableComponent implements OnInit {
    constructor(public activeModal: NgbActiveModal,
                private fb: FormBuilder,
                @Inject('ISecurityDepositClient') private securityDepositClient: ISecurityDepositClient,
                @Inject('ISecurityDepositOptionClient') private securityDepositOptionClient: ISecurityDepositOptionClient,
                @Inject('IAccountClassClient') private accountClassClient: IAccountClassClient,
                @Inject('ICallSessionService') private callSessionService: ICallSessionService) {
        super();
    }

    public fullAmount: number;
    public successMessages: string[] = [];
    public errorMessage: string;
    public createDepositForm: FormGroup;
    public amount: number;
    public reason: IdNamePair;
    public option: IdNamePair;
    public securityDepositReasons: IdNamePair[] = [new IdNamePair("1","1")];
    public securityDepositOptions: IdNamePair[] = [new IdNamePair("1","1")];
    public isCreateButtonEnabled = true;
    public maxAmountLength = 9;
    private accountId: string;
    private accountClassId = '';
    private createFailedMessage = 'An error has occurred during security deposit creation.';
    private initialGetFailedMessage = 'An error has occurred during full amount retrieval.';
    private residentialAccountClassId = 'RES';

    public ngOnInit(): void {
        this.initializeFormGroup();
        this.loading = true;
        this.accountId = this.callSessionService.currentSessionSnapshot.AccountId;

        Observable.forkJoin(
            this.securityDepositOptionClient.getSecurityDepositOptions(),
            this.securityDepositClient.getSecurityDepositReasons(),
            this.accountClassClient.getAccountClassIdByAccountId(this.accountId),
            this.securityDepositClient.getSecurityDepositAmount(this.accountId)
        )
            .takeWhile(() => this.isAlive)
            .finally(() => {
                this.loading = false;
            })
            .subscribe(([securityDepositOptions, securityDepositReasons, accountClassId, fullAmount]) => {
                this.securityDepositOptions = securityDepositOptions.filter((option) => !this.isOptionDisabled(option.Id));
                this.securityDepositReasons = securityDepositReasons;
                this.accountClassId = accountClassId;
                this.createDepositForm.setValue({
                    amount: fullAmount,
                    fullAmount: fullAmount,
                    option: this.securityDepositOptions[0].Id,
                    reason: this.securityDepositReasons[0].Id
                });
            }, () => {
                this.errorMessage = this.initialGetFailedMessage;
            });
    }

    public onCreateClicked(): void {
        const model = this.buildCreateModel();

        this.loading = true;
        this.securityDepositClient.createSecurityDeposit(model)
            .finally(() => {
                this.loading = false;
            })
            .subscribe((createdDocumentNumbers: Array<string>) => {
                    this.successMessages.length = 0;
                    for (const documentNumber of createdDocumentNumbers) {
                        this.successMessages.push(`Successfully created security deposit with document number ${documentNumber}`);
                    }
                    this.isCreateButtonEnabled = false;
                }, () => {
                    this.errorMessage = this.createFailedMessage;

                }
            );
    }

    public shouldDisplayAmountErrorMessage(control: FormControl) {
        return this.shouldDisplayErrorMessage(control) && control.value > 0;
    }

    public shouldDisplayErrorMessage(control: FormControl): boolean {
        return shouldControlDisplayErrorMessage(control);
    }

    public isOptionDisabled(optionId: string) {
        return this.isOptionSplitInThree(optionId) && this.isAccountResidential(this.accountClassId);
    }

    private buildCreateModel(): SecurityDepositCreateModel {
        const model = new SecurityDepositCreateModel();
        model.AccountId = this.accountId;
        model.Amount = this.createDepositForm.controls['amount'].value;
        model.OptionId = this.createDepositForm.controls['option'].value;
        model.ReasonId = this.createDepositForm.controls['reason'].value;
        return model;
    }

    private initializeFormGroup(): void {
        this.createDepositForm = this.fb.group({
            fullAmount: this.fb.control({ value: this.fullAmount, disabled: true }, Validators.required),
            amount: ['', Validators.compose([Validators.required, validatorPositive()])],
            reason: [new IdNamePair('1','1'), Validators.required],
            option: [new IdNamePair('1','1'), Validators.required]
        });
    }

    private isOptionSplitInThree(optionId: string): boolean {
        return optionId === 'false';
    }

    private isAccountResidential(accountClassId): boolean {
        return accountClassId === this.residentialAccountClassId;
    }
}