"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.BASE_SHEMA = '$base';
var BaseValueProp;
(function (BaseValueProp) {
    BaseValueProp[BaseValueProp["None"] = 0] = "None";
    BaseValueProp[BaseValueProp["Text"] = 1] = "Text";
    BaseValueProp[BaseValueProp["Input"] = 2] = "Input";
    BaseValueProp[BaseValueProp["Disabled"] = 3] = "Disabled";
    BaseValueProp[BaseValueProp["Hidden"] = 4] = "Hidden";
})(BaseValueProp = exports.BaseValueProp || (exports.BaseValueProp = {}));
var BaseValueType;
(function (BaseValueType) {
    BaseValueType["Text"] = "text";
    BaseValueType["Number"] = "number";
    BaseValueType["Array"] = "array";
    BaseValueType["Object"] = "object";
    BaseValueType["Boolean"] = "boolean";
    BaseValueType["Undefined"] = "undefined";
    BaseValueType["Date"] = "date";
    BaseValueType["Time"] = "time";
    BaseValueType["Error"] = "error";
    BaseValueType["Custom"] = "custom";
})(BaseValueType = exports.BaseValueType || (exports.BaseValueType = {}));
class BaseParam {
    constructor(type = BaseValueType.Text, shema = exports.BASE_SHEMA, prop = BaseValueProp.Text, template = '', provider = '', validator = '') {
        this.type = type;
        this.shema = shema;
        this.prop = prop;
        this.template = template;
        this.provider = provider;
        this.validator = validator;
    }
}
exports.BaseParam = BaseParam;
class BaseValue {
    constructor(name, param) {
        this.name = name;
        this.param = param;
    }
}
exports.BaseValue = BaseValue;
function objectType(obj) {
    if (obj !== undefined) {
        if (obj instanceof Array) {
            return BaseValueType.Array;
        }
        else if (typeof obj === 'boolean') {
            return BaseValueType.Boolean;
        }
        else if (typeof obj === 'number') {
            return BaseValueType.Number;
        }
        else if (obj && obj.hours !== undefined && '' + obj.hours) {
            return BaseValueType.Time;
        }
        else if (obj && typeof obj.getMilliseconds === 'function') {
            return BaseValueType.Date;
        }
        else {
            return BaseValueType.Text;
        }
    }
    return BaseValueType.Undefined;
}
function Descriptor(descriptor, property) {
    return function (constructor) {
        const a = new constructor();
        if (!property) {
            property = Object.getOwnPropertyNames(a);
        }
        const array = property;
        let trg = constructor.prototype;
        //console.log('Descriptor',array,trg);
        function proc(data, propertyKey) {
            let base = Object.getOwnPropertyDescriptor(trg, data.shema);
            if (!base) {
                Object.defineProperty(trg, data.shema, {
                    configurable: false,
                    enumerable: true,
                    value: {
                        list: [],
                        hash: {},
                    },
                });
                base = Object.getOwnPropertyDescriptor(trg, data.shema);
            }
            // keep previous definition !
            if (base && !base.value.hash[propertyKey]) {
                base.value.hash[propertyKey] = new BaseValue(propertyKey, data);
                base.value.list.push(propertyKey);
                Object.defineProperty(trg, data.shema, base);
            }
        }
        descriptor.forEach(d => {
            array.forEach(name => {
                let nd = Object.assign({}, d);
                const t = nd.type;
                if (t === BaseValueType.Undefined && a) {
                    // get value type
                    nd.type = objectType(a[name]);
                }
                proc(nd, name);
            });
            let base = Object.getOwnPropertyDescriptor(trg, d.shema);
            if (base) {
                base.value.list = property.slice();
                Object.defineProperty(trg, d.shema, base);
            }
        });
        return class extends constructor {
        };
    };
}
exports.Descriptor = Descriptor;
function BaseDescriptors(descriptor) {
    function proc(data, target, propertyKey) {
        let base = Object.getOwnPropertyDescriptor(target, data.shema);
        if (!base) {
            Object.defineProperty(target, data.shema, {
                configurable: false,
                enumerable: true,
                value: {
                    hash: {},
                    list: [],
                },
            });
            base = Object.getOwnPropertyDescriptor(target, data.shema);
        }
        if (base) {
            base.value.hash[propertyKey] = new BaseValue(propertyKey, data);
            base.value.list.push(propertyKey);
            Object.defineProperty(target, data.shema, base);
        }
    }
    return function (target, propertyKey) {
        descriptor.forEach(d => {
            proc(d, target, propertyKey);
        });
    };
}
exports.BaseDescriptors = BaseDescriptors;