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 { TextAreaField } from '../../app/form/fields/textarea/textarea';
import { LabelField } from '../../app/form/fields/label/label';
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, dataValues) {

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

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

        this.checkDuplicateInObject('order', this.dataModel.groups[13].groupFields); //for future use , for composite field

        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: false,
                    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);
            } else if (element.viewStyle._renderstyle == "textarea") {
                let newfield: FieldBase<any>;
                let rule = new Rule();
                newfield = new TextAreaField({
                    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 == "label") {
                let newfield: FieldBase<any>;
                let rule = new Rule();
                newfield = new LabelField({
                    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);
            }
        });
        fieldsVisible.sort((a, b) => a.order - b.order);
        return fieldsVisible;
    }

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

        if (fieldGroups.length > 1) {
            fieldGroups.forEach(fieldGroup => {   // each fiedgroup fills with its fields from json  
                let newfldGroup = new GroupBase();
                let compositeFields = new GroupBase();
                newfldGroup.groupFields = new Array();
                compositeFields.groupFields = new Array();


                fields.forEach(field => {
                    if (fieldGroup._id == field.group) {
                        if (dataValues != "")//--------------------------SET VALUES---------------------------------------------------------------------------------------
                            if (dataValues[fieldGroup._id][field.key] != undefined) // to put values in fields
                                field.value = dataValues[fieldGroup._id][field.key].value == undefined ? dataValues[fieldGroup._id][field.key] : dataValues[fieldGroup._id][field.key].value;
                       
                        if(field.order.toString().split(".").length > 1){//--------------Composite Fields Multiplicity --------------------------------------------------
                            compositeFields.groupFields.push(field);
                            newfldGroup.compositeFields = compositeFields;
                        }else
                            newfldGroup.groupFields.push(field);
                    } else {
                        //this.dataModel.fields.push(field);
                    }
                    //TO DO FIELDSET WITH MULTIPLICITY
                    // if (dataValues != "")
                    //     if (dataValues[fieldGroup._id][field.key] != undefined){
                    //         let keys = new Array<string>();
                    //         Object.keys(dataValues[fieldGroup._id]).forEach(key=>{if(key.startsWith(field.key+"_"))keys.push(key)})
                    //         if (keys.length)
                    //             if (field.controlType == "textbox") {
                    //                 let newfield: FieldBase<any>;
                    //                 let rule = new Rule();
                    //                 newfield = new TextboxField({
                    //                     label: field.label+"_"+ 1,
                    //                     key: keys[0],
                    //                     value: dataValues[fieldGroup._id][keys[0]].value,
                    //                     order: field.order,
                    //                     rules: field.rules,
                    //                     visible: field.visible,
                    //                     group: field.group,
                    //                     description: field.description
                    //                 });debugger;
                    //                 newfldGroup.groupFields.push(newfield);
                    //             }
                    //     }
                    

                    

                });

                newfldGroup.title = fieldGroup.title.__cdata;
                newfldGroup.key = fieldGroup._id;
                newfldGroup.section = fieldGroup._section;
                newfldGroup.style = fieldGroup.visible._style;
                newfldGroup.class = fieldGroup.visible._cssclass;
                newfldGroup.page = fieldGroup._page;
                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;
    }

    addAttributesToFields(attr, functions, fields, multiplicity){

        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
        if (multiplicity){
            fields.find(x => x.key == newAttribute.id).order = fields.find(x => x.key == newAttribute.id).order +'.'+ newAttribute.ordinal;            
            fields.find(x => x.key == newAttribute.id).multiplicity = true;  
        }          
        newAttribute.ordinal = attr._ordinal;
        newAttribute.sources = new Array();
        newAttribute.validation = new Array();
        //newAttribute.validation.push(attr.validation.rule);
        //-----------------Sources---------------------------------------------------------------
        if (attr.sources) {
            newAttribute.sources.push(attr.sources.source);
            if (attr.sources.source.length != undefined) {
                for (var i = 0; i < attr.sources.source.length; i++) {
                    if (attr.sources.source[i]._type == "url") {
                        newAttribute.url = attr.sources.source[i].value._value;
                        break;
                    } 
                }
            }
            if (attr.sources.source._type == "url") {
                newAttribute.url = attr.sources.source.value._value;
            } 
        }
        //-----------Rules------------------------------------------------------------------------
        if(attr.validation.rule != undefined)
            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);                    }
            }

        
    
    fields.sort((a, b) => a.order - b.order);

    return newAttribute;
    }

    private getFieldsAttributes(fieldsets: any, functions: any, fields: any[]) {
        let attribute: Attribute[] = [];
        let newAttribute = new Attribute();
        let multiplicityParam = false;
        fieldsets.forEach(fieldset => {
            let multiplicityParam = false;
            if (fieldset.fields.field.length){
                if(fieldset.multiplicity._max >1 || fieldset.multiplicity._max == "n")  
                    multiplicityParam = true;
                fieldset.fields.field.forEach(fieldAttribute=>{
                    newAttribute = this.addAttributesToFields(fieldAttribute, functions, fields, multiplicityParam)
                    attribute.push(newAttribute);
                    if (newAttribute.url !== undefined)
                        fields.find(x => x.key == newAttribute.id).url = newAttribute.url;
                    fields.find(x => x.key == newAttribute.id).attributes.sources = newAttribute.sources;
                    fields.find(x => x.key == newAttribute.id).attributes.validation = newAttribute.validation;
                })
            }else{
                    if(fieldset.multiplicity._max >1 || fieldset.multiplicity._max == "n")  
                        multiplicityParam = true;
                    newAttribute = this.addAttributesToFields(fieldset.fields.field, functions, fields, multiplicityParam)
                    attribute.push(newAttribute);
                    if (newAttribute.url !== undefined)
                        fields.find(x => x.key == newAttribute.id).url = newAttribute.url;
                    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.page = section._page;
                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;
    }


    checkDuplicateInObject(propertyName, inputArray) {
        let DuplicateArray = [];
        inputArray.forEach(item => {
            for(var i=0; i<inputArray.length; i++){
                if(item[propertyName] == inputArray[i][propertyName] && item['key'] !=  inputArray[i]['key']){
                    DuplicateArray.push(inputArray[i]);
                }
            }
        });
        console.log(DuplicateArray);
            
      }

}