package eu.eudat.model;

import eu.eudat.commons.enums.DescriptionStatus;
import eu.eudat.commons.enums.DmpStatus;
import eu.eudat.commons.enums.IsActive;
import eu.eudat.commons.enums.RecentActivityOrder;
import eu.eudat.query.lookup.DescriptionLookup;
import eu.eudat.query.lookup.DmpLookup;
import eu.eudat.query.lookup.DmpUserLookup;
import gr.cite.tools.data.query.Lookup;
import gr.cite.tools.data.query.Ordering;
import gr.cite.tools.data.query.Paging;
import gr.cite.tools.fieldset.BaseFieldSet;

import java.util.List;
import java.util.UUID;

public class RecentActivityItemLookup{

    private String like;
    private Boolean onlyDraft;
    private Boolean onlyDmp;
    private Boolean onlyDescription;
    private List<UUID> userIds;
    private Paging page;
    private BaseFieldSet project;
    private RecentActivityOrder orderField;

    public String getLike() {
        return like;
    }

    public void setLike(String like) {
        this.like = like;
    }

    public Boolean getOnlyDraft() {
        return onlyDraft;
    }

    public void setOnlyDraft(Boolean onlyDraft) {
        this.onlyDraft = onlyDraft;
    }

    public List<UUID> getUserIds() {
        return userIds;
    }

    public void setUserIds(List<UUID> userIds) {
        this.userIds = userIds;
    }

    public Paging getPage() {
        return page;
    }

    public void setPage(Paging page) {
        this.page = page;
    }

    public BaseFieldSet getProject() {
        return project;
    }

    public void setProject(BaseFieldSet project) {
        this.project = project;
    }

    public RecentActivityOrder getOrderField() {
        return orderField;
    }

    public void setOrderField(RecentActivityOrder orderField) {
        this.orderField = orderField;
    }

    public Boolean getOnlyDmp() {
        return onlyDmp;
    }

    public void setOnlyDmp(Boolean onlyDmp) {
        this.onlyDmp = onlyDmp;
    }

    public Boolean getOnlyDescription() {
        return onlyDescription;
    }

    public void setOnlyDescription(Boolean onlyDescription) {
        this.onlyDescription = onlyDescription;
    }

    public DescriptionLookup asDescriptionLookup() {
        if (this.onlyDmp != null) return null;

        DescriptionLookup lookup = new DescriptionLookup();
        lookup.setIsActive(List.of(IsActive.Active));
        if (this.like != null) lookup.setLike(this.like);
        if (this.onlyDraft != null) lookup.setStatuses(List.of(DescriptionStatus.Draft));
        else lookup.setStatuses(List.of(DescriptionStatus.Draft, DescriptionStatus.Finalized));
        if (this.userIds != null) {
            DmpLookup dmpLookup = new DmpLookup();
            DmpUserLookup dmpUserLookup = new DmpUserLookup();
            dmpUserLookup.setUserIds(this.userIds);
            dmpUserLookup.setIsActive(List.of(IsActive.Active));
            dmpLookup.setDmpUserSubQuery(dmpUserLookup);
            dmpLookup.setIsActive(List.of(IsActive.Active));
            lookup.setDmpSubQuery(dmpLookup);
        }
        if (this.page != null)  lookup.setPage(new Paging(this.page.getOffset(), this.page.getSize()));
        Ordering ordering = new Ordering();
        if (this.orderField != null) {
            switch (this.orderField){
                case Label -> ordering.addDescending(Description._label).addDescending(Description._updatedAt);
                case UpdatedAt -> ordering.addDescending(Description._updatedAt);
                case Status -> ordering.addDescending(Description._status).addDescending(Description._updatedAt);
                default -> throw  new IllegalArgumentException("Type not found" + this.orderField) ;
            }
        } else {
            ordering.addDescending(Description._updatedAt);
        }
        lookup.setOrder(ordering);
        if (this.project !=null) lookup.setProject((BaseFieldSet) this.project.extractPrefixed(RecentActivityItem._description));
        return lookup;
    }

    public DmpLookup asDmpLookup() {
        if (this.onlyDescription != null) return null;

        DmpLookup lookup = new DmpLookup();
        lookup.setIsActive(List.of(IsActive.Active));
        if (this.like != null) lookup.setLike(this.like);
        if (this.onlyDraft != null) lookup.setStatuses(List.of(DmpStatus.Draft));
        if (this.userIds != null) {
            DmpUserLookup dmpUserLookup = new DmpUserLookup();
            dmpUserLookup.setUserIds(this.userIds);
            dmpUserLookup.setIsActive(List.of(IsActive.Active));
            lookup.setDmpUserSubQuery(dmpUserLookup);
        }
        if (this.page != null)  lookup.setPage(new Paging(this.page.getOffset(), this.page.getSize()));
        Ordering ordering = new Ordering();
        if (this.orderField != null) {
            switch (this.orderField){
                case Label -> ordering.addDescending(Dmp._label);
                case UpdatedAt -> ordering.addDescending(Dmp._updatedAt);
                case Status -> ordering.addDescending(Dmp._status).addDescending(Dmp._updatedAt);
                default -> throw  new IllegalArgumentException("Type not found" + this.orderField) ;
            }
        } else {
            ordering.addDescending(Dmp._updatedAt);
        }
        lookup.setOrder(ordering);
        if (this.project !=null)lookup.setProject((BaseFieldSet) this.project.extractPrefixed(RecentActivityItem._dmp));
        return lookup;
    }

}