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

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.Date;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.qianwen.core.tool.metadata.Converter;
import com.qianwen.core.tool.metadata.DataType;
import com.qianwen.core.tool.metadata.ValidateResult;
import com.qianwen.core.tool.time.DateFormatter;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.core.tool.utils.StringPool;

/* loaded from: blade-core-tool-9.3.0.0-SNAPSHOT.jar:org/springblade/core/tool/metadata/types/DateTimeType.class */
public class DateTimeType extends AbstractType<DateTimeType> implements DataType, Converter<Date> {
    public static final String ID = "date";
    public static final String TIMESTAMP_FORMAT = "timestamp";
    private String format = TIMESTAMP_FORMAT;
    private ZoneId zoneId = ZoneId.systemDefault();
    private DateTimeFormatter formatter;
    private static final Logger log = LoggerFactory.getLogger(DateTimeType.class);
    public static final DateTimeType GLOBAL = new DateTimeType();

    public void setFormat(final String format) {
        this.format = format;
    }

    public void setZoneId(final ZoneId zoneId) {
        this.zoneId = zoneId;
    }

    public void setFormatter(final DateTimeFormatter formatter) {
        this.formatter = formatter;
    }

    static {
        DateFormatter.supportFormatter.add(new ISODateTimeFormatter());
    }

    public String getFormat() {
        return this.format;
    }

    public ZoneId getZoneId() {
        return this.zoneId;
    }

    public DateTimeType timeZone(ZoneId zoneId) {
        this.zoneId = zoneId;
        return this;
    }

    public DateTimeType format(String format) {
        this.format = format;
        getFormatter();
        return this;
    }

    @Override // org.springblade.core.tool.metadata.Metadata
    public String getId() {
        return ID;
    }

    @Override // org.springblade.core.tool.metadata.Metadata
    public String getName() {
        return "时间";
    }

    protected DateTimeFormatter getFormatter() {
        if (this.formatter == null && !TIMESTAMP_FORMAT.equals(this.format)) {
            this.formatter = DateTimeFormatter.ofPattern(this.format);
        }
        return this.formatter;
    }

    @Override // org.springblade.core.tool.metadata.DataType
    public ValidateResult validate(Object value) {
        Object value2 = convert(value);
        if (value2 == null) {
            return ValidateResult.fail("不是合法的时间格式");
        }
        return ValidateResult.success(value2);
    }

    @Override // org.springblade.core.tool.metadata.FormatSupport
    public String format(Object value) {
        try {
            if (TIMESTAMP_FORMAT.equals(this.format)) {
                return String.valueOf(convert(value).getTime());
            }
            Date dateValue = convert(value);
            if (dateValue == null) {
                return StringPool.EMPTY;
            }
            return LocalDateTime.ofInstant(dateValue.toInstant(), this.zoneId).format(getFormatter());
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            return StringPool.EMPTY;
        }
    }

    /* JADX WARN: Can't rename method to resolve collision */
    @Override // org.springblade.core.tool.metadata.Converter
    public Date convert(Object value) {
        if (value instanceof Instant) {
            return Date.from((Instant) value);
        }
        if (value instanceof LocalDateTime) {
            return Date.from(((LocalDateTime) value).atZone(this.zoneId).toInstant());
        }
        if (value instanceof Date) {
            return (Date) value;
        }
        if (value instanceof Number) {
            return new Date(((Number) value).longValue());
        }
        if (value instanceof String) {
            if (Func.isNumeric(value.toString())) {
                return new Date(Long.parseLong((String) value));
            }
            Date data = DateFormatter.fromString((String) value);
            if (data != null) {
                return data;
            }
            DateTimeFormatter formatter = getFormatter();
            if (null == formatter) {
                throw new IllegalArgumentException("unsupported date format:" + value);
            }
            return Date.from(LocalDateTime.parse((String) value, formatter).atZone(this.zoneId).toInstant());
        }
        throw new IllegalArgumentException("can not format datetime :" + value);
    }
}