package com.qianwen.core.tool.metadata.types;

import java.lang.Number;
import java.math.BigDecimal;
import java.util.Date;
import java.util.Optional;
import java.util.function.Function;
import com.qianwen.core.tool.metadata.Converter;
import com.qianwen.core.tool.metadata.DataType;
import com.qianwen.core.tool.metadata.UnitSupported;
import com.qianwen.core.tool.metadata.ValidateResult;
import com.qianwen.core.tool.metadata.unit.ValueUnit;

/* loaded from: blade-core-tool-9.3.0.0-SNAPSHOT.jar:org/springblade/core/tool/metadata/types/NumberType.class */
public abstract class NumberType<N extends Number> extends AbstractType<NumberType<N>> implements UnitSupported, DataType, Converter<N> {
    private Number max;
    private Number min;
    private ValueUnit unit;

    @Override // org.springblade.core.tool.metadata.Converter
    public abstract N convert(Object value);

    public void setMax(final Number max) {
        this.max = max;
    }

    public void setMin(final Number min) {
        this.min = min;
    }

    @Override // org.springblade.core.tool.metadata.UnitSupported
    public void setUnit(final ValueUnit unit) {
        this.unit = unit;
    }

    public Number getMax() {
        return this.max;
    }

    public Number getMin() {
        return this.min;
    }

    @Override // org.springblade.core.tool.metadata.UnitSupported
    public ValueUnit getUnit() {
        return this.unit;
    }

    public NumberType<N> unit(ValueUnit unit) {
        this.unit = unit;
        return this;
    }

    public NumberType<N> max(Number max) {
        this.max = max;
        return this;
    }

    public NumberType<N> min(Number min) {
        this.min = min;
        return this;
    }

    public Object format(Object value) {
        if (value == null) {
            return null;
        }
        ValueUnit unit = getUnit();
        if (unit == null) {
            return value;
        }
        return unit.format(value);
    }

    @Override // org.springblade.core.tool.metadata.DataType
    public ValidateResult validate(Object value) {
        try {
            N numberValue = convert(value);
            if (numberValue == null) {
                return ValidateResult.fail("数字格式错误:" + value);
            }
            if (this.max != null && numberValue.doubleValue() > this.max.doubleValue()) {
                return ValidateResult.fail("超过最大值:" + this.max);
            }
            if (this.min != null && numberValue.doubleValue() < this.min.doubleValue()) {
                return ValidateResult.fail("超过最大值:" + this.min);
            }
            return ValidateResult.success(numberValue);
        } catch (NumberFormatException e) {
            return ValidateResult.fail(e.getMessage());
        }
    }

    public N convertNumber(Object value, Function<Number, N> mapper) {
        return (N) Optional.ofNullable(convertNumber(value)).map(mapper).orElse(null);
    }

    public Number convertNumber(Object value) {
        if (value instanceof Number) {
            return (Number) value;
        }
        if (value instanceof String) {
            try {
                return new BigDecimal((String) value);
            } catch (NumberFormatException e) {
                return null;
            }
        } else if (value instanceof Date) {
            return Long.valueOf(((Date) value).getTime());
        } else {
            return null;
        }
    }

    public long getMax(long defaultVal) {
        return ((Long) Optional.ofNullable(getMax()).map((v0) -> {
            return v0.longValue();
        }).orElse(Long.valueOf(defaultVal))).longValue();
    }

    public long getMin(long defaultVal) {
        return ((Long) Optional.ofNullable(getMin()).map((v0) -> {
            return v0.longValue();
        }).orElse(Long.valueOf(defaultVal))).longValue();
    }

    public double getMax(double defaultVal) {
        return ((Double) Optional.ofNullable(getMax()).map((v0) -> {
            return v0.doubleValue();
        }).orElse(Double.valueOf(defaultVal))).doubleValue();
    }

    public double getMin(double defaultVal) {
        return ((Double) Optional.ofNullable(getMin()).map((v0) -> {
            return v0.doubleValue();
        }).orElse(Double.valueOf(defaultVal))).doubleValue();
    }
}