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

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.Struttura} entity. This class is used
 * in {@link it.sw.pa.comune.artegna.web.rest.StrutturaResource} to receive all the possible filtering options from
 * the Http GET request parameters.
 * For example the following could be a valid request:
 * {@code /strutturas?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 StrutturaCriteria implements Serializable, Criteria {

    @Serial
    private static final long serialVersionUID = 1L;

    private LongFilter id;

    private StringFilter nome;

    private StringFilter descrizione;

    private StringFilter indirizzo;

    private IntegerFilter capienzaMax;

    private BooleanFilter attiva;

    private StringFilter fotoUrl;

    private InstantFilter createdAt;

    private InstantFilter updatedAt;

    private LongFilter disponibilitaId;

    private LongFilter moduliLiberatorieId;

    private Boolean distinct;

    public StrutturaCriteria() {}

    public StrutturaCriteria(StrutturaCriteria other) {
        this.id = other.optionalId().map(LongFilter::copy).orElse(null);
        this.nome = other.optionalNome().map(StringFilter::copy).orElse(null);
        this.descrizione = other.optionalDescrizione().map(StringFilter::copy).orElse(null);
        this.indirizzo = other.optionalIndirizzo().map(StringFilter::copy).orElse(null);
        this.capienzaMax = other.optionalCapienzaMax().map(IntegerFilter::copy).orElse(null);
        this.attiva = other.optionalAttiva().map(BooleanFilter::copy).orElse(null);
        this.fotoUrl = other.optionalFotoUrl().map(StringFilter::copy).orElse(null);
        this.createdAt = other.optionalCreatedAt().map(InstantFilter::copy).orElse(null);
        this.updatedAt = other.optionalUpdatedAt().map(InstantFilter::copy).orElse(null);
        this.disponibilitaId = other.optionalDisponibilitaId().map(LongFilter::copy).orElse(null);
        this.moduliLiberatorieId = other.optionalModuliLiberatorieId().map(LongFilter::copy).orElse(null);
        this.distinct = other.distinct;
    }

    @Override
    public StrutturaCriteria copy() {
        return new StrutturaCriteria(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 StringFilter getNome() {
        return nome;
    }

    public Optional<StringFilter> optionalNome() {
        return Optional.ofNullable(nome);
    }

    public StringFilter nome() {
        if (nome == null) {
            setNome(new StringFilter());
        }
        return nome;
    }

    public void setNome(StringFilter nome) {
        this.nome = nome;
    }

    public StringFilter getDescrizione() {
        return descrizione;
    }

    public Optional<StringFilter> optionalDescrizione() {
        return Optional.ofNullable(descrizione);
    }

    public StringFilter descrizione() {
        if (descrizione == null) {
            setDescrizione(new StringFilter());
        }
        return descrizione;
    }

    public void setDescrizione(StringFilter descrizione) {
        this.descrizione = descrizione;
    }

    public StringFilter getIndirizzo() {
        return indirizzo;
    }

    public Optional<StringFilter> optionalIndirizzo() {
        return Optional.ofNullable(indirizzo);
    }

    public StringFilter indirizzo() {
        if (indirizzo == null) {
            setIndirizzo(new StringFilter());
        }
        return indirizzo;
    }

    public void setIndirizzo(StringFilter indirizzo) {
        this.indirizzo = indirizzo;
    }

    public IntegerFilter getCapienzaMax() {
        return capienzaMax;
    }

    public Optional<IntegerFilter> optionalCapienzaMax() {
        return Optional.ofNullable(capienzaMax);
    }

    public IntegerFilter capienzaMax() {
        if (capienzaMax == null) {
            setCapienzaMax(new IntegerFilter());
        }
        return capienzaMax;
    }

    public void setCapienzaMax(IntegerFilter capienzaMax) {
        this.capienzaMax = capienzaMax;
    }

    public BooleanFilter getAttiva() {
        return attiva;
    }

    public Optional<BooleanFilter> optionalAttiva() {
        return Optional.ofNullable(attiva);
    }

    public BooleanFilter attiva() {
        if (attiva == null) {
            setAttiva(new BooleanFilter());
        }
        return attiva;
    }

    public void setAttiva(BooleanFilter attiva) {
        this.attiva = attiva;
    }

    public StringFilter getFotoUrl() {
        return fotoUrl;
    }

    public Optional<StringFilter> optionalFotoUrl() {
        return Optional.ofNullable(fotoUrl);
    }

    public StringFilter fotoUrl() {
        if (fotoUrl == null) {
            setFotoUrl(new StringFilter());
        }
        return fotoUrl;
    }

    public void setFotoUrl(StringFilter fotoUrl) {
        this.fotoUrl = fotoUrl;
    }

    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 InstantFilter getUpdatedAt() {
        return updatedAt;
    }

    public Optional<InstantFilter> optionalUpdatedAt() {
        return Optional.ofNullable(updatedAt);
    }

    public InstantFilter updatedAt() {
        if (updatedAt == null) {
            setUpdatedAt(new InstantFilter());
        }
        return updatedAt;
    }

    public void setUpdatedAt(InstantFilter updatedAt) {
        this.updatedAt = updatedAt;
    }

    public LongFilter getDisponibilitaId() {
        return disponibilitaId;
    }

    public Optional<LongFilter> optionalDisponibilitaId() {
        return Optional.ofNullable(disponibilitaId);
    }

    public LongFilter disponibilitaId() {
        if (disponibilitaId == null) {
            setDisponibilitaId(new LongFilter());
        }
        return disponibilitaId;
    }

    public void setDisponibilitaId(LongFilter disponibilitaId) {
        this.disponibilitaId = disponibilitaId;
    }

    public LongFilter getModuliLiberatorieId() {
        return moduliLiberatorieId;
    }

    public Optional<LongFilter> optionalModuliLiberatorieId() {
        return Optional.ofNullable(moduliLiberatorieId);
    }

    public LongFilter moduliLiberatorieId() {
        if (moduliLiberatorieId == null) {
            setModuliLiberatorieId(new LongFilter());
        }
        return moduliLiberatorieId;
    }

    public void setModuliLiberatorieId(LongFilter moduliLiberatorieId) {
        this.moduliLiberatorieId = moduliLiberatorieId;
    }

    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 StrutturaCriteria that = (StrutturaCriteria) o;
        return (
            Objects.equals(id, that.id) &&
            Objects.equals(nome, that.nome) &&
            Objects.equals(descrizione, that.descrizione) &&
            Objects.equals(indirizzo, that.indirizzo) &&
            Objects.equals(capienzaMax, that.capienzaMax) &&
            Objects.equals(attiva, that.attiva) &&
            Objects.equals(fotoUrl, that.fotoUrl) &&
            Objects.equals(createdAt, that.createdAt) &&
            Objects.equals(updatedAt, that.updatedAt) &&
            Objects.equals(disponibilitaId, that.disponibilitaId) &&
            Objects.equals(moduliLiberatorieId, that.moduliLiberatorieId) &&
            Objects.equals(distinct, that.distinct)
        );
    }

    @Override
    public int hashCode() {
        return Objects.hash(
            id,
            nome,
            descrizione,
            indirizzo,
            capienzaMax,
            attiva,
            fotoUrl,
            createdAt,
            updatedAt,
            disponibilitaId,
            moduliLiberatorieId,
            distinct
        );
    }

    // prettier-ignore
    @Override
    public String toString() {
        return "StrutturaCriteria{" +
            optionalId().map(f -> "id=" + f + ", ").orElse("") +
            optionalNome().map(f -> "nome=" + f + ", ").orElse("") +
            optionalDescrizione().map(f -> "descrizione=" + f + ", ").orElse("") +
            optionalIndirizzo().map(f -> "indirizzo=" + f + ", ").orElse("") +
            optionalCapienzaMax().map(f -> "capienzaMax=" + f + ", ").orElse("") +
            optionalAttiva().map(f -> "attiva=" + f + ", ").orElse("") +
            optionalFotoUrl().map(f -> "fotoUrl=" + f + ", ").orElse("") +
            optionalCreatedAt().map(f -> "createdAt=" + f + ", ").orElse("") +
            optionalUpdatedAt().map(f -> "updatedAt=" + f + ", ").orElse("") +
            optionalDisponibilitaId().map(f -> "disponibilitaId=" + f + ", ").orElse("") +
            optionalModuliLiberatorieId().map(f -> "moduliLiberatorieId=" + f + ", ").orElse("") +
            optionalDistinct().map(f -> "distinct=" + f + ", ").orElse("") +
        "}";
    }
}
