package de.micromata.borgbutler.jobs;

import de.micromata.borgbutler.utils.DateUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.time.LocalDateTime;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public abstract class AbstractJob<T> {
    private Logger logger = LoggerFactory.getLogger(AbstractJob.class);

    public boolean isCancellationRequested() {
        return this.cancellationRequested;
    }

    public Status getStatus() {
        return this.status;
    }

    public String getTitle() {
        return this.title;
    }

    Future<JobResult<T>> getFuture() {
        return this.future;
    }

    public long getUniqueJobNumber() {
        return this.uniqueJobNumber;
    }

    public String getCreateTime() {
        return this.createTime;
    }

    public String getStartTime() {
        return this.startTime;
    }

    public String getStopTime() {
        return this.stopTime;
    }

    public AbstractJob<T> setCancellationRequested(boolean cancellationRequested) {
        this.cancellationRequested = cancellationRequested;
        return this;
    }

    public AbstractJob<T> setTitle(String title) {
        this.title = title;
        return this;
    }

    AbstractJob<T> setFuture(Future<JobResult<T>> future) {
        this.future = future;
        return this;
    }

    protected AbstractJob<T> setUniqueJobNumber(long uniqueJobNumber) {
        this.uniqueJobNumber = uniqueJobNumber;
        return this;
    }

    public AbstractJob<T> setCreateTime(String createTime) {
        this.createTime = createTime;
        return this;
    }

    public AbstractJob<T> setStartTime(String startTime) {
        this.startTime = startTime;
        return this;
    }

    public AbstractJob<T> setStopTime(String stopTime) {
        this.stopTime = stopTime;
        return this;
    }

    public enum Status {DONE, RUNNING, QUEUED, CANCELLED, FAILED}

    private boolean cancellationRequested;
    private Status status;
    private String title;
    private Future<JobResult<T>> future;
    private long uniqueJobNumber = -1;
    private String createTime;
    private String startTime;
    private String stopTime;

    protected AbstractJob<T> setStatus(Status status) {
        if (status == Status.RUNNING && this.status != Status.RUNNING) {
            this.startTime = DateUtils.format(LocalDateTime.now());
        } else if (status != Status.RUNNING && this.status == Status.RUNNING) {
            this.stopTime = DateUtils.format(LocalDateTime.now());
        }
        this.status = status;
        return this;
    }

    public void cancel() {
        if (this.getStatus() == Status.QUEUED) {
            setStatus(Status.CANCELLED);
        }
        this.cancellationRequested = true;
        cancelRunningProcess();
    }

    protected void setCancelled() {
        setStatus(Status.CANCELLED);
    }

    /**
     * Not supported if not implemented.
     */
    protected void cancelRunningProcess() {
    }

    /**
     * Waits for and gets the result.
     *
     * @return
     */
    public JobResult<T> getResult() {
        try {
            return future.get();
        } catch (InterruptedException | ExecutionException ex) {
            logger.error(ex.getMessage(), ex);
        }
        return null;
    }

    public T getResultObject() {
        return getResult().getResultObject();
    }

    protected void failed() {
        if (this.status == Status.CANCELLED) {
            // do nothing. It's normal that cancelled jobs fail.
            return;
        }
        if (this.status != null && this.status != Status.RUNNING) {
            logger.error("Internal error, illegal state! You shouldn't set the job status to FAILED if not in status RUNNING: " + this.status);
        }
        setStatus(Status.FAILED);
    }

    /**
     * @return true, if the job is done, stopped or failed. Otherwise false (if job is running or queued).
     */
    public boolean isFinished() {
        if (status == Status.DONE || status == Status.CANCELLED || status == Status.FAILED) {
            return true;
        }
        return false;
    }

    public abstract JobResult<T> execute();

    /**
     * A job is identified by this id. If a job with the same id is already queued (not yet finished), this job will
     * not be added twice.
     *
     * @return
     */
    public abstract Object getId();

    protected AbstractJob() {
        this.createTime = DateUtils.format(LocalDateTime.now());
    }
}