Write and test a UDF to convert dates, times, and names

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.format.ResolverStyle;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import kotlin.Pair;
import com.molo17.gluesync.commons.model.api.MappingFunctionOperation;
import org.slf4j.Logger;

public class UDF_events {

    // Accepted spellings of the date, tried in order. STRICT rejects impossible dates such as 31/02/2026.
    private static final List<DateTimeFormatter> DATE_INPUTS = List.of(
            strict("uuuuMMdd"),      // 20260131
            strict("dd/MM/uuuu"),    // 31/01/2026
            strict("uuuu-MM-dd"),    // 2026-01-31
            strict("dd.MM.uuuu"));   // 31.01.2026

    private static final DateTimeFormatter DATE_LABEL = DateTimeFormatter.ofPattern("dd MMM uuuu", Locale.ENGLISH);
    private static final DateTimeFormatter TIME_24H = DateTimeFormatter.ofPattern("HH:mm");
    private static final DateTimeFormatter TIME_12H = DateTimeFormatter.ofPattern("hh:mm a", Locale.ENGLISH);

    private static DateTimeFormatter strict(String pattern) {
        return DateTimeFormatter.ofPattern(pattern).withResolverStyle(ResolverStyle.STRICT);
    }

    public Pair<MappingFunctionOperation, Map<String, Object>> onChange(Map<String, Object> newValues, Map<String, Object> oldValues, MappingFunctionOperation operation, boolean isSnapshot, Logger logger) {
        Map<String, Object> targetValues = new HashMap<>();
        targetValues.put("id", newValues.get("id"));

        // Columns that also have a field function (Trim String on code, Convert Time to String on
        // end_time_text) receive the untouched source value: the field function runs after the UDF
        // and expects the original type, a LocalTime for end_time_text, not a String.
        targetValues.put("code", newValues.get("code"));
        targetValues.put("end_time_text", newValues.get("end_time"));

        // One source column, two target columns: split the full name.
        String[] name = splitName(newValues.get("full_name"));
        targetValues.put("first_name", name[0]);
        targetValues.put("last_name", name[1]);

        // One source column, two target columns: the same date as a DATE and as a label.
        LocalDate eventDate = parseDate(newValues.get("event_date_text"), logger);
        targetValues.put("event_date", eventDate);
        targetValues.put("event_date_label", eventDate == null ? null : eventDate.format(DATE_LABEL));

        // One source column, two target columns: the same TIME in two text patterns.
        targetValues.put("start_time_24h", formatTime(newValues.get("start_time"), TIME_24H, logger));
        targetValues.put("start_time_12h", formatTime(newValues.get("start_time"), TIME_12H, logger));

        return new Pair<>(operation, targetValues);
    }

    private static LocalDate parseDate(Object value, Logger logger) {
        if (value == null) {
            return null;
        }
        if (value instanceof LocalDate) {
            return (LocalDate) value;
        }
        String text = value.toString().trim();
        if (text.isEmpty()) {
            return null;
        }
        for (DateTimeFormatter format : DATE_INPUTS) {
            try {
                return LocalDate.parse(text, format);
            } catch (DateTimeParseException ignored) {
                // try the next format
            }
        }
        logger.warn("event_date_text '{}' matches no accepted date format: event_date left null", text);
        return null;
    }

    private static String formatTime(Object value, DateTimeFormatter format, Logger logger) {
        if (value == null) {
            return null;
        }
        if (value instanceof LocalTime) {
            return ((LocalTime) value).format(format);
        }
        try {
            return LocalTime.parse(value.toString().trim()).format(format);
        } catch (DateTimeParseException e) {
            logger.warn("start_time '{}' is not a time: left null", value);
            return null;
        }
    }

    // First word = first name, the rest = last name. A single word is a first name only.
    private static String[] splitName(Object value) {
        if (value == null) {
            return new String[] {null, null};
        }
        String text = value.toString().trim().replaceAll("\\s+", " ");
        if (text.isEmpty()) {
            return new String[] {null, null};
        }
        int cut = text.indexOf(' ');
        if (cut < 0) {
            return new String[] {text, null};
        }
        return new String[] {text.substring(0, cut), text.substring(cut + 1)};
    }
}

String code = newValues.get("code");
targetValues.put("code", code);

SELECT id, first_name, last_name, event_date, event_date_label,
       start_time_24h, start_time_12h, code, end_time_text
FROM shop_udf.events
ORDER BY id;