source: PerfectFit/Dialog/src/main/java/tudelft/mentalhealth/perfectfit/updatefuncs/CheckDeadline.java

package tudelft.mentalhealth.perfectfit.updatefuncs;

import java.io.IOException;
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.temporal.ChronoUnit;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;

import tudelft.dialogmanager.parameters.DoubleValue;
import tudelft.dialogmanager.parameters.ParameterValue;
import tudelft.dialogmanager.parameters.Parameters;
import tudelft.dialogmanager.parameters.StringValue;
import tudelft.dialogmanager.updatefunctions.UpdateFunction;

/**
 * Function to get a response to a suggested deadline. Will be either a
 * confirmation message or error message..
 */
public class CheckDeadline implements UpdateFunction {
        private final String timefieldname;
        private final String datefieldname;
        private final String replyfieldname;

        /**
         * @param datefieldname  the name of the parameter contraining the date
         *                       string (eg "20-12-2022") in. NOTE the original code
         *                       *syggests* they support 3 formats, but a bug in
         *                       their code results in effective use of only the
         *                       first format.
         * @param timefieldname  the name of OUT parameter to put the the time
         *                       (seconds since 1970 as double) in. This is set to
         *                       -1 if the datefieldname can not be parsed.
         * @param replyfieldname the name of the OUT parameter to put messages in.
         *                       These must be end-user readable. Set to error
         *                       message if timefieldname contains -1, or a
         *                       confirmation message if that deadline is OK.
         */
        @JsonCreator
        public CheckDeadline(@JsonProperty("datefieldname") String datefieldname,
                        @JsonProperty("timefieldname") String timefieldname,
                        @JsonProperty("replyfieldname") String replyfieldname)
                        throws IOException {

                this.timefieldname = timefieldname;
                this.datefieldname = datefieldname;
                this.replyfieldname = replyfieldname;
        }

        @Override
        public int hashCode() {
                return Objects.hash(datefieldname, replyfieldname, timefieldname);
        }

        @Override
        public boolean equals(Object obj) {
                if (this == obj)
                        return true;
                if (obj == null)
                        return false;
                if (getClass() != obj.getClass())
                        return false;
                CheckDeadline other = (CheckDeadline) obj;
                return Objects.equals(datefieldname, other.datefieldname)
                                && Objects.equals(replyfieldname, other.replyfieldname)
                                && Objects.equals(timefieldname, other.timefieldname);
        }

        @Override
        public Parameters call(Parameters parameters) {

                ParameterValue date = parameters.get(datefieldname);
                // check if string, if not that's a bug somewhere.
                if (!(date instanceof StringValue))
                        throw new IllegalArgumentException("Field " + datefieldname
                                        + " does not contain string but " + date);

                double deadline = -1;
                String message = "";
                try {
                        ZonedDateTime value = parse(((StringValue) date).getValue());
                        deadline = value.toInstant().getEpochSecond();

                        ZonedDateTime now = ZonedDateTime.now();
                        long diff = ChronoUnit.DAYS.between(now, value);

                        if (diff < 7) {
                                deadline = -1;
                                if (diff < 0)
                                        message = "Hmm, it seems like you have set a deadline in the past!<br/>Could you set a deadline in the future?";
                                else
                                        message = "Hmm, this seems a bit soon. How about setting a new deadline?";
                        } else {
                                if (diff < 14)
                                        message = "Okay!<br/>So you want to achieve your goal in "
                                                        + diff + " days";
                                else if (diff < 70)
                                        message = "Okay!<br/>So you want to achieve your goal in around "
                                                        + (int) (diff / 7) + " weeks";
                                else
                                        message = "Okay!<br/>So you want to achieve your goal in around "
                                                        + (int) (diff / 30) + " months";

                                message = message + " by "
                                                + value.format(DateString.dateformat);
                        }

                } catch (DateTimeParseException e) {
                        message = "Hmm, I didn't quite get that.<br/>Could you please reformulate the goal deadline you want to set?";
                }
                return parameters.with(timefieldname, new DoubleValue(deadline))
                                .with(replyfieldname, new StringValue(message));
        }

        @Override
        public List<String> getAssignedParameters() {
                return Arrays.asList(timefieldname);
        }

        /**
         * @param date a string using the format "day-month-year".
         * @return parsed date, or null if we can't parse it. We use the system
         *         timezone to convert the given date to absolute time.
         */
        private ZonedDateTime parse(String date) throws DateTimeParseException {
                return parseZonedDate(date, "d-M-y");
        }

        /**
         * @param date   string with the date
         * @param format the expected format
         * @return Instant which is some date.
         * @throws DateTimeParseException if date can't be parsed
         */
        private ZonedDateTime parseZonedDate(String date, String format)
                        throws DateTimeParseException {
                DateTimeFormatter formatter = DateTimeFormatter.ofPattern(format);

                return LocalDate.parse(date, formatter)
                                .atStartOfDay(ZoneId.systemDefault());

        }
}