package core.util;

import java.io.UnsupportedEncodingException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import core.nonblocking.NonBlockingRequestHandler;
import engine.webspider.WebSpider;

/**
 * Class schedules logout request. The submitted logout request can be
 * rescheduled if required.
 *
 * @author dimitrijs
 */
public class SupplierSessionCleaner {
    private static final int TIMEOUT = (int) TimeUnit.MINUTES.toSeconds(3);
    private static final Logger logger = LoggerFactory
            .getLogger(SupplierSessionCleaner.class);
    private static final ScheduledExecutorService executor = Executors
            .newSingleThreadScheduledExecutor(new ThreadFactory() {
                @Override
                public Thread newThread(Runnable r) {
                    Thread result = new Thread(r, SupplierSessionCleaner.class.getName());
                    result.setDaemon(false);
                    result.setPriority(Thread.NORM_PRIORITY - 1);
                    return result;
                }
            });
    private int modCount = 0;
    private final WebSpider spider = new LogoutWebSpider();
    private final String name;
    private ScheduledFuture<?> future;
    private boolean closed = false;

    /**
     * registers the logoutRequest to be run after closeAfter minutes.
     *
     * @param name spider's name
     * @param logoutDelay how long (in minutes) to wait before to run logout request
     */
    public SupplierSessionCleaner(String name, long logoutDelay) {
        this.name = name + "Logout";
    }

    /**
     * Reschedules logout request for later time.
     * If it is a first call this method does initial schedule.
     * So should be called after webspider is initialized.
     *
     * @param logoutDelay delay (in minutes) logout request
     * @throws IllegalStateException if logout request already sent
     */
    public synchronized void reschedule(long logoutDelay) {
        if (closed) {
            throw new IllegalStateException("already closed [" + name + "]");
        }
        if (future != null) {
            future.cancel(false);
        }
        modCount++;
        LogoutWorker worker = new LogoutWorker(modCount);
        future = executor.schedule(worker, logoutDelay, TimeUnit.MINUTES);
        logger.debug("logout request rescheduled [{}]. delay {} min", name, logoutDelay);
    }

    /**
     * Forces to execute logout request
     */
    public synchronized void logout() {
        if (future == null) {
            logger.debug("already logged out [{}]", name);
            return;
        }
        future.cancel(false);
        future = null;
        closed = true;
        logger.debug("submitting logout request [{}]", name);
        try {
            spider.run();
        } catch (Throwable ex) {
            logger.warn("logout request submission error [" + name + "]", ex);
        }
    }

    private synchronized void tryLogout(int expectedModCount) {
        if (expectedModCount == modCount) {
            logger.debug("scheduled logging out [{}]", name);
            logout();
        } else {
            logger.debug("scheduled logging out is cancelled due to previous reschedule [{}]", name);
        }
    }


    /*  ========================================================
     *  DELEGATED METHODS OF WEBSPIDER.
     *  TODO: ADD MORE, IF REQUIRED
     *  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
     */

    public final void addHttpGetField(String field, long value) {
        spider.addHttpGetField(field, value);
    }

    public final void addHttpGetField(String field, Object value) {
        spider.addHttpGetField(field, value);
    }

    public final void addHttpHeader(String header, String value) {
        spider.addHttpHeader(header, value);
    }

    public final void addHttpPostField(String field, long value) throws UnsupportedEncodingException {
        spider.addHttpPostField(field, value);
    }

    public final void addHttpPostField(String field, String value) throws UnsupportedEncodingException {
        spider.addHttpPostField(field, value);
    }

    public final void newHttpGetRequest(String url) {
        spider.newHttpGetRequest(url);
    }

    public final void newHttpPostRequest(String url) {
        spider.newHttpPostRequest(url);
    }

    public void setHttpCharset(String charset) {
        spider.setHttpCharset(charset);
    }

    public final void setHttpCookie(String key, String value) {
        spider.setHttpCookie(key, value);
    }

    public final void setHttpHeader(String header, String value) {
        spider.setHttpHeader(header, value);
    }

    public final void setHttpMethodGet() {
        spider.setHttpMethodGet();
    }

    public final void setHttpMethodPost() {
        spider.setHttpMethodPost();
    }

    // -----------------------------------------------------------------------------------

    private class LogoutWebSpider extends WebSpider implements NonBlockingRequestHandler {

        @Override
        public String getSpiderName() {
            return name;
        }

        @Override
        public void runTask() throws Throwable {
            init();
        }

        private void cleanup() {
            try {
                close();
                // TODO: maybe need more cleanup?
            } catch (Throwable t) {
                if (logger.isWarnEnabled()) {
                    logger.warn("logout spider cleanup error [" + name + "]", t);
                }
            }
        }

        @Override
        public void downloadingComplete() {
            logger.debug("logout request successful [{}]", name);
            cleanup();
        }

        @Override
        public void downloadingFailed(Exception ex) {
            if (logger.isWarnEnabled()) {
                logger.warn("logout request unsuccessful [" + name + "]", ex);
            }
            cleanup();
        }

        @Override
        public void init() {
            try {
                // TODO: more init? (proxies etc)
                download(TIMEOUT);
            } catch (Throwable t) {
                logger.error("Logging out error [" + name + "]", t);
            }
        }

    }

    // -----------------------------------------------------------------------------------

    private class LogoutWorker implements Runnable {
        private final int expectedModCount;

        LogoutWorker(int expectedModCount) {
            this.expectedModCount = expectedModCount;
        }

        @Override
        public void run() {
            SupplierSessionCleaner.this.tryLogout(expectedModCount);
        }
    }
}