package org.rx.cache;

import org.rx.common.*;

import org.rx.beans.DateTime;

import java.util.Collections;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.concurrent.Future;

import java.util.function.Consumer;

import java.util.function.Function;

import static org.rx.common.Contract.as;

import static org.rx.common.Contract.require;

import static org.rx.util.AsyncTask.TaskFactory;

public final class LRUCache<TK, TV> extends Disposable {

    private class CacheItem {

        public TV            value;

        private int          expireSeconds;

        private DateTime     createTime;

        private Consumer<TV> expireCallback;

        public CacheItem(TV value, int expireSeconds, Consumer<TV> expireCallback) {

            this.value = value;

            this.expireSeconds = expireSeconds;

            this.expireCallback = expireCallback;

            refresh();

        }

        public void refresh() {

            if (expireSeconds > -1) {

                createTime = DateTime.utcNow();

            }

        }

        public void callback() {

            if (expireCallback != null) {

                expireCallback.accept(value);

            }

        }

    }

    private static final Lazy<LRUCache<String, Object>> instance = new Lazy<>(() -> new LRUCache<>(1000, 120));

    public static LRUCache<String, Object> getInstance() {

        return instance.getValue();

    }

    public static Object getOrStore(String key, Function<String, Object> supplier) {

        require(key, supplier);

        return getInstance().getOrAdd(App.cacheKey(key), p -> supplier.apply(key));

    }

    private final Map<TK, CacheItem> cache;

    private int                      maxCapacity;

    private int                      expireSeconds;

    private Consumer<TV>             expireCallback;

    private Future                   future;

    public LRUCache(int maxSize, int expireSecondsAfterAccess) {

        this(maxSize, expireSecondsAfterAccess, 8 * 1000, null);

    }

    public LRUCache(int maxSize, int expireSecondsAfterAccess, long checkPeriod, Consumer<TV> removeCallback) {

        cache = Collections.synchronizedMap(new LinkedHashMap<TK, CacheItem>(maxSize + 1, .75F, true) {

            @Override

            protected boolean removeEldestEntry(Map.Entry<TK, CacheItem> eldest) {

                boolean remove = size() > maxCapacity;

                if (remove) {

                    eldest.getValue().callback();

                }

                return remove;

            }

        });

        maxCapacity = maxSize;

        expireSeconds = expireSecondsAfterAccess;

        expireCallback = removeCallback;

        future = TaskFactory.schedule(() -> {

            for (Map.Entry<TK, CacheItem> entry : NQuery.of(cache.entrySet()).where(p -> p.getValue().expireSeconds > -1

                    && DateTime.utcNow().addSeconds(-p.getValue().expireSeconds).after(p.getValue().createTime))) {

                entry.getValue().callback();

                cache.remove(entry.getKey());

            }

        }, checkPeriod);

    }

    @Override

    protected void freeObjects() {

        if (future != null) {

            future.cancel(true);

        }

        cache.clear();

    }

    public void add(TK key, TV val) {

        add(key, val, expireSeconds, expireCallback);

    }

    public void add(TK key, TV val, int expireSecondsAfterAccess, Consumer<TV> removeCallback) {

        require(key);

        cache.put(key, new CacheItem(val, expireSecondsAfterAccess, removeCallback));

    }

    public void remove(TK key) {

        remove(key, true);

    }

    public void remove(TK key, boolean destroy) {

        require(key);

        CacheItem remove = cache.remove(key);

        if (remove == null) {

            return;

        }

        AutoCloseable ac;

        if (destroy && (ac = as(remove.value, AutoCloseable.class)) != null) {

            try {

                ac.close();

            } catch (Exception ex) {

                Logger.error(ex, "Auto close error");

            }

        }

    }

    public TV get(TK key) {

        require(key);

        CacheItem item = cache.get(key);

        if (item == null) {

            return null;

        }

        item.refresh();

        return item.value;

    }

    public TV getOrAdd(TK key, Function<TK, TV> supplier) {

        require(key, supplier);

        CacheItem item = cache.get(key);

        if (item == null) {

            cache.put(key, item = new CacheItem(supplier.apply(key), expireSeconds, expireCallback));

        } else {

            item.refresh();

        }

        return item.value;

    }

}