const ServerValidationFactory = ($compile) => {
        const errorType = "servervalidation";

        return {
            restrict: "A",
            require: ['ngModel', '^form'],
            link: function(scope, element, attr, controllers) {                
                const [ngModel, form] = controllers;
                let path = attr.ngModel.replace(/\$ctrl\./g, "");
                if (attr.serverValidationPath) {
                    path = attr.serverValidationPath;
                }

                const watchPath = `$ctrl.serverValidityResults.${path}`;

                const validationMessageScope = scope.$new(true);
                const serverValidationMessage = $compile("<server-validation-message />")(validationMessageScope);
                serverValidationMessage.insertAfter(element);

                const updateValidity = (valid) => {
                    ngModel.$setValidity(errorType, valid);
                    validationMessageScope.valid = valid;
                }

                scope.$watch(watchPath, (error) => {
                    validationMessageScope.errorMessage = error;

                    if (error && ngModel.$dirty) {
                        updateValidity(false);
                    } else {
                        updateValidity(true);
                    }
                });

                scope.$watch(`${form.$name}.$submitted`, (attempted) => {
                    if (attempted) {
                        ngModel.$setDirty(true);
                        if (validationMessageScope.errorMessage) {
                            updateValidity(false);
                        }
                    }
                })
            },
        }
    };

const ServerValidationMessageFactory = () => {
        return {
            restrict: "E",
            link: (scope) => {
                scope.valid = true;
            },
            template: "<div ng-if='!valid' style='color: red;'></div>"
        }
    };

queueRefresh = () => {
    if (this.refreshTimeout) {
        this.$timeout.cancel(this.refreshTimeout);
        delete this.refreshTimeout;
    }

    this.refreshTimeout = this.$timeout(() => {
        this.performRefresh();
    }, this.REFRESH_DELAY);
};

performRefresh() {
    const refreshPayload = this.getPayload();

    const refreshJsonSent = JSON.stringify(refreshPayload);

    const refreshPromise = this.$http.post("/api/rules/validate", refreshPayload).then(response => {
        delete this.refreshTimeout;
        this.handleRefreshResponse(response, refreshJsonSent);
    }, (response) => {
        if (response.status !== 400) {
            window.toastr.error("Validation failed due to an unexpected error");
        }
        delete this.refreshTimeout;
        this.handleRefreshResponse(response, refreshJsonSent);
    });

    this.tracker.track(refreshPromise);
}

handleRefreshResponse(response, jsonSent) {
    // Update the model client side based on server tidying. But only if nothing has changed since
    // we sent the request.
    const currentJson = JSON.stringify(this.getPayload());
    if (currentJson === jsonSent) {
        const data = response.data;

        // Take a little bit of care updating the Rule to avoid unwanted scope changes
        // If the user is typing in one of the threshold input fields, don't disrupt them
        for (const key in data.Model.Rule) {
            if (!data.Model.Rule.hasOwnProperty(key)) {
                continue;
            }

            if (key === "ThresholdValues") {
                this.mergeArrayValues(data.Model.Rule[key], this.Rule[key]);
            } else {
                this.Rule[key] = data.Model.Rule[key];
            }
        }

        this.GroupAssignments = data.Model.GroupAssignments;
        this.serverValidityResults = this.parseAspNetModelStateDictionary(data.Errors);        
    }
}

parseAspNetModelStateDictionary(dict) {
    const result = {};

    const partsRe = /([a-zA-Z0-9]*\[[0-9]+\])|(\.)/g;
    const indexerRe = /^([a-zA-Z0-9]*)\[([0-9]+)\]$/;

    for (const key in dict) {
        if (!dict.hasOwnProperty(key)) {
            continue;
        }

        const value = dict[key];

        const keyParts = key.split(partsRe).filter(p => !!p && p !== ".");
        const finalKeyPart = keyParts.splice(keyParts.length - 1, 1)[0];

        let container = result;
        for (const part of keyParts) {
            if (indexerRe.test(part)) {
                const match = indexerRe.exec(part);
                const arrayName = match[1];
                const arrayIndex = match[2];

                container[arrayName] = container[arrayName] || [];
                const elem = {};
                container[arrayName][arrayIndex] = elem;
                container = elem;
            } else {
                container = container[part] = container[part] || {};
            }
        }

        if (indexerRe.test(finalKeyPart)) {
            const match = indexerRe.exec(finalKeyPart);
            const arrayName = match[1];
            const arrayIndex = match[2];

            const array = container[arrayName] = container[arrayName] || [];
            array[arrayIndex] = value;
        } else {
            container[finalKeyPart] = value;
        }
    }

    return result;
}

mergeArrayValues(sourceArray, targetArray) {
    if (targetArray.length !== sourceArray.length) {
        targetArray.length = 0;
        for (const item of sourceArray) {
            targetArray.push(item);
        }
    } else {
        for (var i=0; i<sourceArray.length; i++) {
            const sourceItem = sourceArray[i];
            const targetItem = targetArray[i];

            for (const key in sourceItem) {
                if (sourceItem.hasOwnProperty(key)) {
                    continue;
                }

                targetItem[key] = sourceItem[key];
            }
        }
    }
}