import {Entity} from "./entity";
import {DsProjectRoomBlock, DsProjectRoomBlockField, DsProjectRoomData} from "../dynamic-labeling-room/entities";
import {ExampleEntityData} from "./example-entity-data";

export class ValidUserEmail implements Entity {
    private _email: string;
    private _valid_emails: any[] = [];
    private _hints: any[] = [];
    private _prob: number = -1;
    private _is_valid: number = -1;
    private _version: string = '';
    private _exampleEntityData: ExampleEntityData = new ExampleEntityData('valid-user-email');

    constructor(obj?) {
        if (obj) {
            if (obj.valid_emails) {
                this._valid_emails = obj.valid_emails;
            }
            if (obj.email) {
                this._email = obj.email;
            }
            if (obj.hints) {
                for (const i in obj.hints) {
                    this._hints.push((obj.hints[i]));
                }
            }
            if (obj.prob > -1) {
                this._prob = obj.prob;
            }
            if (obj.version) {
                this._version = obj.version;
            }
            if (obj.is_valid > -1) {
                this._is_valid = obj.is_valid;
            }
            if (obj.pred && obj.pred.email) {
                this._email = obj.pred.email;
            }
            if (obj.pred && obj.pred.is_valid !== undefined) {
                this._is_valid = obj.pred.is_valid;
            }

            if (obj.res && obj.res.email) {
                this._email = obj.res.email;
            }
            if (obj.res && obj.res.is_valid !== undefined) {
                this._is_valid = obj.res.is_valid;
            }
        }
    }

    get valid_emails(): any[] {
        return this._valid_emails;
    }

    set valid_emails(value: any[]) {
        this._valid_emails = value;
    }

    get email(): string {
        return this._email;
    }

    set email(value: string) {
        this._email = value;
    }

    get hints(): any[] {
        return this._hints;
    }

    set hints(value: any[]) {
        this._hints = value;
    }

    get prob(): number {
        return this._prob;
    }

    set prob(value: number) {
        this._prob = value;
    }

    get is_valid(): number {
        return this._is_valid;
    }

    set is_valid(value: number) {
        this._is_valid = value;
    }

    get version(): string {
        return this._version;
    }

    set version(value: string) {
        this._version = value;
    }

    public toDsProjectRoom() {
        const data: DsProjectRoomData = new DsProjectRoomData({
            text: this._exampleEntityData.getExampleData(),
            url: '',
            showInIframe: false
        });
        const blocks = [
            {
                blockName: '',
                blockDesc: '',
                numColumns: 4,
                fields: []
            }];
        const final = [];
        for (const similarTitle of this._exampleEntityData.getExampleLinkedData()) {
            const objTitle = {label: similarTitle, inputType: 'checkbox'};
            blocks[0].fields.push(objTitle);
        }
        for (const i in blocks) {
            final.push(new DsProjectRoomBlock(blocks[i]));
        }
        return {blocks: final, data: data};
    }

    public fromDsProjectRoom(obj: DsProjectRoomBlock[], data: DsProjectRoomData) {
        const validUserEmail = {
            text: data.text,
            valid_emails: []
        };
        let block: DsProjectRoomBlock;
        for (block of obj) {
            validUserEmail.valid_emails = [];
            let field: DsProjectRoomBlockField;
            for (field of block.fields) {
                if (field.value) {
                    validUserEmail.valid_emails.push(field.label);
                }
            }
        }
        return new ValidUserEmail(validUserEmail);
    }

    public toJSON() {
        return {
            email: this.email,
            hints: this.hints,
            prob: this.prob,
            is_valid: this.is_valid,
            version: this.version,
        };
    }

    public toNerEntities(type = 1) {
        return {
            relationOptions: [],
            entities: {
                email: this.email,
                hints: ''
            }
        };
    }

    nerEntityTypeOptions(): any[] {
        return [];
    }
}