Parameters and Configuration

public interface IParams {
    /**
     * Convert parameters to Redis protocol arguments
     * @return Array of byte arrays representing protocol arguments
     */
    byte[][] getByteParams();
}

public class SetParams implements IParams {
    /**
     * Set expiration in seconds
     * @param secondsToExpire Seconds until expiration
     * @return SetParams instance for chaining
     */
    public SetParams ex(long secondsToExpire);
    
    /**
     * Set expiration in milliseconds
     * @param millisecondsToExpire Milliseconds until expiration
     * @return SetParams instance
     */
    public SetParams px(long millisecondsToExpire);
    
    /**
     * Set expiration at specific Unix timestamp (seconds)
     * @param unixTime Unix timestamp in seconds
     * @return SetParams instance
     */
    public SetParams exAt(long unixTime);
    
    /**
     * Set expiration at specific Unix timestamp (milliseconds)
     * @param unixTimeInMillis Unix timestamp in milliseconds
     * @return SetParams instance
     */
    public SetParams pxAt(long unixTimeInMillis);
    
    /**
     * Set only if key doesn't exist (SET IF NOT EXISTS)
     * @return SetParams instance
     */
    public SetParams nx();
    
    /**
     * Set only if key exists (SET IF EXISTS)
     * @return SetParams instance
     */
    public SetParams xx();
    
    /**
     * Keep existing TTL (don't change expiration)
     * @return SetParams instance
     */
    public SetParams keepTtl();
    
    /**
     * Get previous value (GET SET behavior)
     * @return SetParams instance
     */
    public SetParams get();
    
    /**
     * Static factory method for convenient creation
     * @return New SetParams instance
     */
    public static SetParams setParams();
}

Jedis jedis = new Jedis("localhost", 6379);

// Set with expiration in seconds
SetParams expiryParams = SetParams.setParams().ex(3600);
jedis.set("session:abc", "user_data", expiryParams);

// Set only if not exists with millisecond precision
SetParams nxParams = SetParams.setParams().px(5000).nx();
String result = jedis.set("lock:resource", "locked", nxParams);

// Set with expiration at specific timestamp
long expireAt = System.currentTimeMillis() + 86400000; // 24 hours from now
SetParams timestampParams = SetParams.setParams().pxAt(expireAt);
jedis.set("daily_cache", "data", timestampParams);

// Update existing key while keeping TTL
SetParams keepTtlParams = SetParams.setParams().xx().keepTtl();
jedis.set("existing_key", "new_value", keepTtlParams);

// Atomic get-and-set operation
SetParams getSetParams = SetParams.setParams().get();
String previousValue = jedis.set("counter_backup", "new_counter", getSetParams);

jedis.close();

public class GetExParams implements IParams {
    /**
     * Set expiration in seconds
     * @param seconds Seconds until expiration
     * @return GetExParams instance
     */
    public GetExParams ex(long seconds);
    
    /**
     * Set expiration in milliseconds
     * @param milliseconds Milliseconds until expiration
     * @return GetExParams instance
     */
    public GetExParams px(long milliseconds);
    
    /**
     * Set expiration at Unix timestamp (seconds)
     * @param unixTime Unix timestamp in seconds
     * @return GetExParams instance
     */
    public GetExParams exAt(long unixTime);
    
    /**
     * Set expiration at Unix timestamp (milliseconds)
     * @param unixTimeInMillis Unix timestamp in milliseconds
     * @return GetExParams instance
     */
    public GetExParams pxAt(long unixTimeInMillis);
    
    /**
     * Remove expiration (make key persistent)
     * @return GetExParams instance
     */
    public GetExParams persist();
}

public class ScanParams implements IParams {
    /**
     * Set pattern match filter
     * @param pattern Glob-style pattern (supports *, ?, [abc])
     * @return ScanParams instance
     */
    public ScanParams match(String pattern);
    
    /**
     * Set count hint for number of elements to return per iteration
     * @param count Number of elements hint
     * @return ScanParams instance
     */
    public ScanParams count(int count);
    
    /**
     * Filter by key type (for SCAN command)
     * @param type Redis key type (string, list, set, zset, hash, stream)
     * @return ScanParams instance
     */
    public ScanParams type(String type);
    
    /**
     * Static factory method
     * @return New ScanParams instance
     */
    public static ScanParams scanParams();
}

// Scan keys with pattern matching
ScanParams userKeysParams = ScanParams.scanParams()
    .match("user:*")
    .count(100);

String cursor = "0";
do {
    ScanResult<String> scanResult = jedis.scan(cursor, userKeysParams);
    cursor = scanResult.getCursor();
    
    for (String key : scanResult.getResult()) {
        System.out.println("Found user key: " + key);
    }
} while (!cursor.equals("0"));

// Scan hash fields
ScanParams hashParams = ScanParams.scanParams()
    .match("*_count")
    .count(50);

cursor = "0";
do {
    ScanResult<Map.Entry<String, String>> hashScan = 
        jedis.hscan("statistics", cursor, hashParams);
    cursor = hashScan.getCursor();
    
    for (Map.Entry<String, String> entry : hashScan.getResult()) {
        System.out.println(entry.getKey() + " = " + entry.getValue());
    }
} while (!cursor.equals("0"));

public class ZAddParams implements IParams {
    /**
     * Set only if member doesn't exist
     * @return ZAddParams instance
     */
    public ZAddParams nx();
    
    /**
     * Set only if member exists (update existing)
     * @return ZAddParams instance
     */
    public ZAddParams xx();
    
    /**
     * Return changed count instead of added count
     * @return ZAddParams instance
     */
    public ZAddParams ch();
    
    /**
     * Increment score instead of setting it
     * @return ZAddParams instance
     */
    public ZAddParams incr();
    
    /**
     * Greater than - only update if new score is greater
     * @return ZAddParams instance
     */
    public ZAddParams gt();
    
    /**
     * Less than - only update if new score is less
     * @return ZAddParams instance
     */
    public ZAddParams lt();
}

public class ZRangeParams implements IParams {
    /**
     * Return elements in reverse order
     * @return ZRangeParams instance
     */
    public ZRangeParams rev();
    
    /**
     * Limit results with offset and count
     * @param offset Result offset
     * @param count Result count
     * @return ZRangeParams instance
     */
    public ZRangeParams limit(long offset, long count);
    
    /**
     * Range by score instead of rank
     * @return ZRangeParams instance
     */
    public ZRangeParams byScore();
    
    /**
     * Range by lexicographical order
     * @return ZRangeParams instance
     */
    public ZRangeParams byLex();
    
    /**
     * Include scores in results
     * @return ZRangeParams instance
     */
    public ZRangeParams withScores();
}

public class ZParams implements IParams {
    /**
     * Set weights for input sets
     * @param weights Array of weight values
     * @return ZParams instance
     */
    public ZParams weights(double... weights);
    
    /**
     * Set aggregation function
     * @param aggregate Aggregation function (SUM, MIN, MAX)
     * @return ZParams instance
     */
    public ZParams aggregate(Aggregate aggregate);
    
    public enum Aggregate {
        SUM, MIN, MAX
    }
}

// Add elements with conditional logic
ZAddParams conditionalAdd = new ZAddParams().nx().ch();
Long changed = jedis.zadd("leaderboard", Map.of("player1", 100.0), conditionalAdd);

// Update existing members only
ZAddParams updateOnly = new ZAddParams().xx().ch();
jedis.zadd("leaderboard", Map.of("player1", 150.0), updateOnly);

// Increment score
ZAddParams increment = new ZAddParams().incr();
Double newScore = jedis.zadd("leaderboard", Map.of("player1", 10.0), increment);

// Range with score filtering and limits
ZRangeParams rangeParams = new ZRangeParams()
    .byScore()
    .withScores()
    .limit(0, 10);

List<Tuple> topPlayers = jedis.zrangeWithScores("leaderboard", 90, 200, rangeParams);

// Union multiple sorted sets with weights
ZParams unionParams = new ZParams()
    .weights(2.0, 1.0)  // Weight first set 2x, second 1x
    .aggregate(ZParams.Aggregate.MAX);

jedis.zunionstore("combined_scores", unionParams, "leaderboard1", "leaderboard2");

public class GeoAddParams implements IParams {
    /**
     * Add only if member doesn't exist
     * @return GeoAddParams instance
     */
    public GeoAddParams nx();
    
    /**
     * Update only if member exists
     * @return GeoAddParams instance
     */
    public GeoAddParams xx();
    
    /**
     * Return changed count
     * @return GeoAddParams instance
     */
    public GeoAddParams ch();
}

public class GeoRadiusParam implements IParams {
    /**
     * Include coordinates in results
     * @return GeoRadiusParam instance
     */
    public GeoRadiusParam withCoord();
    
    /**
     * Include distances in results
     * @return GeoRadiusParam instance
     */
    public GeoRadiusParam withDist();
    
    /**
     * Include geohash values in results
     * @return GeoRadiusParam instance
     */
    public GeoRadiusParam withHash();
    
    /**
     * Limit number of results
     * @param count Maximum results
     * @return GeoRadiusParam instance
     */
    public GeoRadiusParam count(int count);
    
    /**
     * Sort results ascending by distance
     * @return GeoRadiusParam instance
     */
    public GeoRadiusParam sortAscending();
    
    /**
     * Sort results descending by distance
     * @return GeoRadiusParam instance
     */
    public GeoRadiusParam sortDescending();
    
    /**
     * Static factory method
     * @return New GeoRadiusParam instance
     */
    public static GeoRadiusParam geoRadiusParam();
}

public class GeoSearchParam implements IParams {
    /**
     * Search from specific coordinates
     * @param longitude Longitude coordinate
     * @param latitude Latitude coordinate
     * @return GeoSearchParam instance
     */
    public GeoSearchParam fromLonLat(double longitude, double latitude);
    
    /**
     * Search from existing member location
     * @param member Member name
     * @return GeoSearchParam instance
     */
    public GeoSearchParam fromMember(String member);
    
    /**
     * Search within radius
     * @param radius Search radius
     * @param unit Distance unit
     * @return GeoSearchParam instance
     */
    public GeoSearchParam byRadius(double radius, GeoUnit unit);
    
    /**
     * Search within rectangle box
     * @param width Box width
     * @param height Box height
     * @param unit Distance unit
     * @return GeoSearchParam instance
     */
    public GeoSearchParam byBox(double width, double height, GeoUnit unit);
    
    /**
     * Sort results ascending
     * @return GeoSearchParam instance
     */
    public GeoSearchParam asc();
    
    /**
     * Sort results descending
     * @return GeoSearchParam instance
     */
    public GeoSearchParam desc();
    
    /**
     * Limit result count
     * @param count Maximum results
     * @return GeoSearchParam instance
     */
    public GeoSearchParam count(int count);
    
    /**
     * Include coordinates in results
     * @return GeoSearchParam instance
     */
    public GeoSearchParam withCoord();
    
    /**
     * Include distances in results
     * @return GeoSearchParam instance
     */
    public GeoSearchParam withDist();
    
    /**
     * Include geohash in results
     * @return GeoSearchParam instance
     */
    public GeoSearchParam withHash();
}

// Add locations with conditions
Map<String, GeoCoordinate> locations = Map.of(
    "store1", new GeoCoordinate(-122.4194, 37.7749),  // San Francisco
    "store2", new GeoCoordinate(-118.2437, 34.0522)   // Los Angeles
);

GeoAddParams addParams = new GeoAddParams().nx().ch();
Long added = jedis.geoadd("stores", addParams, locations);

// Search for stores within radius with full information
GeoRadiusParam radiusParam = GeoRadiusParam.geoRadiusParam()
    .withCoord()
    .withDist() 
    .withHash()
    .count(10)
    .sortAscending();

List<GeoRadiusResponse> nearbyStores = jedis.georadius("stores", 
    -122.0, 37.5, 100, GeoUnit.MI, radiusParam);

for (GeoRadiusResponse store : nearbyStores) {
    System.out.println("Store: " + store.getMemberByString());
    System.out.println("Distance: " + store.getDistance() + " miles");
    System.out.println("Coordinates: " + store.getCoordinate());
}

// Modern GEOSEARCH (Redis 6.2+)
GeoSearchParam searchParam = new GeoSearchParam()
    .fromLonLat(-122.4194, 37.7749)
    .byRadius(50, GeoUnit.MI)
    .withDist()
    .withCoord()
    .asc()
    .count(5);

List<GeoRadiusResponse> searchResults = jedis.geosearch("stores", searchParam);

public class XAddParams implements IParams {
    /**
     * Set maximum stream length
     * @param maxLen Maximum number of entries
     * @return XAddParams instance
     */
    public XAddParams maxLen(long maxLen);
    
    /**
     * Set approximate maximum length for efficiency
     * @param maxLen Approximate maximum entries
     * @return XAddParams instance
     */
    public XAddParams maxLen(long maxLen, boolean approximateLength);
    
    /**
     * Minimum ID for trimming
     * @param minId Minimum entry ID to keep
     * @return XAddParams instance
     */
    public XAddParams minId(String minId);
    
    /**
     * Minimum ID with approximate trimming
     * @param minId Minimum entry ID
     * @param approximateLength Use approximate trimming
     * @return XAddParams instance
     */
    public XAddParams minId(String minId, boolean approximateLength);
    
    /**
     * Limit trimming operations for performance
     * @param limit Maximum trimming operations
     * @return XAddParams instance
     */
    public XAddParams limit(long limit);
    
    /**
     * Add only if ID doesn't exist
     * @return XAddParams instance
     */
    public XAddParams nomkStream();
}

public class XReadParams implements IParams {
    /**
     * Set read count limit
     * @param count Maximum entries to read per stream
     * @return XReadParams instance
     */
    public XReadParams count(int count);
    
    /**
     * Set blocking timeout
     * @param block Timeout in milliseconds (0 for infinite)
     * @return XReadParams instance
     */
    public XReadParams block(long block);
}

public class XReadGroupParams implements IParams {
    /**
     * Set read count limit
     * @param count Maximum entries per stream
     * @return XReadGroupParams instance
     */
    public XReadGroupParams count(int count);
    
    /**
     * Set blocking timeout
     * @param block Timeout in milliseconds
     * @return XReadGroupParams instance
     */
    public XReadGroupParams block(long block);
    
    /**
     * Don't acknowledge messages automatically
     * @return XReadGroupParams instance
     */
    public XReadGroupParams noAck();
}

// Add to stream with length limit and trimming
XAddParams addParams = new XAddParams()
    .maxLen(10000, true)  // Keep ~10K entries (approximate)
    .limit(100);          // Limit trimming operations

Map<String, String> fields = Map.of(
    "user_id", "123",
    "action", "login",
    "timestamp", String.valueOf(System.currentTimeMillis())
);

StreamEntryID entryId = jedis.xadd("events", addParams, fields);

// Read from streams with blocking
XReadParams readParams = new XReadParams()
    .count(10)
    .block(5000);  // Block up to 5 seconds

Map<String, StreamEntryID> streams = Map.of("events", StreamEntryID.LAST_ENTRY);
List<Map.Entry<String, List<StreamEntry>>> result = jedis.xread(readParams, streams);

// Consumer group reading
XReadGroupParams groupParams = new XReadGroupParams()
    .count(5)
    .block(1000)
    .noAck();

List<Map.Entry<String, List<StreamEntry>>> messages = 
    jedis.xreadGroup("processors", "consumer1", groupParams, streams);

public class LPosParams implements IParams {
    /**
     * Find nth occurrence
     * @param rank Occurrence rank (1-based, negative for reverse)
     * @return LPosParams instance
     */
    public LPosParams rank(int rank);
    
    /**
     * Return up to count positions
     * @param count Maximum positions to return
     * @return LPosParams instance
     */
    public LPosParams count(int count);
    
    /**
     * Limit search to maxlen elements
     * @param maxlen Maximum elements to examine
     * @return LPosParams instance
     */
    public LPosParams maxlen(int maxlen);
}

public class BitPosParams implements IParams {
    /**
     * Set start position in bytes
     * @param start Start byte position
     * @return BitPosParams instance
     */
    public BitPosParams start(long start);
    
    /**
     * Set end position in bytes
     * @param end End byte position
     * @return BitPosParams instance
     */
    public BitPosParams end(long end);
    
    /**
     * Use bit-level addressing instead of byte-level
     * @return BitPosParams instance
     */
    public BitPosParams bit();
    
    /**
     * Use byte-level addressing (default)
     * @return BitPosParams instance
     */
    public BitPosParams byteParam();
}

public class ClientKillParams implements IParams {
    /**
     * Kill client by address
     * @param address Client address (host:port)
     * @return ClientKillParams instance
     */
    public ClientKillParams addr(String address);
    
    /**
     * Kill client by ID
     * @param id Client ID
     * @return ClientKillParams instance
     */
    public ClientKillParams id(long id);
    
    /**
     * Kill clients of specific type
     * @param type Client type
     * @return ClientKillParams instance
     */
    public ClientKillParams type(ClientType type);
    
    /**
     * Kill clients from specific user
     * @param user Username
     * @return ClientKillParams instance
     */
    public ClientKillParams user(String user);
    
    /**
     * Skip calling client
     * @return ClientKillParams instance
     */
    public ClientKillParams skipMe();
}

public class RestoreParams implements IParams {
    /**
     * Replace existing key
     * @return RestoreParams instance
     */
    public RestoreParams replace();
    
    /**
     * Don't replace existing key
     * @return RestoreParams instance
     */
    public RestoreParams absTtl();
    
    /**
     * Set idle time
     * @param idleTime Idle time in seconds
     * @return RestoreParams instance
     */
    public RestoreParams idleTime(long idleTime);
    
    /**
     * Set frequency
     * @param frequency LFU frequency value
     * @return RestoreParams instance
     */
    public RestoreParams freq(int frequency);
}

// Find specific occurrences in list
LPosParams posParams = new LPosParams()
    .rank(2)      // Find 2nd occurrence
    .count(3)     // Return up to 3 positions
    .maxlen(1000); // Search only first 1000 elements

List<Long> positions = jedis.lpos("mylist", "search_value", posParams);

// Bit operations with precise control
BitPosParams bitParams = new BitPosParams()
    .start(10)    // Start from byte 10
    .end(50)      // End at byte 50
    .bit();       // Use bit-level addressing

Long bitPosition = jedis.bitpos("bitmap", true, bitParams);

// Kill specific client connections
ClientKillParams killParams = new ClientKillParams()
    .type(ClientType.NORMAL)
    .user("guest")
    .skipMe();

Long killedClients = jedis.clientKill(killParams);

public abstract class BaseSetExParams implements IParams {
    /**
     * Set expiration in seconds
     * @param seconds Expiration time
     * @return Parameter instance
     */
    protected abstract BaseSetExParams ex(long seconds);
    
    /**
     * Set expiration in milliseconds
     * @param milliseconds Expiration time
     * @return Parameter instance
     */
    protected abstract BaseSetExParams px(long milliseconds);
    
    /**
     * Set expiration at Unix timestamp
     * @param timestamp Unix timestamp in seconds
     * @return Parameter instance
     */
    protected abstract BaseSetExParams exAt(long timestamp);
    
    /**
     * Set expiration at Unix timestamp in milliseconds
     * @param timestamp Unix timestamp in milliseconds
     * @return Parameter instance
     */
    protected abstract BaseSetExParams pxAt(long timestamp);
}

public abstract class BaseGetExParams implements IParams {
    /**
     * Get with expiration in seconds
     * @param seconds Expiration time
     * @return Parameter instance
     */
    protected abstract BaseGetExParams ex(long seconds);
    
    /**
     * Get with expiration in milliseconds
     * @param milliseconds Expiration time
     * @return Parameter instance
     */
    protected abstract BaseGetExParams px(long milliseconds);
    
    /**
     * Get with expiration at timestamp
     * @param timestamp Unix timestamp
     * @return Parameter instance
     */
    protected abstract BaseGetExParams exAt(long timestamp);
    
    /**
     * Get with expiration at timestamp in milliseconds
     * @param timestamp Unix timestamp in milliseconds
     * @return Parameter instance
     */
    protected abstract BaseGetExParams pxAt(long timestamp);
    
    /**
     * Remove expiration (persist)
     * @return Parameter instance
     */
    protected abstract BaseGetExParams persist();
}

// Chain parameters for readable configuration
SetParams sessionParams = SetParams.setParams()
    .ex(1800)           // 30 minutes
    .nx()               // Only if not exists
    .get();             // Return previous value

String previousSession = jedis.set("session:" + userId, sessionData, sessionParams);

// Complex scan with multiple filters
ScanParams complexScan = ScanParams.scanParams()
    .match("user:*:profile")
    .type("hash")
    .count(500);

// Geospatial search with all options
GeoSearchParam fullGeoSearch = new GeoSearchParam()
    .fromLonLat(-122.4194, 37.7749)
    .byRadius(25, GeoUnit.KM)
    .withCoord()
    .withDist()
    .asc()
    .count(20);

List<GeoRadiusResponse> locations = jedis.geosearch("locations", fullGeoSearch);

public SetParams buildSetParams(boolean useExpiry, boolean onlyIfNotExists, 
                               boolean getOldValue) {
    SetParams params = SetParams.setParams();
    
    if (useExpiry) {
        params.ex(3600);  // 1 hour
    }
    
    if (onlyIfNotExists) {
        params.nx();
    }
    
    if (getOldValue) {
        params.get();
    }
    
    return params;
}

// Usage
SetParams dynamicParams = buildSetParams(true, false, true);
String oldValue = jedis.set("dynamic_key", "new_value", dynamicParams);

public class ParameterValidator {
    public static ZAddParams validateZAddParams(ZAddParams params, 
                                               boolean requireConditional) {
        if (requireConditional && params == null) {
            throw new IllegalArgumentException("ZAddParams required for conditional operations");
        }
        return params;
    }
    
    public static ScanParams validateScanCount(ScanParams params, int maxCount) {
        if (params != null) {
            // Ensure reasonable count limits
            return params.count(Math.min(maxCount, 1000));
        }
        return ScanParams.scanParams().count(100);
    }
}