package com.qianwen.core.tool.metadata;

import cn.hutool.core.date.DateUtil;
import java.math.BigDecimal;
import java.time.Duration;
import java.util.Date;
import java.util.Map;
import java.util.Optional;
import com.qianwen.core.tool.utils.BeanUtil;
import org.springframework.util.StringUtils;

/* loaded from: blade-core-tool-9.3.0.0-SNAPSHOT.jar:org/springblade/core/tool/metadata/ValueObject.class */
public interface ValueObject {
    Map<String, Object> values();

    default Optional<Object> get(String name) {
        return Optional.ofNullable(values()).map(map -> {
            return map.get(name);
        });
    }

    default Optional<Integer> getInt(String name) {
        return get(name, Integer.class);
    }

    default int getInt(String name, int defaultValue) {
        return getInt(name).orElse(Integer.valueOf(defaultValue)).intValue();
    }

    default Optional<Long> getLong(String name) {
        return get(name, Long.class);
    }

    default long getLong(String name, long defaultValue) {
        return getLong(name).orElse(Long.valueOf(defaultValue)).longValue();
    }

    default Optional<Duration> getDuration(String name) {
        return getString(name).map(ValueObject::parse);
    }

    default Optional<Interval> getInterval(String name) {
        return getString(name).map(Interval::of);
    }

    default Interval getInterval(String name, Interval defaultValue) {
        return (Interval) getString(name).map(Interval::of).orElse(defaultValue);
    }

    default Duration getDuration(String name, Duration defaultValue) {
        return getDuration(name).orElse(defaultValue);
    }

    default Optional<Date> getDate(String name) {
        return get(name).map(String::valueOf).map((v0) -> {
            return DateUtil.parse(v0);
        });
    }

    default Date getDate(String name, Date defaultValue) {
        return getDate(name).orElse(defaultValue);
    }

    default Optional<Double> getDouble(String name) {
        return get(name, Double.class);
    }

    default double getDouble(String name, double defaultValue) {
        return getDouble(name).orElse(Double.valueOf(defaultValue)).doubleValue();
    }

    default Optional<String> getString(String name) {
        return get(name, String.class).filter(StringUtils::hasText);
    }

    default String getString(String name, String defaultValue) {
        return getString(name).orElse(defaultValue);
    }

    default Optional<Boolean> getBoolean(String name) {
        return get(name, Boolean.class);
    }

    default boolean getBoolean(String name, boolean defaultValue) {
        return getBoolean(name).orElse(Boolean.valueOf(defaultValue)).booleanValue();
    }

    default <T> Optional<T> get(String name, Class<T> type) {
        return (Optional<T>) get(name).map(obj -> {
            return BeanUtil.copyWithConvert(obj, type);
        });
    }

    static ValueObject of(Map<String, Object> mapVal) {
        return () -> {
            return mapVal;
        };
    }

    default <T> T as(Class<T> type) {
        return (T) BeanUtil.copy((Object) values(), (Class<Object>) type);
    }

    static Duration parse(String timeString) {
        char[] all = timeString.toCharArray();
        if (all[0] == 'P' || (all[0] == '-' && all[1] == 'P')) {
            return Duration.parse(timeString);
        }
        Duration duration = Duration.ofSeconds(0L);
        char[] tmp = new char[32];
        int numIndex = 0;
        for (char c : all) {
            if (c == '-' || (c >= '0' && c <= '9')) {
                int i = numIndex;
                numIndex++;
                tmp[i] = c;
            } else {
                long val = new BigDecimal(tmp, 0, numIndex).longValue();
                numIndex = 0;
                Duration plus = null;
                if (c == 'D' || c == 'd') {
                    plus = Duration.ofDays(val);
                } else if (c == 'H' || c == 'h') {
                    plus = Duration.ofHours(val);
                } else if (c == 'M' || c == 'm') {
                    plus = Duration.ofMinutes(val);
                } else if (c == 's') {
                    plus = Duration.ofSeconds(val);
                } else if (c == 'S') {
                    plus = Duration.ofMillis(val);
                } else if (c == 'W' || c == 'w') {
                    plus = Duration.ofDays(val * 7);
                }
                if (plus != null) {
                    duration = duration.plus(plus);
                }
            }
        }
        return duration;
    }
}