import { Member } from './../../../membership-models/member.model';
import { MembershipApiService } from './../../../membership-serivce/membership.api';
import { Application } from './../../../../nots-common/api/models/application.model';
import { FormBuilder, FormArray, Validators, FormGroup, FormControl } from '@angular/forms';
import { Loadable } from './../../../../nots-utils/xLoader/loadable.base';
import { Component, OnInit } from '@angular/core';
import { MembershipEnablementDetails } from 'app/nots-membership/membership-models/membershipEnablementDetails.model';
import { ConnectionIPDetails } from 'app/nots-membership/membership-models/connectionIPDetails.model';
import { EnablementValidators } from 'app/nots-membership/custom-validators/customValidator';

@Component({
    selector: 'app-membership-connection',
    templateUrl: './membership-connection.component.html',
    styleUrls: ['./membership-connection.component.css']
})
export class MembershipConnectionComponent extends Loadable implements OnInit {
    model: MembershipEnablementDetails;
    mode = 'new';
    connectionIPSForm: FormGroup;
    member: Member;
    invalidIpFormControls: Array<FormControl> = [];

    constructor(private formBuilder: FormBuilder,
        private apiService: MembershipApiService,
        private enablementValidator: EnablementValidators) { super(); }

    ngOnInit() {
        this.apiService.getMemberByID(this.model.member.id).then(response => {
            this.member = response;
            console.log(this.member);
        }).catch(err => {
            console.dir(err);
        });
    }

    createIP(): FormGroup {
        const octet = '(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[1-9][0-9]|[0-9])';
        const ip = '(?:' + octet + '\\.){3}' + octet;
        const quad = '(?:\\[' + ip + '\\])|(?:' + ip + ')';
        const ipRE = new RegExp('(' + quad + ')');
        return this.formBuilder.group({
            connectionNumber: ['', Validators.required],
            ip: ['', [Validators.required, Validators.pattern(ipRE), this.uniqueIPS.bind(this)],
                this.enablementValidator.checkIP.bind(this)],
            location: ['', Validators.required]
        });
    }

    uniqueIPS(control: FormControl): any {
        if (this.model.notsConnectionIDS.map(item => item.connectionIPS).filter(ip => ip === control.value).length > 1) {
            if (!this.invalidIpFormControls.includes(control)) {
                this.invalidIpFormControls.push(control);
            }
            return { 'error': true };
        }
        this.invalidIpFormControls.forEach(item => {
            if (item != control) {
                this.invalidIpFormControls = this.invalidIpFormControls.filter(item2 => item2 !== control);
                item.reset(item.value);
            }
        });
        return null;
    }

    doMagic() {
        this.connectionIPSForm.reset(this.connectionIPSForm.value);
    }
    addFormDetail() {
        const control = <FormArray>this.connectionIPSForm.controls['connectionIPS'];
        control.push(this.createIP());
        this.model.notsConnectionIDS.push(new ConnectionIPDetails());
    }

    removeFormDetail(i: number) {
        const control = <FormArray>this.connectionIPSForm.controls['connectionIPS'];
        control.removeAt(i);
        this.model.notsConnectionIDS.splice(i, 1);
    }

    loadDataObject(data: Application, loaderId?: String) {
        this.model = data.memberEnablementDetails;
        this.connectionIPSForm = this.formBuilder.group({
            connectionIPS: this.formBuilder.array([])
        });
    }

    onSave() {
        return new Promise((resolve, reject) => {
            resolve(this.connectionIPSForm.valid);
        });
    }

    isValid() { return new Promise((resolve, reject) => { resolve(this.connectionIPSForm.valid); }); }

    loaded(loaderId?: String) {
        if (this.model.notsConnectionIDS.length === 0) {
            this.model.notsConnectionIDS.push(new ConnectionIPDetails());
        }

        const control = <FormArray>this.connectionIPSForm.controls['connectionIPS'];
        this.model.notsConnectionIDS.forEach(item => {
            control.push(this.createIP());
        });

        console.log(control);
    }



}