import java.util.function.Function;
import java.util.Optional;

public class UserInputProcessor {

    // 驗證輸入字符串是否為有效的用戶名
    private static Function<String, Optional<String>> validateUsername = input -> {
        // 驗證邏輯...
        if (isValidUsername(input)) {
            return Optional.of(input);
        } else {
            return Optional.empty();
        }
    };

    // 將輸入字符串轉換為小寫形式
    private static Function<String, String> toLowerCase = String::toLowerCase;

    // 格式化用戶名（例如，添加前綴或后綴）
    private static Function<String, String> formatUsername = username -> "User_" + username;

    // 通用處理方法，接受一個Function鏈作為參數
    public static <T, R> R processInput(String input, Function<T, R>... functions) {
        // 由于我們的輸入是String類型，并且我們想要保持類型的一致性，
        // 我們需要將第一個Function的輸入類型強制轉換為String，并返回R類型的結果。
        // 為了簡化示例，我們假設所有函數都接受String輸入并返回String輸出（在實際應用中可能需要更復雜的類型處理）。
        // 注意：這個實現是簡化的，并且假設了所有函數都可以安全地鏈接在一起。
        // 在真實場景中，你可能需要添加更多的錯誤處理和類型檢查。

        Function<String, String> combinedFunction = functions[0];
        for (int i = 1; i < functions.length; i++) {
            combinedFunction = combinedFunction.andThen(functions[i]);
        }

        // 由于我們的輸入是String，我們可以直接調用apply方法。
        // 但請注意，這里的類型安全是基于我們的假設和簡化的實現。
        return (R) combinedFunction.apply(input);
    }

    // 示例：處理用戶輸入
    public static void main(String[] args) {
        String input = "JohnDoe";
        String processedUsername = processInput(input, validateUsername::apply.andThen(Optional::get).andThen(toLowerCase).andThen(formatUsername));
        // 注意：上面的鏈式調用需要一些調整才能正確工作，因為validateUsername返回一個Optional<String>。
        // 在實際應用中，你可能需要編寫一個輔助方法來處理Optional的鏈式調用，或者重新設計你的Function鏈。
        // 為了簡化示例，我們假設validateUsername總是返回一個有效的Optional<String>。

        // 正確的處理方式可能是這樣的：
        String processedUsernameCorrected = processInputCorrected(input,
                input -> Optional.ofNullable(validateUsernameOriginal(input)).orElseThrow(() -> new IllegalArgumentException("Invalid username")),
                toLowerCase,
                formatUsername
        );

        System.out.println(processedUsernameCorrected); // 輸出: User_johndoe（假設validateUsernameOriginal驗證通過）
    }

    // 輔助方法，用于處理Optional并拋出異常（如果需要）
    private static <T> T validateUsernameOriginal(T input) {
        // 實際的驗證邏輯（這里應該返回T類型或拋出異常，但為了簡化我們假設它總是返回input）
        return input instanceof String && isValidUsername((String) input) ? (T) input : null;
    }

    // 正確的處理輸入方法，考慮了Optional的處理和異常拋出
    private static <T, R> R processInputCorrected(T input, Function<T, ?>... functions) {
        // 由于我們的函數鏈可能包含返回Optional或拋出異常的情況，
        // 我們需要一種方法來安全地處理這些情況。這里我們簡化處理，只演示了如何鏈接函數并處理異常。
        // 在實際應用中，你可能需要更復雜的邏輯來處理不同類型的返回值和異常。

        Function<T, R> combinedFunction = input1 -> {
            Object result = functions[0].apply(input1);
            for (int i = 1; i < functions.length; i++) {
                if (result instanceof Optional) {
                    Optional<?> optionalResult = (Optional<?>) result;
                    if (!optionalResult.isPresent()) {
                        throw new RuntimeException("Validation failed at step " + i);
                    }
                    result = functions[i].apply(optionalResult.get());
                } else {
                    result = functions[i].apply(result);
                }
            }
            return (R) result;
        };

        // 注意：上面的實現有很多假設和簡化，只是為了演示目的。
        // 在實際應用中，你需要根據具體的業務邏輯和錯誤處理需求來調整這個實現。

        return combinedFunction.apply(input);
    }

    // 輔助方法，用于驗證用戶名（示例邏輯）
    private static boolean isValidUsername(String username) {
        // 實際的驗證邏輯（例如，檢查用戶名是否只包含字母和數字）
        return username != null && username.matches("[a-zA-Z0-9]+");
    }
}