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

import it.sw.pa.comune.artegna.domain.enumeration.TipoCanaleNotifica;
import it.sw.pa.comune.artegna.domain.enumeration.TipoEventoNotifica;
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.Notifica} entity. This class is used
 * in {@link it.sw.pa.comune.artegna.web.rest.NotificaResource} to receive all the possible filtering options from
 * the Http GET request parameters.
 * For example the following could be a valid request:
 * {@code /notificas?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 NotificaCriteria implements Serializable, Criteria {

    /**
     * Class for filtering TipoCanaleNotifica
     */
    public static class TipoCanaleNotificaFilter extends Filter<TipoCanaleNotifica> {

        public TipoCanaleNotificaFilter() {}

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

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

    /**
     * Class for filtering TipoEventoNotifica
     */
    public static class TipoEventoNotificaFilter extends Filter<TipoEventoNotifica> {

        public TipoEventoNotificaFilter() {}

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

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

    @Serial
    private static final long serialVersionUID = 1L;

    private LongFilter id;

    private TipoCanaleNotificaFilter tipoCanale;

    private TipoEventoNotificaFilter tipoEvento;

    private StringFilter messaggio;

    private BooleanFilter inviata;

    private InstantFilter inviataAt;

    private StringFilter errore;

    private InstantFilter createdAt;

    private LongFilter confermaId;

    private Boolean distinct;

    public NotificaCriteria() {}

    public NotificaCriteria(NotificaCriteria other) {
        this.id = other.optionalId().map(LongFilter::copy).orElse(null);
        this.tipoCanale = other.optionalTipoCanale().map(TipoCanaleNotificaFilter::copy).orElse(null);
        this.tipoEvento = other.optionalTipoEvento().map(TipoEventoNotificaFilter::copy).orElse(null);
        this.messaggio = other.optionalMessaggio().map(StringFilter::copy).orElse(null);
        this.inviata = other.optionalInviata().map(BooleanFilter::copy).orElse(null);
        this.inviataAt = other.optionalInviataAt().map(InstantFilter::copy).orElse(null);
        this.errore = other.optionalErrore().map(StringFilter::copy).orElse(null);
        this.createdAt = other.optionalCreatedAt().map(InstantFilter::copy).orElse(null);
        this.confermaId = other.optionalConfermaId().map(LongFilter::copy).orElse(null);
        this.distinct = other.distinct;
    }

    @Override
    public NotificaCriteria copy() {
        return new NotificaCriteria(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 TipoCanaleNotificaFilter getTipoCanale() {
        return tipoCanale;
    }

    public Optional<TipoCanaleNotificaFilter> optionalTipoCanale() {
        return Optional.ofNullable(tipoCanale);
    }

    public TipoCanaleNotificaFilter tipoCanale() {
        if (tipoCanale == null) {
            setTipoCanale(new TipoCanaleNotificaFilter());
        }
        return tipoCanale;
    }

    public void setTipoCanale(TipoCanaleNotificaFilter tipoCanale) {
        this.tipoCanale = tipoCanale;
    }

    public TipoEventoNotificaFilter getTipoEvento() {
        return tipoEvento;
    }

    public Optional<TipoEventoNotificaFilter> optionalTipoEvento() {
        return Optional.ofNullable(tipoEvento);
    }

    public TipoEventoNotificaFilter tipoEvento() {
        if (tipoEvento == null) {
            setTipoEvento(new TipoEventoNotificaFilter());
        }
        return tipoEvento;
    }

    public void setTipoEvento(TipoEventoNotificaFilter tipoEvento) {
        this.tipoEvento = tipoEvento;
    }

    public StringFilter getMessaggio() {
        return messaggio;
    }

    public Optional<StringFilter> optionalMessaggio() {
        return Optional.ofNullable(messaggio);
    }

    public StringFilter messaggio() {
        if (messaggio == null) {
            setMessaggio(new StringFilter());
        }
        return messaggio;
    }

    public void setMessaggio(StringFilter messaggio) {
        this.messaggio = messaggio;
    }

    public BooleanFilter getInviata() {
        return inviata;
    }

    public Optional<BooleanFilter> optionalInviata() {
        return Optional.ofNullable(inviata);
    }

    public BooleanFilter inviata() {
        if (inviata == null) {
            setInviata(new BooleanFilter());
        }
        return inviata;
    }

    public void setInviata(BooleanFilter inviata) {
        this.inviata = inviata;
    }

    public InstantFilter getInviataAt() {
        return inviataAt;
    }

    public Optional<InstantFilter> optionalInviataAt() {
        return Optional.ofNullable(inviataAt);
    }

    public InstantFilter inviataAt() {
        if (inviataAt == null) {
            setInviataAt(new InstantFilter());
        }
        return inviataAt;
    }

    public void setInviataAt(InstantFilter inviataAt) {
        this.inviataAt = inviataAt;
    }

    public StringFilter getErrore() {
        return errore;
    }

    public Optional<StringFilter> optionalErrore() {
        return Optional.ofNullable(errore);
    }

    public StringFilter errore() {
        if (errore == null) {
            setErrore(new StringFilter());
        }
        return errore;
    }

    public void setErrore(StringFilter errore) {
        this.errore = errore;
    }

    public InstantFilter getCreatedAt() {
        return createdAt;
    }

    public Optional<InstantFilter> optionalCreatedAt() {
        return Optional.ofNullable(createdAt);
    }

    public InstantFilter createdAt() {
        if (createdAt == null) {
            setCreatedAt(new InstantFilter());
        }
        return createdAt;
    }

    public void setCreatedAt(InstantFilter createdAt) {
        this.createdAt = createdAt;
    }

    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 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 NotificaCriteria that = (NotificaCriteria) o;
        return (
            Objects.equals(id, that.id) &&
            Objects.equals(tipoCanale, that.tipoCanale) &&
            Objects.equals(tipoEvento, that.tipoEvento) &&
            Objects.equals(messaggio, that.messaggio) &&
            Objects.equals(inviata, that.inviata) &&
            Objects.equals(inviataAt, that.inviataAt) &&
            Objects.equals(errore, that.errore) &&
            Objects.equals(createdAt, that.createdAt) &&
            Objects.equals(confermaId, that.confermaId) &&
            Objects.equals(distinct, that.distinct)
        );
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, tipoCanale, tipoEvento, messaggio, inviata, inviataAt, errore, createdAt, confermaId, distinct);
    }

    // prettier-ignore
    @Override
    public String toString() {
        return "NotificaCriteria{" +
            optionalId().map(f -> "id=" + f + ", ").orElse("") +
            optionalTipoCanale().map(f -> "tipoCanale=" + f + ", ").orElse("") +
            optionalTipoEvento().map(f -> "tipoEvento=" + f + ", ").orElse("") +
            optionalMessaggio().map(f -> "messaggio=" + f + ", ").orElse("") +
            optionalInviata().map(f -> "inviata=" + f + ", ").orElse("") +
            optionalInviataAt().map(f -> "inviataAt=" + f + ", ").orElse("") +
            optionalErrore().map(f -> "errore=" + f + ", ").orElse("") +
            optionalCreatedAt().map(f -> "createdAt=" + f + ", ").orElse("") +
            optionalConfermaId().map(f -> "confermaId=" + f + ", ").orElse("") +
            optionalDistinct().map(f -> "distinct=" + f + ", ").orElse("") +
        "}";
    }
}
