import { Injectable } from '@angular/core';
import { DropdownField } from '../../app/form/fields/dropdown/field-dropdown';
import { FieldBase } from '../../app/form/fields/field-base';
import { TextboxField } from '../../app/form/fields/textbox/field-textbox';
import { CheckBoxField } from '../../app/form/fields/checkbox/field-checkbox';
import { RadioBoxField } from '../../app/form/fields/radiobox/field-radiobox';
import { DataModel } from '../entities/DataModel';
import { Rule } from '../entities/common/rule';
import { GroupBase } from '../form/dynamic-form-group/group-base';
import { Attribute } from '../entities/model/attribute';
import { Param } from '../entities/model/param';
import { Section } from '../entities/model/section';
import { RestBase } from '../services/rest-base';

@Injectable()
export class dataModelBuilder {

    private dataModel: DataModel;
    private fields: FieldBase<any>[];

    constructor(private restBase: RestBase) { }

    public getDataModel(data) {

        if (this.dataModel != null)
            return this.dataModel;

        this.dataModel = new DataModel();
        this.fields = this.buildFields(data.dataset.profile.viewstyle.definition.root.fields.field);
        this.dataModel.groups = this.getGroups(data.dataset.profile.viewstyle.definition.root.fieldGroups.fieldGroup, this.fields);
        this.dataModel.semanticAttr = new Array(new Attribute);
        //this.dataModel.semanticAttr = data.dataset.profile.definition.root.fields.field;
        this.dataModel.semanticAttr = this.getFieldsAttributes(data.dataset.profile.definition.root.fields.field, data.dataset.profile.ruleset.definition.root.functions.function, this.fields);
        this.dataModel.sections = this.getSections(data.dataset.profile.viewstyle.definition.root.sections.section, this.dataModel.groups);
        this.dataModel.buildIndex();

        return this.dataModel;
    }


    private buildFields(fields: any[]) {
        let fieldsVisible: FieldBase<any>[] = [];
        fields.forEach(element => {
            if (element.viewStyle._renderstyle == "freetext") {
                let newfield: FieldBase<any>;
                let rule = new Rule();
                newfield = new TextboxField({
                    label: element.title.__cdata,
                    key: element._id,
                    value: element.value,
                    order: element._ordinal,
                    rules: element.visible.rule != undefined ? element.visible.rule : rule,
                    visible: element._defaultVisibility,
                    group: element._group,
                    description: element.description.__cdata
                });

                fieldsVisible.push(newfield);
            }
            else if (element.viewStyle._renderstyle == "dropdown" || element.viewStyle._renderstyle == "combobox") {//to choose one of these in xml
                let newfield: DropdownField;
                let rule = new Rule();
                newfield = new DropdownField({
                    label: element.title.__cdata,
                    key: element._id,
                    value: element.value,
                    order: element._ordinal,
                    rules: element.visible.rule != undefined ? element.visible.rule : rule,
                    visible: element._defaultVisibility,
                    description: element.description.__cdata,
                    group: element._group
                });
                fieldsVisible.push(newfield);
            }
            else if (element.viewStyle._renderstyle == "checkbox" || element.viewStyle._renderstyle == "checkBox") {
                let newfield: CheckBoxField;
                let rule = new Array<Rule>();
                newfield = new CheckBoxField({
                    label: element.title.__cdata,
                    key: element._id,
                    value: element.value,
                    order: element._ordinal,
                    rules: element.visible.rule != undefined ? element.visible.rule : rule,
                    visible: element._defaultVisibility,
                    group: element._group,
                    description: element.description.__cdata,
                    type: "checkbox"
                });
                fieldsVisible.push(newfield);
            }
            else if (element.viewStyle._renderstyle == "booleanDesicion") {
                let newfield: RadioBoxField;
                let rule = new Array<Rule>();
                newfield = new RadioBoxField({
                    label: element.title.__cdata,
                    key: element._id,
                    value: element.value,
                    order: element._ordinal,
                    rules: element.visible.rule != undefined ? element.visible.rule : rule,
                    visible: element._defaultVisibility,
                    group: element._group,
                    type: "radio",
                    description: element.description.__cdata,
                    answers: [
                        {
                            id: 1,
                            answer: "Yes",
                            value: true
                        },
                        {
                            id: 2,
                            answer: "No",
                            value: false
                        }]
                });
                fieldsVisible.push(newfield);
            }
        });
        fieldsVisible.sort((a, b) => a.order - b.order);
        return fieldsVisible;
    }

    private getGroups(fieldGroups: any, fields: any[]) {
        let groups: GroupBase<any>[] = [];

        if (fieldGroups.length > 1) {
            fieldGroups.forEach(fieldGroup => {   // each fiedgroup fills with its fields from json  
                let newfldGroup = new GroupBase();
                newfldGroup.groupFields = new Array();
                fields.forEach(field => {
                    if (fieldGroup._id == field.group) {
                        newfldGroup.groupFields.push(field);
                    } else {
                        //this.dataModel.fields.push(field);
                    }

                });
                newfldGroup.title = fieldGroup.title.__cdata;
                newfldGroup.key = fieldGroup._id;
                newfldGroup.section = fieldGroup._section;
                newfldGroup.style = fieldGroup.visible._style;
                newfldGroup.class = fieldGroup.visible._cssclass;
                groups.push(newfldGroup)
            });
        }

        else {
            let newfldGroup = new GroupBase();
            newfldGroup.groupFields = new Array();
            fields.forEach(field => {       //for one fieldgroup, because xml to json transformation doesn't create array of one fieldfroup                      
                if (fieldGroups._id == field.group) {
                    newfldGroup.groupFields.push(field);
                } else
                    this.dataModel.fields.push(field);
            });
            newfldGroup.title = fieldGroups.title.__cdata;
            newfldGroup.key = fieldGroups._id;
            newfldGroup.section = fieldGroups._section;
            groups.push(newfldGroup)
        }
        return groups;
    }


    private getDummyGroups() {

        let groups: GroupBase<any>[] = [];


        let group: GroupBase<any>;
        group = new GroupBase<any>({
            key: "adfgadfsg",
            title: "GroupA",
            rules: new Array(),
            groupFields: new Array(),
            value: "value",
            visible: true,
            order: 1
            //,
            //controlType: "none"
        });


        let newfield1: FieldBase<any>;
        newfield1 = new TextboxField({
            key: "tf1-455",
            label: "Field from group1",
            value: 'this is a groupfield',
            required: true,
            ordinal: 1
        });
        group.groupFields.push(newfield1);

        let newfield2: FieldBase<any>;
        newfield2 = new TextboxField({
            key: "tf1-443",
            label: "Another field from group1",
            value: 'this is a groupfield',
            required: true,
            ordinal: 2
        });
        group.groupFields.push(newfield2);

        groups.push(group);


        return groups;

    }

    private getFieldsAttributes(attributes: any, functions: any, fields: any[]) {
        let attribute: Attribute[] = [];
        attributes.forEach(attr => {
            let newAttribute = new Attribute();
            newAttribute.datatype = attr._datatype;
            newAttribute.defaultValue = attr.defaultValue._value;
            newAttribute.id = attr._id;
            newAttribute.multiplicityMax = attr.multiplicity._max;
            newAttribute.multiplicityMin = attr.multiplicity._min;
            newAttribute.ordinal = attr._ordinal;
            newAttribute.sources = new Array();
            newAttribute.validation = new Array();
            //newAttribute.validation.push(attr.validation.rule);

            if (attr.sources) {
                newAttribute.sources.push(attr.sources.source);

                if (attr.sources.source.url !== undefined) {



                    fields.find(x => x.key == newAttribute.id).url.url = attr.sources.source.url._value;
                    
                    this.restBase.proxy_get(attr.sources.source.url._value).subscribe((data) => {
                        
                        
                       
                            console.log(data);
                            newAttribute.sources.forEach(src => {
                                src.params = new Array();
                                data.data.forEach(data => {
                                let prm = new Param();
                                    prm.key = data.id;
                                    prm.value = data.attributes.name;
                                    src.params.push(prm);


                            });
                        });

                    });
                } else {
                    newAttribute.sources.forEach(src => {

                        src.params = new Array();
                        for (var i = 0, len = attr.sources.source.value.length; i < len; i++) {
                            let prm = new Param();
                            prm.key = attr.sources.source.value[i]._value;
                            prm.value = attr.sources.source.value[i]._label;
                            src.params.push(prm);
                        }


                    });
                }

            }


            if (attr.validation.rule.length)
                for (var i = 0, len = attr.validation.rule.length; i < len; i++) {
                    let rule = new Rule();
                    rule.ruleStyle = attr.validation.rule[i]._ruleStyle;
                    rule.ruleType = attr.validation.rule[i]._type;
                    if (attr.validation.rule[i]._ruleStyle == "regex")
                        rule.regex = attr.validation.rule[i].__cdata;
                    if (attr.validation.rule[i]._ruleStyle == "customValidation") {
                        rule.method = attr.validation.rule[i]._method;
                        functions.forEach(fnc => {
                            if (fnc._id == rule.method)
                                rule.methodJs = fnc.script.__cdata;
                        });
                    }

                    newAttribute.validation.push(rule);
                }

            else {
                if (attr.validation.rule) {
                    let rule = new Rule();
                    rule.ruleStyle = attr.validation.rule._ruleStyle;
                    rule.ruleType = attr.validation.rule._type;
                    if (attr.validation.rule._ruleStyle == "regex")
                        rule.regex = attr.validation.rule.__cdata;
                    if (attr.validation.rule._ruleStyle == "customValidation") {
                        rule.method = attr.validation.rule._method;
                        functions.forEach(fnc => {
                            if (fnc._id == rule.method)
                                rule.methodJs = fnc.__cdata;
                        });

                    }

                    newAttribute.validation.push(rule);
                }
            }

            attribute.push(newAttribute);
            //if (fields.find(x => x.key == newAttribute.id).url.url == null)
                fields.find(x => x.key == newAttribute.id).attributes.sources = newAttribute.sources;
            fields.find(x => x.key == newAttribute.id).attributes.validation = newAttribute.validation;
        });


        return attribute;
    }

    private getSections(sections: any, fieldGroups: GroupBase<any>[]) {
        let sects: Section[] = [];

        if (sections.length) {
            sections.forEach(section => {
                let newSection = new Section();
                newSection.defaultVisibility = section.defaultVisibility;
                newSection.description = section.description;
                newSection.id = section._id;
                newSection.title = section.title;
                newSection.ordinal = section._ordinal;
                newSection.groupFields = new Array();
                fieldGroups.forEach(fldgroup => {
                    if (fldgroup.section == newSection.id)
                        newSection.groupFields.push(fldgroup);
                })
                sects.push(newSection);
            });
        }
        sects.sort((a, b) => a.ordinal - b.ordinal);
        return sects;
    }

    getValuesFromEestore(url: string, fieldPath: string) {
        this.restBase.proxy_get(url).subscribe((data) => {
            data.data.forEach(data => {
                console.log(data);
            });
        });
    }
}