package io.lettuce.core;

import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.json.JsonPath;
import io.lettuce.core.protocol.DecodeBufferPolicies;
import io.lettuce.core.protocol.ProtocolVersion;
import io.lettuce.core.search.arguments.CreateArgs;
import io.lettuce.core.search.arguments.NumericFieldArgs;
import io.lettuce.core.search.arguments.SearchArgs;
import io.lettuce.core.search.arguments.SortByArgs;
import org.opentest4j.AssertionFailedError;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;

public class RediSearchBugProver {

    private static final Logger log = LoggerFactory.getLogger(RediSearchBugProver.class);

    public static void main(String[] args) {
        // System.setProperty("org.slf4j.simpleLogger.log.io.lettuce.core.protocol", "trace");
        var uri = RedisURI.create("localhost", 6379);
        try (var client = RedisClient.create(uri)) {
            client.setOptions(ClientOptions.builder()
                    // increase it drastically just to be sure discardBytesRatio is not the cause
                    .decodeBufferPolicy(DecodeBufferPolicies.ratio(Integer.MAX_VALUE / 2.0f))
                    // ft.search result on RESP2 is an array, on RESP3 a map. So error is different
                    .protocolVersion(ProtocolVersion.RESP2)
                    .build());
            try (var connection = client.connect()) {
                runTest(connection, String.valueOf(System.currentTimeMillis()));
            }
        }
    }

    private static void runTest(StatefulRedisConnection<String, String> con, String space) {
        var prefix = "test-" + space + ":";
        var index = "idx-" + space;

        log.info("===> running with {}, {}", prefix, index);
        con.sync().ftCreate(
                index,
                CreateArgs.<String, String>builder()
                        .on(CreateArgs.TargetType.JSON)
                        .withPrefix(prefix)
                        .build(),
                List.of(NumericFieldArgs.<String>builder().name("pos").build())
        );
        var searchArgs = SearchArgs.<String, String>builder()
                .sortBy(SortByArgs.<String>builder().attribute("pos").build())
                .limit(0, 10_000)
                .build();

        var expected = new ArrayList<>();
        for (int i = 1; i <= 1000; i++) {
            var latest = """
                    {"pos":%d,"ts":%d,"large":"just here to make the response larger to some great extend and overflow the buffers"}
                    """.formatted(i, System.currentTimeMillis()).trim();
            // lettuce<7.x: con.sync().jsonSet(prefix + i, JsonPath.ROOT_PATH, con.sync().getJsonParser().createJsonValue(latest));
            con.sync().jsonSet(prefix + i, JsonPath.ROOT_PATH, latest);
            expected.add(latest);

            if (i >= 924) {
                log.info("=== search {}", i);
                var searchReply = con.sync().ftSearch(index, "*", searchArgs);
                // with RESP3 this simply returns 0 as the map keys in Resp3SearchResultsParser are not found
                assertEquals(expected.size(), searchReply.getCount());
                for (int t = 1; t <= expected.size(); t++) {
                    var fields = searchReply.getResults().get(t - 1).getFields();
                    try {
                        assertEquals(expected.get(t - 1), fields.get("$"));
                    } catch (AssertionFailedError e) {
                        // with RESP2 this shows strange fields instead of the expected '$={"pos":..."'
                        log.info("Fields at pos {}: {}", t - 1, fields);
                        throw new AssertionFailedError("On loop " + i + ": " + e.getMessage(), e);
                    }
                }
            }
        }
    }

}