/*
 *  Copyright 2016 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.ametys.workspaces.repository.maintenance;

import java.util.HashMap;
import java.util.Map;

/**
 * TaskProgress
 */
public class TaskProgress
{
    private final float _total;
    private float _progress;
    private State _state;

    private Exception _exception;

    /**
     * Progress state
     */
    public enum State 
    {
        /** NEW */
        NEW,
        /** RUNNING */
        RUNNING,
        /** FINISHED */
        FINISHED,
        /** ERROR_STATE */
        ERROR_STATE
    }

    /**
     * Ctor
     * @param total The total progress
     */
    public TaskProgress(float total)
    {
        this._total = total;
        this._progress = 0f;
        this._state = State.NEW;
    }

    /**
     * Overriden Ctor
     * @param total The total progress
     * @param start The progress start
     */
    public TaskProgress(float total, float start)
    {
        this(total);
        this._progress = start;
    }

    /**
     * Unit progress
     */
    public void progress()
    {
        progress(1);
    }

    /**
     * Quantitative progress
     * @param quantity The quantity to progress
     */
    public synchronized void progress(float quantity)
    {
        _progress += quantity;
    }

    /**
     * Progress by a percentage relative to the range [current progress; total]
     * @param percentage must be in the [0; 100] range
     */
    public void progressRelativePercentage(int percentage)
    {
        if (percentage < 0 || percentage > 100)
        {
            throw new IllegalArgumentException("percentage must be in the [0; 100] range.");
        }

        synchronized (this)
        {
            if (percentage == 100)
            {
                _progress = _total;
            }
            else
            {
                _progress += (_total - _progress) * percentage / 100f;
            }
        }
    }

    /**
     * Progress by a given percentage
     * @param percentage must be in the [0; 100] range
     */
    public void progressTotalPercentage(int percentage)
    {
        if (percentage < 0 || percentage > 100)
        {
            throw new IllegalArgumentException("percentage must be in the [0; 100] range.");
        }

        synchronized (this)
        {
            if (percentage == 100)
            {
                _progress = _total;
            }
            else
            {
                _progress = _total * percentage / 100f;
            }
        }
    }

    /**
     * getProgressPercentage
     * @return int
     */
    public synchronized float getProgressPercentage()
    {
        return Math.min(1f, _progress / _total);
    }

    /**
     * setRunning
     */
    public synchronized void setRunning()
    {
        _state = State.RUNNING;
    }

    /**
     * setFinished
     */
    public synchronized void setFinished()
    {
        _state = State.FINISHED;
    }

    /**
     * setInErrorState
     */
    public void setInErrorState()
    {
        setInErrorState(null);
    }

    /**
     * setInErrorState
     * @param e The exception responsible for the error state
     */
    public synchronized void setInErrorState(Exception e)
    {
        _exception = e;
        _state = State.ERROR_STATE;
    }

    /**
     * isNotStarted
     * @return boolean
     */
    public boolean isNotStarted()
    {
        return State.NEW.equals(_state);
    }

    /**
     * isRunning
     * @return boolean
     */
    public boolean isRunning()
    {
        return State.RUNNING.equals(_state);
    }

    /**
     * isFinished
     * @return boolean
     */
    public boolean isFinished()
    {
        return State.FINISHED.equals(_state);
    }

    /**
     * isInErrorState
     * @return boolean
     */
    public boolean isInErrorState()
    {
        return State.ERROR_STATE.equals(_state);
    }

    /**
     * getException
     * @return Exception
     */
    public Exception getException()
    {
        return _exception;
    }

    /**
     * getState
     * @return State
     */
    public State getState()
    {
        return _state;
    }


    /**
     * Returns information this progress object.
     * @return a map containing information on the progress status
     */
    public Map<String, Object> getProgressInfo()
    {
        Map<String, Object> infos = new HashMap<>();
        synchronized (this)
        {
            infos.put("progress", _progress);
            infos.put("total", _total);
            infos.put("percentage", getProgressPercentage());
            infos.put("state", _state.name());
            if (_exception != null)
            {
                infos.put("exception", _exception.getLocalizedMessage());
            }
        }
        return infos;
    }

    @Override
    public String toString()
    {
        StringBuilder sb = new StringBuilder("Progress : ");
        synchronized (this)
        {
            sb.append(getProgressPercentage()).append(" ");
            sb.append("[").append(_progress).append("/").append(_total).append("]");
        }
        return sb.toString();
    }
}