/*!
 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing
 * permissions and limitations under the License.
 */
// import Ajv from 'ajv';
import cloneDeep from 'lodash/cloneDeep.js';
import JSONPointer from './JSONPointer.js';

export default class JSONSchema {
    setSchema(schema) {
        this._schema = schema;
        this._fragmentsCache = new Map();
        // this._ajv = new Ajv({
        // 	useDefaults: true,
        // 	coerceTypes: true
        // });
        // this._validate = this._ajv.compile(schema);
    }

    processData(data) {
        data = cloneDeep(data);
        // this._validate(data);
        return data;
    }

    // array of names of validation functions
    setSupportedValidationFunctions(supportedValidationFunctions) {
        this._supportedValidationFunctions = supportedValidationFunctions;
    }

    /* FYI - I was going to support "required" but then found out that server never sends it in its schema (it was a business decision. so leaving the code commented for now */
    flattenSchema(supportedValidationFunctions) {
        if (supportedValidationFunctions) {
            this.setSupportedValidationFunctions(supportedValidationFunctions);
        }
        let genericFieldInfo = {};
        if (this._schema && this._schema.properties) {
            this.travelProperties(
                this._schema.properties,
                genericFieldInfo /*, this._schema.required*/
            );
        }
        return { genericFieldInfo };
    }

    extractGenericFieldInfo(item) {
        let validationsArr = [];
        let additionalInfo = { isValid: true, errorText: '' };
        for (let value in item) {
            if (this._supportedValidationFunctions.includes(value)) {
                let validationItem = this.extractValidations(item, value);
                validationsArr[validationsArr.length] = validationItem;
            } else {
                let enumResult = this.extractEnum(item, value);
                if (enumResult !== null) {
                    additionalInfo.enum = enumResult;
                } else {
                    additionalInfo[value] = item[value];
                }
                /*if (required.includes (property)) {
				 additionalInfo[value].isRequired = true ;
				 }*/
            }
        }

        additionalInfo.validations = validationsArr;
        return additionalInfo;
    }

    extractValidations(item, value) {
        let validationItem;
        let data = item[value];
        if (value === 'maximum') {
            if (item.exclusiveMaximum) {
                value = 'maximumExclusive';
            }
        }
        if (value === 'minimum') {
            if (item.exclusiveMinimum) {
                value = 'minimumExclusive';
            }
        }
        validationItem = { type: value, data: data };
        return validationItem;
    }

    extractEnum(item, value) {
        let enumResult = null;
        if (value === 'type' && item[value] === 'array') {
            let items = item.items;
            if (items && items.enum && items.enum.length > 0) {
                let values = items.enum
                    .filter(value => value)
                    .map(value => ({ enum: value, title: value }));
                enumResult = values;
            }
        } else if (value === 'enum') {
            let items = item[value];
            if (items && items.length > 0) {
                let values = items
                    .filter(value => value)
                    .map(value => ({ enum: value, title: value }));
                enumResult = values;
            }
        }
        return enumResult;
    }

    travelProperties(
        properties,
        genericFieldDefs,
        /*required = [],*/ pointer = ''
    ) {
        let newPointer = pointer;
        for (let property in properties) {
            newPointer = newPointer ? newPointer + '/' + property : property;
            if (properties[property].properties) {
                this.travelProperties(
                    properties[property].properties,
                    genericFieldDefs /*, properties[property].required*/,
                    newPointer
                );
            } else if (properties[property].$ref) {
                let fragment = this._getSchemaFragmentByRef(
                    properties[property].$ref
                );
                if (fragment.properties) {
                    this.travelProperties(
                        fragment.properties,
                        genericFieldDefs /*, properties[property].required*/,
                        newPointer
                    );
                } else {
                    genericFieldDefs[newPointer] = this.extractGenericFieldInfo(
                        fragment.properties
                    );
                }
            } else {
                genericFieldDefs[newPointer] = this.extractGenericFieldInfo(
                    properties[property]
                );
            }
            newPointer = pointer;
        }
    }

    getTitle(pointer) {
        return this._getSchemaFragment(pointer).title;
    }

    exists(pointer) {
        const fragment = this._getSchemaFragment(pointer);
        return !!fragment;
    }

    getDefault(pointer) {
        const fragment = this._getSchemaFragment(pointer);
        return fragment && fragment.default;
    }

    getEnum(pointer) {
        const fragment = this._getSchemaFragment(pointer);
        return (
            fragment &&
            (fragment.type === 'array' ? fragment.items.enum : fragment.enum)
        );
    }

    isRequired(pointer) {
        const parentPointer = JSONPointer.extractParentPointer(pointer);
        const lastPart = JSONPointer.extractLastPart(pointer);
        let parentFragment = this._getSchemaFragment(parentPointer);
        return (
            parentFragment &&
            parentFragment.required &&
            parentFragment.required.includes(lastPart)
        );
    }

    isNumber(pointer) {
        const fragment = this._getSchemaFragment(pointer);
        return fragment && fragment.type === 'number';
    }

    getMaxValue(pointer) {
        const fragment = this._getSchemaFragment(pointer);
        return fragment && fragment.exclusiveMaximum
            ? fragment.maximum - 1
            : fragment.maximum;
    }

    getMinValue(pointer) {
        const fragment = this._getSchemaFragment(pointer);
        return fragment && fragment.exclusiveMinimum
            ? fragment.minimum
            : fragment.minimum;
    }

    isString(pointer) {
        const fragment = this._getSchemaFragment(pointer);
        return fragment && fragment.type === 'string';
    }

    getPattern(pointer) {
        const fragment = this._getSchemaFragment(pointer);
        return fragment && fragment.pattern;
    }

    getMaxLength(pointer) {
        const fragment = this._getSchemaFragment(pointer);
        return fragment && fragment.maxLength;
    }

    getMinLength(pointer) {
        const fragment = this._getSchemaFragment(pointer);
        return fragment && fragment.minLength;
    }

    isArray(pointer) {
        const fragment = this._getSchemaFragment(pointer);
        return fragment && fragment.type === 'array';
    }

    _getSchemaFragment(pointer) {
        if (this._fragmentsCache.has(pointer)) {
            return this._fragmentsCache.get(pointer);
        }

        let parts = JSONPointer.extractParts(pointer);

        let fragment = parts.reduce((fragment, part) => {
            if (fragment === undefined) {
                return undefined;
            }

            if (fragment.$ref) {
                fragment = this._getSchemaFragmentByRef(fragment.$ref);
            }

            switch (fragment.type) {
                case 'object':
                    return fragment.properties && fragment.properties[part];

                case 'array':
                    return fragment.enum && fragment.enum[part];

                default:
                    // throw new Error(`Incorrect/unsupported JSONPointer "${pointer}" from "${part}"`);
                    return undefined;
            }
        }, this._schema);

        while (fragment && fragment.$ref) {
            fragment = this._getSchemaFragmentByRef(fragment.$ref);
        }

        this._fragmentsCache.set(pointer, fragment);
        return fragment;
    }

    _getSchemaFragmentByRef($ref) {
        let pointer = $ref.substr(1);
        return JSONPointer.getValue(this._schema, pointer);
        // let fragmentAjv = new Ajv();
        // fragmentAjv.addSchema(this._schema);
        // let compiledFragment = fragmentAjv.compile({$ref});
        // let fragment = compiledFragment.refVal[compiledFragment.refs[$ref]];
        // return fragment;
    }
}