package it.sw.pa.comune.artegna.service.criteria;

import it.sw.pa.comune.artegna.domain.enumeration.StatoPrenotazione;
import java.io.Serial;
import java.io.Serializable;
import java.util.Objects;
import java.util.Optional;
import org.springdoc.core.annotations.ParameterObject;
import tech.jhipster.service.Criteria;
import tech.jhipster.service.filter.*;

/**
 * Criteria class for the {@link it.sw.pa.comune.artegna.domain.Prenotazione} entity. This class is used
 * in {@link it.sw.pa.comune.artegna.web.rest.PrenotazioneResource} to receive all the possible filtering options from
 * the Http GET request parameters.
 * For example the following could be a valid request:
 * {@code /prenotaziones?id.greaterThan=5&attr1.contains=something&attr2.specified=false}
 * As Spring is unable to properly convert the types, unless specific {@link Filter} class are used, we need to use
 * fix type specific filters.
 */
@ParameterObject
@SuppressWarnings("common-java:DuplicatedBlocks")
public class PrenotazioneCriteria implements Serializable, Criteria {

    /**
     * Class for filtering StatoPrenotazione
     */
    public static class StatoPrenotazioneFilter extends Filter<StatoPrenotazione> {

        public StatoPrenotazioneFilter() {}

        public StatoPrenotazioneFilter(StatoPrenotazioneFilter filter) {
            super(filter);
        }

        @Override
        public StatoPrenotazioneFilter copy() {
            return new StatoPrenotazioneFilter(this);
        }
    }

    @Serial
    private static final long serialVersionUID = 1L;

    private LongFilter id;

    private InstantFilter oraInizio;

    private InstantFilter oraFine;

    private StatoPrenotazioneFilter stato;

    private StringFilter motivoEvento;

    private IntegerFilter numeroPartecipanti;

    private StringFilter noteUtente;

    private LongFilter confermaId;

    private LongFilter utenteId;

    private LongFilter strutturaId;

    private Boolean distinct;

    public PrenotazioneCriteria() {}

    public PrenotazioneCriteria(PrenotazioneCriteria other) {
        this.id = other.optionalId().map(LongFilter::copy).orElse(null);
        this.oraInizio = other.optionalOraInizio().map(InstantFilter::copy).orElse(null);
        this.oraFine = other.optionalOraFine().map(InstantFilter::copy).orElse(null);
        this.stato = other.optionalStato().map(StatoPrenotazioneFilter::copy).orElse(null);
        this.motivoEvento = other.optionalMotivoEvento().map(StringFilter::copy).orElse(null);
        this.numeroPartecipanti = other.optionalNumeroPartecipanti().map(IntegerFilter::copy).orElse(null);
        this.noteUtente = other.optionalNoteUtente().map(StringFilter::copy).orElse(null);
        this.confermaId = other.optionalConfermaId().map(LongFilter::copy).orElse(null);
        this.utenteId = other.optionalUtenteId().map(LongFilter::copy).orElse(null);
        this.strutturaId = other.optionalStrutturaId().map(LongFilter::copy).orElse(null);
        this.distinct = other.distinct;
    }

    @Override
    public PrenotazioneCriteria copy() {
        return new PrenotazioneCriteria(this);
    }

    public LongFilter getId() {
        return id;
    }

    public Optional<LongFilter> optionalId() {
        return Optional.ofNullable(id);
    }

    public LongFilter id() {
        if (id == null) {
            setId(new LongFilter());
        }
        return id;
    }

    public void setId(LongFilter id) {
        this.id = id;
    }

    public InstantFilter getOraInizio() {
        return oraInizio;
    }

    public Optional<InstantFilter> optionalOraInizio() {
        return Optional.ofNullable(oraInizio);
    }

    public InstantFilter oraInizio() {
        if (oraInizio == null) {
            setOraInizio(new InstantFilter());
        }
        return oraInizio;
    }

    public void setOraInizio(InstantFilter oraInizio) {
        this.oraInizio = oraInizio;
    }

    public InstantFilter getOraFine() {
        return oraFine;
    }

    public Optional<InstantFilter> optionalOraFine() {
        return Optional.ofNullable(oraFine);
    }

    public InstantFilter oraFine() {
        if (oraFine == null) {
            setOraFine(new InstantFilter());
        }
        return oraFine;
    }

    public void setOraFine(InstantFilter oraFine) {
        this.oraFine = oraFine;
    }

    public StatoPrenotazioneFilter getStato() {
        return stato;
    }

    public Optional<StatoPrenotazioneFilter> optionalStato() {
        return Optional.ofNullable(stato);
    }

    public StatoPrenotazioneFilter stato() {
        if (stato == null) {
            setStato(new StatoPrenotazioneFilter());
        }
        return stato;
    }

    public void setStato(StatoPrenotazioneFilter stato) {
        this.stato = stato;
    }

    public StringFilter getMotivoEvento() {
        return motivoEvento;
    }

    public Optional<StringFilter> optionalMotivoEvento() {
        return Optional.ofNullable(motivoEvento);
    }

    public StringFilter motivoEvento() {
        if (motivoEvento == null) {
            setMotivoEvento(new StringFilter());
        }
        return motivoEvento;
    }

    public void setMotivoEvento(StringFilter motivoEvento) {
        this.motivoEvento = motivoEvento;
    }

    public IntegerFilter getNumeroPartecipanti() {
        return numeroPartecipanti;
    }

    public Optional<IntegerFilter> optionalNumeroPartecipanti() {
        return Optional.ofNullable(numeroPartecipanti);
    }

    public IntegerFilter numeroPartecipanti() {
        if (numeroPartecipanti == null) {
            setNumeroPartecipanti(new IntegerFilter());
        }
        return numeroPartecipanti;
    }

    public void setNumeroPartecipanti(IntegerFilter numeroPartecipanti) {
        this.numeroPartecipanti = numeroPartecipanti;
    }

    public StringFilter getNoteUtente() {
        return noteUtente;
    }

    public Optional<StringFilter> optionalNoteUtente() {
        return Optional.ofNullable(noteUtente);
    }

    public StringFilter noteUtente() {
        if (noteUtente == null) {
            setNoteUtente(new StringFilter());
        }
        return noteUtente;
    }

    public void setNoteUtente(StringFilter noteUtente) {
        this.noteUtente = noteUtente;
    }

    public LongFilter getConfermaId() {
        return confermaId;
    }

    public Optional<LongFilter> optionalConfermaId() {
        return Optional.ofNullable(confermaId);
    }

    public LongFilter confermaId() {
        if (confermaId == null) {
            setConfermaId(new LongFilter());
        }
        return confermaId;
    }

    public void setConfermaId(LongFilter confermaId) {
        this.confermaId = confermaId;
    }

    public LongFilter getUtenteId() {
        return utenteId;
    }

    public Optional<LongFilter> optionalUtenteId() {
        return Optional.ofNullable(utenteId);
    }

    public LongFilter utenteId() {
        if (utenteId == null) {
            setUtenteId(new LongFilter());
        }
        return utenteId;
    }

    public void setUtenteId(LongFilter utenteId) {
        this.utenteId = utenteId;
    }

    public LongFilter getStrutturaId() {
        return strutturaId;
    }

    public Optional<LongFilter> optionalStrutturaId() {
        return Optional.ofNullable(strutturaId);
    }

    public LongFilter strutturaId() {
        if (strutturaId == null) {
            setStrutturaId(new LongFilter());
        }
        return strutturaId;
    }

    public void setStrutturaId(LongFilter strutturaId) {
        this.strutturaId = strutturaId;
    }

    public Boolean getDistinct() {
        return distinct;
    }

    public Optional<Boolean> optionalDistinct() {
        return Optional.ofNullable(distinct);
    }

    public Boolean distinct() {
        if (distinct == null) {
            setDistinct(true);
        }
        return distinct;
    }

    public void setDistinct(Boolean distinct) {
        this.distinct = distinct;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        final PrenotazioneCriteria that = (PrenotazioneCriteria) o;
        return (
            Objects.equals(id, that.id) &&
            Objects.equals(oraInizio, that.oraInizio) &&
            Objects.equals(oraFine, that.oraFine) &&
            Objects.equals(stato, that.stato) &&
            Objects.equals(motivoEvento, that.motivoEvento) &&
            Objects.equals(numeroPartecipanti, that.numeroPartecipanti) &&
            Objects.equals(noteUtente, that.noteUtente) &&
            Objects.equals(confermaId, that.confermaId) &&
            Objects.equals(utenteId, that.utenteId) &&
            Objects.equals(strutturaId, that.strutturaId) &&
            Objects.equals(distinct, that.distinct)
        );
    }

    @Override
    public int hashCode() {
        return Objects.hash(
            id,
            oraInizio,
            oraFine,
            stato,
            motivoEvento,
            numeroPartecipanti,
            noteUtente,
            confermaId,
            utenteId,
            strutturaId,
            distinct
        );
    }

    // prettier-ignore
    @Override
    public String toString() {
        return "PrenotazioneCriteria{" +
            optionalId().map(f -> "id=" + f + ", ").orElse("") +
            optionalOraInizio().map(f -> "oraInizio=" + f + ", ").orElse("") +
            optionalOraFine().map(f -> "oraFine=" + f + ", ").orElse("") +
            optionalStato().map(f -> "stato=" + f + ", ").orElse("") +
            optionalMotivoEvento().map(f -> "motivoEvento=" + f + ", ").orElse("") +
            optionalNumeroPartecipanti().map(f -> "numeroPartecipanti=" + f + ", ").orElse("") +
            optionalNoteUtente().map(f -> "noteUtente=" + f + ", ").orElse("") +
            optionalConfermaId().map(f -> "confermaId=" + f + ", ").orElse("") +
            optionalUtenteId().map(f -> "utenteId=" + f + ", ").orElse("") +
            optionalStrutturaId().map(f -> "strutturaId=" + f + ", ").orElse("") +
            optionalDistinct().map(f -> "distinct=" + f + ", ").orElse("") +
        "}";
    }
}
