package org.nexuis;

import io.netty.util.internal.ThreadLocalRandom;
import org.redisson.Redisson;
import org.redisson.api.BatchOptions;
import org.redisson.api.RBatch;
import org.redisson.api.RMap;
import org.redisson.api.RMapAsync;
import org.redisson.api.RSearch;
import org.redisson.api.RedissonClient;
import org.redisson.api.SortOrder;
import org.redisson.api.search.index.FieldIndex;
import org.redisson.api.search.index.IndexOptions;
import org.redisson.api.search.index.IndexType;
import org.redisson.api.search.query.Document;
import org.redisson.api.search.query.QueryOptions;
import org.redisson.api.search.query.SearchResult;
import org.redisson.client.codec.StringCodec;
import org.redisson.config.Config;
import org.redisson.config.TransportMode;
import org.redisson.connection.ConnectionListener;

import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.locks.LockSupport;

public class RedissonController {

    private static final StringCodec UTF8_CODEC = new StringCodec(StandardCharsets.UTF_8);

    private static RedissonClient redisson;

    private static int numb = 0;

    private static void search(String name) {
        long t1 = System.nanoTime();
        SearchResult r = redisson.getSearch(UTF8_CODEC).search("auctionidx2", name, QueryOptions.defaults().sortBy("date")
                        .sortOrder(SortOrder.DESC).limit(numb, 1));
        for (Document rDocument : r.getDocuments()) {
            Object o = rDocument.getAttributes().get("date");
            System.out.println(rDocument.getAttributes().get("owner")+ " " + o + " " + (System.nanoTime() - t1)/(1_000_000.0));
        }
        numb++;

        long t2 = System.nanoTime();

    }

    public static void main(String[] args) {
        Config config = new Config();
        config.setTransportMode(TransportMode.NIO);
        config.setNettyThreads(8);
        config.setConnectionListener(new ConnectionListener() {

                    @Override
                    public void onConnect(InetSocketAddress inetSocketAddress) {

                    }

                    @Override
                    public void onDisconnect(InetSocketAddress inetSocketAddress) {

                    }
                }
        );
        System.out.println("at " + System.currentTimeMillis());
        config.useSingleServer().setAddress("redis://10.8.1.20:6379").setPassword(null)
                .setConnectionMinimumIdleSize(1)
                .setConnectionPoolSize(8);
        redisson = Redisson.create(config);
        System.out.println("connecting at " + System.currentTimeMillis());
        try {
            RSearch rSearch = redisson.getSearch();
            rSearch.createIndex("auctionidx2", IndexOptions.defaults().on(IndexType.HASH)
                            .prefix("au:"),
                    FieldIndex.numeric("date"),
                    FieldIndex.numeric("price"),
                    FieldIndex.text("owner"),
                    FieldIndex.text("customer"),
                    FieldIndex.text("where"));
        } catch (Exception e) {
            e.printStackTrace();
        }
        RBatch rBatch = redisson.createBatch(BatchOptions.defaults().executionMode(BatchOptions.ExecutionMode.REDIS_WRITE_ATOMIC));

        long put = System.currentTimeMillis();
        for (int i = 0; i < 20_000; i++) {
            String playerName = UUID.randomUUID().toString().substring(0,6);
            UUID playerID = UUID.randomUUID();
            RMapAsync<Object, Object> player = rBatch.getMap("au:"+playerName, UTF8_CODEC);
            Map<String, Object> objectMap = new HashMap<>();
            objectMap.put("owner", "x"+playerName);
            objectMap.put("uuid", playerID.toString());
            objectMap.put("customer", "x"+playerName);
            objectMap.put("date", put);
            objectMap.put("price", ThreadLocalRandom.current().nextDouble(100000000));
            player.putAllAsync(objectMap);
            System.out.println("player name " + playerName);
            put+=1000;
        }
        try {
            rBatch.executeAsync().get();
        } catch (InterruptedException | ExecutionException e) {
            throw new RuntimeException(e);
        }

        Scanner scanner = new Scanner(System.in);
        RMap<Object, Object> map = redisson.getMap("testingkeys", UTF8_CODEC);
        System.out.println("start " + System.currentTimeMillis());
        while (true) {
//            String line = scanner.nextLine();
            try {
                search("*");
            } catch (Exception exception) {
                exception.printStackTrace();
            }
            LockSupport.parkNanos(500_000);
        }
    }

}