package net.frozenorb.apiv3.models;

import com.google.common.collect.ImmutableList;
import com.google.common.primitives.Ints;
import com.mongodb.async.client.MongoCollection;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import fr.javatic.mongo.jacksonCodec.objectId.Id;
import lombok.Getter;
import net.frozenorb.apiv3.APIv3;
import net.frozenorb.apiv3.unsorted.BlockingCallback;
import net.frozenorb.apiv3.utils.SyncUtils;
import org.bson.Document;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

public final class Rank {

    private static final MongoCollection<Rank> ranksCollection = APIv3.getDatabase().getCollection("ranks", Rank.class);

    private static Map<String, Rank> rankCache = null;
    private static List<Rank> rankAltCache = null;
    private static long rankCacheUpdated = 0;

    @Getter @Id private String id;
    @Getter private int weight;
    @Getter private String displayName;
    @Getter private String gameColor;
    @Getter private String websiteColor;
    @Getter private boolean staffRank;

    public static List<Rank> findAll() {
        updateCacheIfNeeded();
        return ImmutableList.copyOf(rankAltCache);
    }

    public static Rank findById(String id) {
        updateCacheIfNeeded();
        return rankCache.get(id);
    }

    public Rank() {} // For Morphia

    public Rank(String id, int weight, String displayName, String gameColor, String websiteColor, boolean staffRank) {
        this.id = id;
        this.weight = weight;
        this.displayName = displayName;
        this.gameColor = gameColor;
        this.websiteColor = websiteColor;
        this.staffRank = staffRank;
    }

    private static void updateCacheIfNeeded() {
        if (rankCache == null || (System.currentTimeMillis() - rankCacheUpdated) > TimeUnit.MINUTES.toMillis(1)) {
            Map<String, Rank> working = new HashMap<>();
            List<Rank> workingAlt = new ArrayList<>();
            List<Rank> allRanks = SyncUtils.blockMulti(ranksCollection.find());
            allRanks.sort((a, b) -> Ints.compare(a.getWeight(), b.getWeight()));

            for (Rank rank : allRanks) {
                working.put(rank.getId(), rank);
                workingAlt.add(rank);
            }

            rankCache = working;
            rankAltCache = workingAlt;
            rankCacheUpdated = System.currentTimeMillis();
        }
    }

    public void insert() {
        BlockingCallback<Void> callback = new BlockingCallback<>();
        ranksCollection.insertOne(this, callback);
        callback.get();
    }

    public void save() {
        BlockingCallback<UpdateResult> callback = new BlockingCallback<>();
        ranksCollection.replaceOne(new Document("_id", id), this, callback);
        callback.get();
    }

    public void delete() {
        BlockingCallback<DeleteResult> callback = new BlockingCallback<>();
        ranksCollection.deleteOne(new Document("_id", id), callback);
        callback.get();
    }

}