Needing help with my first software engineering project (Hospital vital simulator)

        // DataReader reader

        // DataReader reader

 return patientRecords.stream()
            .filter(record -> ValueRange.of(startTime, endTime).isValidValue(record.getTimeStamp()))
            .collect(Collectors.toList());

 return patientRecords.stream()
            .filter(record -> ValueRange.of(startTime, endTime).isValidValue(record.getTimeStamp()))
            .collect(Collectors.toList());

 return patientRecords.stream()
            .filter(record -> record.getTimeStamp() >= startTime && record.getTimeStamp <= endTime)
            .collect(Collectors.toList());

 return patientRecords.stream()
            .filter(record -> record.getTimeStamp() >= startTime && record.getTimeStamp <= endTime)
            .collect(Collectors.toList());

    public DataStorage readData(DataStorage dataStorage, String filePath) throws IOException {
        DataStorage dS = new DataStorage();
        if(filePath == null || filePath.isEmpty()){
            throw new IllegalArgumentException("File path needs to be established");
        }
        try(Stream<String> stream = Files.lines(Paths.get(filePath))){
            stream.forEach(line ->{DataStorage.addPatientData(line)}); 
        }
        return dS;
    } 

    public DataStorage readData(DataStorage dataStorage, String filePath) throws IOException {
        DataStorage dS = new DataStorage();
        if(filePath == null || filePath.isEmpty()){
            throw new IllegalArgumentException("File path needs to be established");
        }
        try(Stream<String> stream = Files.lines(Paths.get(filePath))){
            stream.forEach(line ->{DataStorage.addPatientData(line)}); 
        }
        return dS;
    } 

    @Override
    public DataStorage readData(DataStorage dataStorage, String filePath) throws IOException {
        if(filePath == null || filePath.isEmpty()){
            throw new IllegalArgumentException("File Path Cannot Be Null or Empty!");
        }

        if (dataStorage == null || !(dataStorage instanceof DataStorage)) {
            throw new IllegalArgumentException("Data Storage Cannot Be Null or Not an Instance of DataStorage!");
        }

        Files.lines(Paths.get(filePath)).forEach(line -> {
            String[] values = line.split(",");

            dataStorage.addPatientData(
                    Integer.parseInt(values[0]),
                    Double.parseDouble(values[1]),
                    values[2],
                    Long.parseLong(values[3])
            );
        });

        return dataStorage;
    }

    @Override
    public DataStorage readData(DataStorage dataStorage, String filePath) throws IOException {
        if(filePath == null || filePath.isEmpty()){
            throw new IllegalArgumentException("File Path Cannot Be Null or Empty!");
        }

        if (dataStorage == null || !(dataStorage instanceof DataStorage)) {
            throw new IllegalArgumentException("Data Storage Cannot Be Null or Not an Instance of DataStorage!");
        }

        Files.lines(Paths.get(filePath)).forEach(line -> {
            String[] values = line.split(",");

            dataStorage.addPatientData(
                    Integer.parseInt(values[0]),
                    Double.parseDouble(values[1]),
                    values[2],
                    Long.parseLong(values[3])
            );
        });

        return dataStorage;
    }

public interface Observer {
    void update(List<Patient> patients);
    void markPatientProcessed(Patient patient);
} 

public interface Observer {
    void update(List<Patient> patients);
    void markPatientProcessed(Patient patient);
} 

public enum ExceptionType {
    INV_FILE_PATH("INV_FP", "Invalid File Path."),
    INV_FILE_TYPE("INV_FT", "Invalid File Type."),
    INV_FILE_FORMAT("INV_FF", "Invalid File Format."),
    INV_FILE_CONTENT("INV_FC", "Invalid File Content."),
    INV_FILE_NAME("INV_FN", "Invalid File Name."),

    INV_SESSION_TIMEOUT("INV_SESH_T", "Invalid Session Timeout."),
    INV_CONNECTION_TIMEOUT("INV_CONN_T", "Invalid Connection Timeout."),
    INV_POOL_SIZE("INV_POOL", "Invalid Pool Size."),
    INV_DETECTION_THRESHOLD("INV_DETE_T", "Invalid Detection Threshold.");

    private final String shortHand;
    private final String desc;

    ExceptionType(final String shortHand, final String desc) {
        this.shortHand = shortHand;
        this.desc = desc;
    }

    public static Optional<ExceptionType> getExceptionByShortHand(final String shortHand)
            throws ExceptionTypeNotFoundException {
        return Optional.ofNullable(Arrays.stream(ExceptionType.values())
                .filter(exception -> exception.shortHand.equalsIgnoreCase(shortHand))
                .findFirst()
                .orElseThrow(() -> new ExceptionTypeNotFoundException("No Such Exception Found."))); // Throwing an Exception for Nullable?
    }

    //region Getters
    public String getShortHand() {
        return shortHand;
    }

    public String getDesc() {
        return desc;
    }
    //endregion

    @Override
    public String toString() {
        return "%s, %s".formatted(this.shortHand, this.desc);
    }
}

public enum ExceptionType {
    INV_FILE_PATH("INV_FP", "Invalid File Path."),
    INV_FILE_TYPE("INV_FT", "Invalid File Type."),
    INV_FILE_FORMAT("INV_FF", "Invalid File Format."),
    INV_FILE_CONTENT("INV_FC", "Invalid File Content."),
    INV_FILE_NAME("INV_FN", "Invalid File Name."),

    INV_SESSION_TIMEOUT("INV_SESH_T", "Invalid Session Timeout."),
    INV_CONNECTION_TIMEOUT("INV_CONN_T", "Invalid Connection Timeout."),
    INV_POOL_SIZE("INV_POOL", "Invalid Pool Size."),
    INV_DETECTION_THRESHOLD("INV_DETE_T", "Invalid Detection Threshold.");

    private final String shortHand;
    private final String desc;

    ExceptionType(final String shortHand, final String desc) {
        this.shortHand = shortHand;
        this.desc = desc;
    }

    public static Optional<ExceptionType> getExceptionByShortHand(final String shortHand)
            throws ExceptionTypeNotFoundException {
        return Optional.ofNullable(Arrays.stream(ExceptionType.values())
                .filter(exception -> exception.shortHand.equalsIgnoreCase(shortHand))
                .findFirst()
                .orElseThrow(() -> new ExceptionTypeNotFoundException("No Such Exception Found."))); // Throwing an Exception for Nullable?
    }

    //region Getters
    public String getShortHand() {
        return shortHand;
    }

    public String getDesc() {
        return desc;
    }
    //endregion

    @Override
    public String toString() {
        return "%s, %s".formatted(this.shortHand, this.desc);
    }
}

public interface Observer {
    class PatientState{
    boolean highDiastolic;
    boolean highSistolic;
    boolean highHeartRate;
    boolean isOk;
    }
void update(Patient patient,PatientState state);
}

public interface Observer {
    class PatientState{
    boolean highDiastolic;
    boolean highSistolic;
    boolean highHeartRate;
    boolean isOk;
    }
void update(Patient patient,PatientState state);
}

public class ObserverImpl implements Observer{
    @Override
    public void update(Patient patient, PatientState state) {
    if(state.highHeartRate){
        //do something if the heart rate is high
    }
    if(state.highSistolic){
        //do something if sistolic blood pressure is high
    }
    if(state.highDiastolic){
        //do something if diastolic blood pressure is high
    }
    }
}

public class ObserverImpl implements Observer{
    @Override
    public void update(Patient patient, PatientState state) {
    if(state.highHeartRate){
        //do something if the heart rate is high
    }
    if(state.highSistolic){
        //do something if sistolic blood pressure is high
    }
    if(state.highDiastolic){
        //do something if diastolic blood pressure is high
    }
    }
}

public class Patient {
    public int systolicBloodPressure;
    public int diastolicBloodPressure;
    public int heartRate;
}

public class Patient {
    public int systolicBloodPressure;
    public int diastolicBloodPressure;
    public int heartRate;
}

import java.util.ArrayList;
import java.util.List;

public class DataStorage {
    List<Patient> patients = new ArrayList<>();
    List<Observer> observers = new ArrayList<>();
    /*Logic here for adding patients to the list or whatever else is needed...*/

    public void addObserver(Observer obs){
        observers.add(obs);
    }
    public void removeObserver(Observer obs){
        observers.remove(obs);
    }
    public void checkAbnormalities(){
        for (Patient p :patients) {
            Observer.PatientState curState = checkPatient(p);
            if(!curState.isOk){
                fireAbnormalEvent(p,curState);
            }
        }
    }
    private void fireAbnormalEvent(Patient p, Observer.PatientState state){
        for(Observer obs:observers){
            obs.update(p,state);
        }
    }
    private Observer.PatientState checkPatient(Patient p){
        Observer.PatientState state = new Observer.PatientState();
        if(p.diastolicBloodPressure >140){
            state.highDiastolic=true;
        }
        if(p.systolicBloodPressure>140){
            state.highSistolic=true;
        }
        if(p.heartRate>80){
            state.highHeartRate=true;
        }
        state.isOk= !state.highSistolic && !state.highDiastolic && !state.highHeartRate;
        return state;
    }

}

import java.util.ArrayList;
import java.util.List;

public class DataStorage {
    List<Patient> patients = new ArrayList<>();
    List<Observer> observers = new ArrayList<>();
    /*Logic here for adding patients to the list or whatever else is needed...*/

    public void addObserver(Observer obs){
        observers.add(obs);
    }
    public void removeObserver(Observer obs){
        observers.remove(obs);
    }
    public void checkAbnormalities(){
        for (Patient p :patients) {
            Observer.PatientState curState = checkPatient(p);
            if(!curState.isOk){
                fireAbnormalEvent(p,curState);
            }
        }
    }
    private void fireAbnormalEvent(Patient p, Observer.PatientState state){
        for(Observer obs:observers){
            obs.update(p,state);
        }
    }
    private Observer.PatientState checkPatient(Patient p){
        Observer.PatientState state = new Observer.PatientState();
        if(p.diastolicBloodPressure >140){
            state.highDiastolic=true;
        }
        if(p.systolicBloodPressure>140){
            state.highSistolic=true;
        }
        if(p.heartRate>80){
            state.highHeartRate=true;
        }
        state.isOk= !state.highSistolic && !state.highDiastolic && !state.highHeartRate;
        return state;
    }

}

public interface AbnormalityHandler {
    class PatientState{
        boolean highDiastolic;
        boolean highSistolic;
        boolean highHeartRate;
        boolean isOk;
    }
    void handlePatientWithAbnormalities(Patient p,PatientState state);
}

public interface AbnormalityHandler {
    class PatientState{
        boolean highDiastolic;
        boolean highSistolic;
        boolean highHeartRate;
        boolean isOk;
    }
    void handlePatientWithAbnormalities(Patient p,PatientState state);
}

public class AbnormalityHandlerImpl implements AbnormalityHandler{

    @Override
    public void handlePatientWithAbnormalities(Patient p, PatientState state) {
        if(state.highHeartRate){
            //do something if the heart rate is high
        }
        if(state.highSistolic){
            //do something if sistolic blood pressure is high
        }
        if(state.highDiastolic){
            //do something if diastolic blood pressure is high
        }
    }
}

public class AbnormalityHandlerImpl implements AbnormalityHandler{

    @Override
    public void handlePatientWithAbnormalities(Patient p, PatientState state) {
        if(state.highHeartRate){
            //do something if the heart rate is high
        }
        if(state.highSistolic){
            //do something if sistolic blood pressure is high
        }
        if(state.highDiastolic){
            //do something if diastolic blood pressure is high
        }
    }
}

import java.util.ArrayList;
import java.util.List;

public class DataStorage {
    List<Patient> patients = new ArrayList<>();
    AbnormalityHandler handler;
    DataStorage(AbnormalityHandler handler){
        this.handler=handler;
    }

    /*Logic here for adding patients to the list or whatever else is needed...*/


    public void checkAbnormalities(){
        for (Patient p :patients) {
            AbnormalityHandler.PatientState curState = checkPatient(p);
            handler.handlePatientWithAbnormalities(p,curState);
        }
    }

    private AbnormalityHandler.PatientState checkPatient(Patient p){
        AbnormalityHandler.PatientState state = new AbnormalityHandler.PatientState();
        if(p.diastolicBloodPressure >140){
            state.highDiastolic=true;
        }
        if(p.systolicBloodPressure>140){
            state.highSistolic=true;
        }
        if(p.heartRate>80){
            state.highHeartRate=true;
        }
        state.isOk= !state.highSistolic && !state.highDiastolic && !state.highHeartRate;
        return state;
    }

}

import java.util.ArrayList;
import java.util.List;

public class DataStorage {
    List<Patient> patients = new ArrayList<>();
    AbnormalityHandler handler;
    DataStorage(AbnormalityHandler handler){
        this.handler=handler;
    }

    /*Logic here for adding patients to the list or whatever else is needed...*/


    public void checkAbnormalities(){
        for (Patient p :patients) {
            AbnormalityHandler.PatientState curState = checkPatient(p);
            handler.handlePatientWithAbnormalities(p,curState);
        }
    }

    private AbnormalityHandler.PatientState checkPatient(Patient p){
        AbnormalityHandler.PatientState state = new AbnormalityHandler.PatientState();
        if(p.diastolicBloodPressure >140){
            state.highDiastolic=true;
        }
        if(p.systolicBloodPressure>140){
            state.highSistolic=true;
        }
        if(p.heartRate>80){
            state.highHeartRate=true;
        }
        state.isOk= !state.highSistolic && !state.highDiastolic && !state.highHeartRate;
        return state;
    }

}