using CommandLine;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using RedisManager.Utils;

namespace RedisManager.Commands
{
    /// <summary>
    /// Contains command line options and implementations for Redis sorted set operations.
    /// Provides functionality for ZADD, ZREM, ZRANGE, ZREVRANGE, ZRANGEBYSCORE, ZCARD, ZSCORE, ZRANK, ZREVRANK, ZINCRBY, ZREVRANGEBYSCORE, ZCOUNT, ZUNIONSTORE, ZINTERSTORE, ZSCAN, ZPOPMAX, ZPOPMIN, ZREMRANGEBYRANK, and ZREMRANGEBYSCORE commands.
    /// </summary>
    [Verb("zadd", HelpText = "Add members to a sorted set.")]
    public class ZAddOptions
    {
        [Option('i', "instance", Required = true, HelpText = "Instance name.")]
        public string Instance { get; set; }
        [Value(0, MetaName = "key", Required = true, HelpText = "Sorted set key.")]
        public string Key { get; set; }
        [Value(1, MetaName = "score", Required = true, HelpText = "Score for the member.")]
        public double Score { get; set; }
        [Value(2, MetaName = "member", Required = true, HelpText = "Member to add.")]
        public string Member { get; set; }
        [Option("table", Required = false, HelpText = "Output as table.")]
        public bool Table { get; set; }
    }

    [Verb("zrem", HelpText = "Remove members from a sorted set.")]
    public class ZRemOptions
    {
        [Option('i', "instance", Required = true, HelpText = "Instance name.")]
        public string Instance { get; set; }
        [Value(0, MetaName = "key", Required = true, HelpText = "Sorted set key.")]
        public string Key { get; set; }
        [Value(1, MetaName = "members", Min = 1, Required = true, HelpText = "Members to remove.")]
        public IEnumerable<string> Members { get; set; }
        [Option("table", Required = false, HelpText = "Output as table.")]
        public bool Table { get; set; }
    }

    [Verb("zrange", HelpText = "Get range of members by rank.")]
    public class ZRangeOptions
    {
        [Option('i', "instance", Required = true, HelpText = "Instance name.")]
        public string Instance { get; set; }
        [Value(0, MetaName = "key", Required = true, HelpText = "Sorted set key.")]
        public string Key { get; set; }
        [Value(1, MetaName = "start", Required = true, HelpText = "Start rank.")]
        public long Start { get; set; }
        [Value(2, MetaName = "stop", Required = true, HelpText = "Stop rank.")]
        public long Stop { get; set; }
        [Option("withscores", Required = false, HelpText = "Include scores in output.")]
        public bool WithScores { get; set; }
        [Option("table", Required = false, HelpText = "Output as table.")]
        public bool Table { get; set; }
    }

    [Verb("zrevrange", HelpText = "Get range of members by rank (reverse order).")]
    public class ZRevRangeOptions
    {
        [Option('i', "instance", Required = true, HelpText = "Instance name.")]
        public string Instance { get; set; }
        [Value(0, MetaName = "key", Required = true, HelpText = "Sorted set key.")]
        public string Key { get; set; }
        [Value(1, MetaName = "start", Required = true, HelpText = "Start rank.")]
        public long Start { get; set; }
        [Value(2, MetaName = "stop", Required = true, HelpText = "Stop rank.")]
        public long Stop { get; set; }
        [Option("withscores", Required = false, HelpText = "Include scores in output.")]
        public bool WithScores { get; set; }
        [Option("table", Required = false, HelpText = "Output as table.")]
        public bool Table { get; set; }
    }

    [Verb("zrangebyscore", HelpText = "Get range of members by score.")]
    public class ZRangeByScoreOptions
    {
        [Option('i', "instance", Required = true, HelpText = "Instance name.")]
        public string Instance { get; set; }
        [Value(0, MetaName = "key", Required = true, HelpText = "Sorted set key.")]
        public string Key { get; set; }
        [Value(1, MetaName = "min", Required = true, HelpText = "Minimum score.")]
        public double Min { get; set; }
        [Value(2, MetaName = "max", Required = true, HelpText = "Maximum score.")]
        public double Max { get; set; }
        [Option("withscores", Required = false, HelpText = "Include scores in output.")]
        public bool WithScores { get; set; }
        [Option("limit", Required = false, HelpText = "Limit results (offset count).")]
        public string Limit { get; set; }
        [Option("table", Required = false, HelpText = "Output as table.")]
        public bool Table { get; set; }
    }

    [Verb("zcard", HelpText = "Get the number of members in a sorted set.")]
    public class ZCardOptions
    {
        [Option('i', "instance", Required = true, HelpText = "Instance name.")]
        public string Instance { get; set; }
        [Value(0, MetaName = "key", Required = true, HelpText = "Sorted set key.")]
        public string Key { get; set; }
        [Option("table", Required = false, HelpText = "Output as table.")]
        public bool Table { get; set; }
    }

    [Verb("zscore", HelpText = "Get the score of a member.")]
    public class ZScoreOptions
    {
        [Option('i', "instance", Required = true, HelpText = "Instance name.")]
        public string Instance { get; set; }
        [Value(0, MetaName = "key", Required = true, HelpText = "Sorted set key.")]
        public string Key { get; set; }
        [Value(1, MetaName = "member", Required = true, HelpText = "Member name.")]
        public string Member { get; set; }
        [Option("table", Required = false, HelpText = "Output as table.")]
        public bool Table { get; set; }
    }

    [Verb("zrank", HelpText = "Get the rank of a member.")]
    public class ZRankOptions
    {
        [Option('i', "instance", Required = true, HelpText = "Instance name.")]
        public string Instance { get; set; }
        [Value(0, MetaName = "key", Required = true, HelpText = "Sorted set key.")]
        public string Key { get; set; }
        [Value(1, MetaName = "member", Required = true, HelpText = "Member name.")]
        public string Member { get; set; }
        [Option("table", Required = false, HelpText = "Output as table.")]
        public bool Table { get; set; }
    }

    [Verb("zrevrank", HelpText = "Get the reverse rank of a member.")]
    public class ZRevRankOptions
    {
        [Option('i', "instance", Required = true, HelpText = "Instance name.")]
        public string Instance { get; set; }
        [Value(0, MetaName = "key", Required = true, HelpText = "Sorted set key.")]
        public string Key { get; set; }
        [Value(1, MetaName = "member", Required = true, HelpText = "Member name.")]
        public string Member { get; set; }
        [Option("table", Required = false, HelpText = "Output as table.")]
        public bool Table { get; set; }
    }

    [Verb("zincrby", HelpText = "Increment the score of a member.")]
    public class ZIncrByOptions
    {
        [Option('i', "instance", Required = true, HelpText = "Instance name.")]
        public string Instance { get; set; }
        [Value(0, MetaName = "key", Required = true, HelpText = "Sorted set key.")]
        public string Key { get; set; }
        [Value(1, MetaName = "increment", Required = true, HelpText = "Score increment.")]
        public double Increment { get; set; }
        [Value(2, MetaName = "member", Required = true, HelpText = "Member name.")]
        public string Member { get; set; }
        [Option("table", Required = false, HelpText = "Output as table.")]
        public bool Table { get; set; }
    }

    [Verb("zrevrangebyscore", HelpText = "Get range of members by score (reverse order).")]
    public class ZRevRangeByScoreOptions
    {
        [Option('i', "instance", Required = true, HelpText = "Instance name.")]
        public string Instance { get; set; }
        [Value(0, MetaName = "key", Required = true, HelpText = "Sorted set key.")]
        public string Key { get; set; }
        [Value(1, MetaName = "max", Required = true, HelpText = "Maximum score.")]
        public double Max { get; set; }
        [Value(2, MetaName = "min", Required = true, HelpText = "Minimum score.")]
        public double Min { get; set; }
        [Option("withscores", Required = false, HelpText = "Include scores in output.")]
        public bool WithScores { get; set; }
        [Option("limit", Required = false, HelpText = "Limit results (offset count).")]
        public string Limit { get; set; }
        [Option("table", Required = false, HelpText = "Output as table.")]
        public bool Table { get; set; }
    }

    [Verb("zcount", HelpText = "Count members within a score range.")]
    public class ZCountOptions
    {
        [Option('i', "instance", Required = true, HelpText = "Instance name.")]
        public string Instance { get; set; }
        [Value(0, MetaName = "key", Required = true, HelpText = "Sorted set key.")]
        public string Key { get; set; }
        [Value(1, MetaName = "min", Required = true, HelpText = "Minimum score.")]
        public double Min { get; set; }
        [Value(2, MetaName = "max", Required = true, HelpText = "Maximum score.")]
        public double Max { get; set; }
        [Option("table", Required = false, HelpText = "Output as table.")]
        public bool Table { get; set; }
    }

    [Verb("zunionstore", HelpText = "Store union of multiple sorted sets.")]
    public class ZUnionStoreOptions
    {
        [Option('i', "instance", Required = true, HelpText = "Instance name.")]
        public string Instance { get; set; }
        [Value(0, MetaName = "destination", Required = true, HelpText = "Destination sorted set key.")]
        public string Destination { get; set; }
        [Value(1, MetaName = "numkeys", Required = true, HelpText = "Number of source keys.")]
        public int NumKeys { get; set; }
        [Value(2, MetaName = "keys", Min = 1, Required = true, HelpText = "Source sorted set keys.")]
        public IEnumerable<string> Keys { get; set; }
        [Option("weights", Required = false, HelpText = "Weights for each source set.")]
        public IEnumerable<double> Weights { get; set; }
        [Option("aggregate", Required = false, HelpText = "Aggregation method (sum, min, max).")]
        public string Aggregate { get; set; }
        [Option("table", Required = false, HelpText = "Output as table.")]
        public bool Table { get; set; }
    }

    [Verb("zinterstore", HelpText = "Store intersection of multiple sorted sets.")]
    public class ZInterStoreOptions
    {
        [Option('i', "instance", Required = true, HelpText = "Instance name.")]
        public string Instance { get; set; }
        [Value(0, MetaName = "destination", Required = true, HelpText = "Destination sorted set key.")]
        public string Destination { get; set; }
        [Value(1, MetaName = "numkeys", Required = true, HelpText = "Number of source keys.")]
        public int NumKeys { get; set; }
        [Value(2, MetaName = "keys", Min = 1, Required = true, HelpText = "Source sorted set keys.")]
        public IEnumerable<string> Keys { get; set; }
        [Option("weights", Required = false, HelpText = "Weights for each source set.")]
        public IEnumerable<double> Weights { get; set; }
        [Option("aggregate", Required = false, HelpText = "Aggregation method (sum, min, max).")]
        public string Aggregate { get; set; }
        [Option("table", Required = false, HelpText = "Output as table.")]
        public bool Table { get; set; }
    }

    [Verb("zscan", HelpText = "Scan sorted set members.")]
    public class ZScanOptions
    {
        [Option('i', "instance", Required = true, HelpText = "Instance name.")]
        public string Instance { get; set; }
        [Value(0, MetaName = "key", Required = true, HelpText = "Sorted set key.")]
        public string Key { get; set; }
        [Value(1, MetaName = "cursor", Required = true, HelpText = "Cursor position.")]
        public int Cursor { get; set; }
        [Option("match", Required = false, HelpText = "Pattern to match.")]
        public string Match { get; set; }
        [Option("count", Required = false, HelpText = "Count hint.")]
        public int? Count { get; set; }
        [Option("table", Required = false, HelpText = "Output as table.")]
        public bool Table { get; set; }
    }

    [Verb("zpopmax", HelpText = "Remove and return members with highest scores.")]
    public class ZPopMaxOptions
    {
        [Option('i', "instance", Required = true, HelpText = "Instance name.")]
        public string Instance { get; set; }
        [Value(0, MetaName = "key", Required = true, HelpText = "Sorted set key.")]
        public string Key { get; set; }
        [Option("count", Required = false, HelpText = "Number of members to pop.")]
        public int? Count { get; set; }
        [Option("table", Required = false, HelpText = "Output as table.")]
        public bool Table { get; set; }
    }

    [Verb("zpopmin", HelpText = "Remove and return members with lowest scores.")]
    public class ZPopMinOptions
    {
        [Option('i', "instance", Required = true, HelpText = "Instance name.")]
        public string Instance { get; set; }
        [Value(0, MetaName = "key", Required = true, HelpText = "Sorted set key.")]
        public string Key { get; set; }
        [Option("count", Required = false, HelpText = "Number of members to pop.")]
        public int? Count { get; set; }
        [Option("table", Required = false, HelpText = "Output as table.")]
        public bool Table { get; set; }
    }

    [Verb("zremrangebyrank", HelpText = "Remove members by rank range.")]
    public class ZRemRangeByRankOptions
    {
        [Option('i', "instance", Required = true, HelpText = "Instance name.")]
        public string Instance { get; set; }
        [Value(0, MetaName = "key", Required = true, HelpText = "Sorted set key.")]
        public string Key { get; set; }
        [Value(1, MetaName = "start", Required = true, HelpText = "Start rank.")]
        public long Start { get; set; }
        [Value(2, MetaName = "stop", Required = true, HelpText = "Stop rank.")]
        public long Stop { get; set; }
        [Option("table", Required = false, HelpText = "Output as table.")]
        public bool Table { get; set; }
    }

    [Verb("zremrangebyscore", HelpText = "Remove members by score range.")]
    public class ZRemRangeByScoreOptions
    {
        [Option('i', "instance", Required = true, HelpText = "Instance name.")]
        public string Instance { get; set; }
        [Value(0, MetaName = "key", Required = true, HelpText = "Sorted set key.")]
        public string Key { get; set; }
        [Value(1, MetaName = "min", Required = true, HelpText = "Minimum score.")]
        public double Min { get; set; }
        [Value(2, MetaName = "max", Required = true, HelpText = "Maximum score.")]
        public double Max { get; set; }
        [Option("table", Required = false, HelpText = "Output as table.")]
        public bool Table { get; set; }
    }

    public static class SortedSetCommands
    {
        /// <summary>
        /// Executes the ZADD command to add members to a sorted set.
        /// </summary>
        /// <param name="opts">The ZAddOptions containing instance, key, score, and member.</param>
        /// <param name="config">The RedisManager configuration.</param>
        /// <returns>Exit code (0 for success, non-zero for failure).</returns>
        public static int RunZAdd(ZAddOptions opts, Config config)
        {
            var instance = RedisUtils.GetInstance(config, opts.Instance);
            using var redis = RedisUtils.ConnectRedis(instance);
            var db = redis.GetDatabase();
            
            var count = db.SortedSetAdd(opts.Key, opts.Member, opts.Score);
            
            if (opts.Table)
            {
                RedisUtils.PrintTable(new[] { "Key", "Added Count" }, new List<string[]> { new[] { opts.Key, count.ToString() } });
            }
            else
                Console.WriteLine(Output.Green($"Added {count} new member(s)"));
            return 0;
        }

        /// <summary>
        /// Executes the ZREM command to remove members from a sorted set.
        /// </summary>
        /// <param name="opts">The ZRemOptions containing instance, key, and members.</param>
        /// <param name="config">The RedisManager configuration.</param>
        /// <returns>Exit code (0 for success, non-zero for failure).</returns>
        public static int RunZRem(ZRemOptions opts, Config config)
        {
            var instance = RedisUtils.GetInstance(config, opts.Instance);
            using var redis = RedisUtils.ConnectRedis(instance);
            var db = redis.GetDatabase();
            
            var members = opts.Members.ToArray();
            var count = db.SortedSetRemove(opts.Key, members.Select(m => (RedisValue)m).ToArray());
            
            if (opts.Table)
            {
                var rows = members.Select(m => new[] { m, "Removed" }).ToList();
                RedisUtils.PrintTable(new[] { "Member", "Status" }, rows);
                RedisUtils.PrintTable(new[] { "Key", "Removed Count" }, new List<string[]> { new[] { opts.Key, count.ToString() } });
            }
            else
                Console.WriteLine(Output.Green($"Removed {count} member(s)"));
            return 0;
        }

        /// <summary>
        /// Executes the ZRANGE command to get a range of members by rank.
        /// </summary>
        /// <param name="opts">The ZRangeOptions containing instance, key, start, and stop.</param>
        /// <param name="config">The RedisManager configuration.</param>
        /// <returns>Exit code (0 for success, non-zero for failure).</returns>
        public static int RunZRange(ZRangeOptions opts, Config config)
        {
            var instance = RedisUtils.GetInstance(config, opts.Instance);
            using var redis = RedisUtils.ConnectRedis(instance);
            var db = redis.GetDatabase();
            if (opts.WithScores)
            {
                var entries = db.SortedSetRangeByRankWithScores(opts.Key, opts.Start, opts.Stop, Order.Ascending);
                if (opts.Table)
                {
                    var rows = entries.Select(e => new string[] { e.Element.ToString(), e.Score.ToString() }).ToList();
                    RedisUtils.PrintTable(new[] { "Member", "Score" }, rows);
                }
                else
                {
                    foreach (var e in entries)
                        Console.WriteLine(Output.Green($"{e.Element} {e.Score}"));
                }
            }
            else
            {
                var members = db.SortedSetRangeByRank(opts.Key, opts.Start, opts.Stop, Order.Ascending);
                if (opts.Table)
                {
                    var rows = members.Select(m => new[] { m.ToString() }).ToList();
                    RedisUtils.PrintTable(new[] { "Member" }, rows);
                }
                else
                {
                    foreach (var member in members)
                        Console.WriteLine(Output.Green(member.ToString()));
                }
            }
            return 0;
        }

        /// <summary>
        /// Executes the ZREVRANGE command to get a range of members by rank in reverse order.
        /// </summary>
        /// <param name="opts">The ZRevRangeOptions containing instance, key, start, and stop.</param>
        /// <param name="config">The RedisManager configuration.</param>
        /// <returns>Exit code (0 for success, non-zero for failure).</returns>
        public static int RunZRevRange(ZRevRangeOptions opts, Config config)
        {
            var instance = RedisUtils.GetInstance(config, opts.Instance);
            using var redis = RedisUtils.ConnectRedis(instance);
            var db = redis.GetDatabase();
            if (opts.WithScores)
            {
                var entries = db.SortedSetRangeByRankWithScores(opts.Key, opts.Start, opts.Stop, Order.Descending);
                if (opts.Table)
                {
                    var rows = entries.Select(e => new string[] { e.Element.ToString(), e.Score.ToString() }).ToList();
                    RedisUtils.PrintTable(new[] { "Member", "Score" }, rows);
                }
                else
                {
                    foreach (var e in entries)
                        Console.WriteLine(Output.Green($"{e.Element} {e.Score}"));
                }
            }
            else
            {
                var members = db.SortedSetRangeByRank(opts.Key, opts.Start, opts.Stop, Order.Descending);
                if (opts.Table)
                {
                    var rows = members.Select(m => new[] { m.ToString() }).ToList();
                    RedisUtils.PrintTable(new[] { "Member" }, rows);
                }
                else
                {
                    foreach (var member in members)
                        Console.WriteLine(Output.Green(member.ToString()));
                }
            }
            return 0;
        }

        /// <summary>
        /// Executes the ZRANGEBYSCORE command to get a range of members by score.
        /// </summary>
        /// <param name="opts">The ZRangeByScoreOptions containing instance, key, min, and max.</param>
        /// <param name="config">The RedisManager configuration.</param>
        /// <returns>Exit code (0 for success, non-zero for failure).</returns>
        public static int RunZRangeByScore(ZRangeByScoreOptions opts, Config config)
        {
            var instance = RedisUtils.GetInstance(config, opts.Instance);
            using var redis = RedisUtils.ConnectRedis(instance);
            var db = redis.GetDatabase();
            if (opts.WithScores)
            {
                var entries = db.SortedSetRangeByScoreWithScores(opts.Key, opts.Min, opts.Max, Exclude.None, Order.Ascending);
                if (opts.Table)
                {
                    var rows = entries.Select(e => new string[] { e.Element.ToString(), e.Score.ToString() }).ToList();
                    RedisUtils.PrintTable(new[] { "Member", "Score" }, rows);
                }
                else
                {
                    foreach (var e in entries)
                        Console.WriteLine(Output.Green($"{e.Element} {e.Score}"));
                }
            }
            else
            {
                var members = db.SortedSetRangeByScore(opts.Key, opts.Min, opts.Max, Exclude.None, Order.Ascending);
                if (opts.Table)
                {
                    var rows = members.Select(m => new[] { m.ToString() }).ToList();
                    RedisUtils.PrintTable(new[] { "Member" }, rows);
                }
                else
                {
                    foreach (var member in members)
                        Console.WriteLine(Output.Green(member.ToString()));
                }
            }
            return 0;
        }

        /// <summary>
        /// Executes the ZCARD command to get the number of members in a sorted set.
        /// </summary>
        /// <param name="opts">The ZCardOptions containing instance and key.</param>
        /// <param name="config">The RedisManager configuration.</param>
        /// <returns>Exit code (0 for success, non-zero for failure).</returns>
        public static int RunZCard(ZCardOptions opts, Config config)
        {
            var instance = RedisUtils.GetInstance(config, opts.Instance);
            using var redis = RedisUtils.ConnectRedis(instance);
            var db = redis.GetDatabase();
            
            var count = db.SortedSetLength(opts.Key);
            
            if (opts.Table)
                RedisUtils.PrintTable(new[] { "Key", "Cardinality" }, new List<string[]> { new[] { opts.Key, count.ToString() } });
            else
                Console.WriteLine(Output.Green(count.ToString()));
            return 0;
        }

        /// <summary>
        /// Executes the ZSCORE command to get the score of a member in a sorted set.
        /// </summary>
        /// <param name="opts">The ZScoreOptions containing instance, key, and member.</param>
        /// <param name="config">The RedisManager configuration.</param>
        /// <returns>Exit code (0 for success, non-zero for failure).</returns>
        public static int RunZScore(ZScoreOptions opts, Config config)
        {
            var instance = RedisUtils.GetInstance(config, opts.Instance);
            using var redis = RedisUtils.ConnectRedis(instance);
            var db = redis.GetDatabase();
            
            var score = db.SortedSetScore(opts.Key, opts.Member);
            
            if (opts.Table)
                RedisUtils.PrintTable(new[] { "Key", "Member", "Score" }, new List<string[]> { new[] { opts.Key, opts.Member, score?.ToString() ?? "[null]" } });
            else if (score.HasValue)
                Console.WriteLine(Output.Green(score.Value.ToString()));
            else
                Console.WriteLine(Output.Yellow("[null]"));
            return 0;
        }

        /// <summary>
        /// Executes the ZRANK command to get the rank of a member in a sorted set.
        /// </summary>
        /// <param name="opts">The ZRankOptions containing instance, key, and member.</param>
        /// <param name="config">The RedisManager configuration.</param>
        /// <returns>Exit code (0 for success, non-zero for failure).</returns>
        public static int RunZRank(ZRankOptions opts, Config config)
        {
            var instance = RedisUtils.GetInstance(config, opts.Instance);
            using var redis = RedisUtils.ConnectRedis(instance);
            var db = redis.GetDatabase();
            
            var rank = db.SortedSetRank(opts.Key, opts.Member);
            
            if (opts.Table)
                RedisUtils.PrintTable(new[] { "Key", "Member", "Rank" }, new List<string[]> { new[] { opts.Key, opts.Member, rank?.ToString() ?? "[null]" } });
            else if (rank.HasValue)
                Console.WriteLine(Output.Green(rank.Value.ToString()));
            else
                Console.WriteLine(Output.Yellow("[null]"));
            return 0;
        }

        /// <summary>
        /// Executes the ZREVRANK command to get the reverse rank of a member in a sorted set.
        /// </summary>
        /// <param name="opts">The ZRevRankOptions containing instance, key, and member.</param>
        /// <param name="config">The RedisManager configuration.</param>
        /// <returns>Exit code (0 for success, non-zero for failure).</returns>
        public static int RunZRevRank(ZRevRankOptions opts, Config config)
        {
            var instance = RedisUtils.GetInstance(config, opts.Instance);
            using var redis = RedisUtils.ConnectRedis(instance);
            var db = redis.GetDatabase();
            
            var rank = db.SortedSetRank(opts.Key, opts.Member, Order.Descending);
            
            if (opts.Table)
                RedisUtils.PrintTable(new[] { "Key", "Member", "Reverse Rank" }, new List<string[]> { new[] { opts.Key, opts.Member, rank?.ToString() ?? "[null]" } });
            else if (rank.HasValue)
                Console.WriteLine(Output.Green(rank.Value.ToString()));
            else
                Console.WriteLine(Output.Yellow("[null]"));
            return 0;
        }

        /// <summary>
        /// Executes the ZINCRBY command to increment the score of a member in a sorted set.
        /// </summary>
        /// <param name="opts">The ZIncrByOptions containing instance, key, increment, and member.</param>
        /// <param name="config">The RedisManager configuration.</param>
        /// <returns>Exit code (0 for success, non-zero for failure).</returns>
        public static int RunZIncrBy(ZIncrByOptions opts, Config config)
        {
            var instance = RedisUtils.GetInstance(config, opts.Instance);
            using var redis = RedisUtils.ConnectRedis(instance);
            var db = redis.GetDatabase();
            
            var newScore = db.SortedSetIncrement(opts.Key, opts.Member, opts.Increment);
            
            if (opts.Table)
                RedisUtils.PrintTable(new[] { "Key", "Member", "New Score" }, new List<string[]> { new[] { opts.Key, opts.Member, newScore.ToString() } });
            else
                Console.WriteLine(Output.Green(newScore.ToString()));
            return 0;
        }

        /// <summary>
        /// Executes the ZREVRANGEBYSCORE command to get a range of members by score in reverse order.
        /// </summary>
        /// <param name="opts">The ZRevRangeByScoreOptions containing instance, key, max, and min.</param>
        /// <param name="config">The RedisManager configuration.</param>
        /// <returns>Exit code (0 for success, non-zero for failure).</returns>
        public static int RunZRevRangeByScore(ZRevRangeByScoreOptions opts, Config config)
        {
            var instance = RedisUtils.GetInstance(config, opts.Instance);
            using var redis = RedisUtils.ConnectRedis(instance);
            var db = redis.GetDatabase();
            
            if (opts.WithScores)
            {
                var entries = db.SortedSetRangeByScoreWithScores(opts.Key, opts.Min, opts.Max, Exclude.None, Order.Descending);
                if (opts.Table)
                {
                    var rows = entries.Select(e => new string[] { e.Element.ToString(), e.Score.ToString() }).ToList();
                    RedisUtils.PrintTable(new[] { "Member", "Score" }, rows);
                }
                else
                    foreach (var entry in entries)
                        Console.WriteLine(Output.Green($"{entry.Element}: {entry.Score}"));
            }
            else
            {
                var members = db.SortedSetRangeByScore(opts.Key, opts.Min, opts.Max, Exclude.None, Order.Descending);
                if (opts.Table)
                {
                    var rows = members.Select(m => new string[] { m.ToString() }).ToList();
                    RedisUtils.PrintTable(new[] { "Member" }, rows);
                }
                else
                    foreach (var member in members)
                        Console.WriteLine(Output.Green(member.ToString()));
            }
            return 0;
        }

        /// <summary>
        /// Executes the ZCOUNT command to count members within a score range in a sorted set.
        /// </summary>
        /// <param name="opts">The ZCountOptions containing instance, key, min, and max.</param>
        /// <param name="config">The RedisManager configuration.</param>
        /// <returns>Exit code (0 for success, non-zero for failure).</returns>
        public static int RunZCount(ZCountOptions opts, Config config)
        {
            var instance = RedisUtils.GetInstance(config, opts.Instance);
            using var redis = RedisUtils.ConnectRedis(instance);
            var db = redis.GetDatabase();
            
            var count = db.SortedSetLengthByValue(opts.Key, opts.Min, opts.Max);
            
            if (opts.Table)
                RedisUtils.PrintTable(new[] { "Key", "Count" }, new List<string[]> { new[] { opts.Key, count.ToString() } });
            else
                Console.WriteLine(Output.Green(count.ToString()));
            return 0;
        }

        /// <summary>
        /// Executes the ZUNIONSTORE command to store the union of multiple sorted sets.
        /// </summary>
        /// <param name="opts">The ZUnionStoreOptions containing instance, destination, numkeys, and keys.</param>
        /// <param name="config">The RedisManager configuration.</param>
        /// <returns>Exit code (0 for success, non-zero for failure).</returns>
        public static int RunZUnionStore(ZUnionStoreOptions opts, Config config)
        {
            var instance = RedisUtils.GetInstance(config, opts.Instance);
            using var redis = RedisUtils.ConnectRedis(instance);
            var db = redis.GetDatabase();
            
            var keys = opts.Keys.Select(k => (RedisKey)k).ToArray();
            var count = db.SortedSetCombineAndStore(SetOperation.Union, opts.Destination, keys);
            
            if (opts.Table)
                RedisUtils.PrintTable(new[] { "Destination", "Stored Count" }, new List<string[]> { new[] { opts.Destination, count.ToString() } });
            else
                Console.WriteLine(Output.Green($"Stored {count} member(s) in {opts.Destination}"));
            return 0;
        }

        /// <summary>
        /// Executes the ZINTERSTORE command to store the intersection of multiple sorted sets.
        /// </summary>
        /// <param name="opts">The ZInterStoreOptions containing instance, destination, numkeys, and keys.</param>
        /// <param name="config">The RedisManager configuration.</param>
        /// <returns>Exit code (0 for success, non-zero for failure).</returns>
        public static int RunZInterStore(ZInterStoreOptions opts, Config config)
        {
            var instance = RedisUtils.GetInstance(config, opts.Instance);
            using var redis = RedisUtils.ConnectRedis(instance);
            var db = redis.GetDatabase();
            
            var keys = opts.Keys.Select(k => (RedisKey)k).ToArray();
            var count = db.SortedSetCombineAndStore(SetOperation.Intersect, opts.Destination, keys);
            
            if (opts.Table)
                RedisUtils.PrintTable(new[] { "Destination", "Stored Count" }, new List<string[]> { new[] { opts.Destination, count.ToString() } });
            else
                Console.WriteLine(Output.Green($"Stored {count} member(s) in {opts.Destination}"));
            return 0;
        }

        /// <summary>
        /// Executes the ZSCAN command to scan sorted set members.
        /// </summary>
        /// <param name="opts">The ZScanOptions containing instance, key, cursor, and scan options.</param>
        /// <param name="config">The RedisManager configuration.</param>
        /// <returns>Exit code (0 for success, non-zero for failure).</returns>
        public static int RunZScan(ZScanOptions opts, Config config)
        {
            var instance = RedisUtils.GetInstance(config, opts.Instance);
            using var redis = RedisUtils.ConnectRedis(instance);
            var db = redis.GetDatabase();
            
            var result = db.SortedSetScan(opts.Key, opts.Match ?? "*", pageSize: opts.Count ?? 10, cursor: opts.Cursor);
            
            if (opts.Table)
            {
                var rows = result.Select(e => new[] { e.Element.ToString(), e.Score.ToString() }).ToList();
                RedisUtils.PrintTable(new[] { "Member", "Score" }, rows);
            }
            else
            {
                foreach (var entry in result)
                    Console.WriteLine(Output.Green($"{entry.Element}: {entry.Score}"));
            }
            return 0;
        }

        /// <summary>
        /// Executes the ZPOPMAX command to remove and return members with the highest scores.
        /// </summary>
        /// <param name="opts">The ZPopMaxOptions containing instance, key, and count.</param>
        /// <param name="config">The RedisManager configuration.</param>
        /// <returns>Exit code (0 for success, non-zero for failure).</returns>
        public static int RunZPopMax(ZPopMaxOptions opts, Config config)
        {
            var instance = RedisUtils.GetInstance(config, opts.Instance);
            using var redis = RedisUtils.ConnectRedis(instance);
            var db = redis.GetDatabase();
            
            if (opts.Count.HasValue)
            {
                var entries = db.SortedSetPop(opts.Key, opts.Count.Value);
                if (opts.Table)
                {
                    var rows = entries.Select(e => new string[] { e.Element.ToString(), e.Score.ToString() }).ToList();
                    RedisUtils.PrintTable(new[] { "Popped Member", "Score" }, rows);
                }
                else
                    foreach (var entry in entries)
                        Console.WriteLine(Output.Green($"{entry.Element}: {entry.Score}"));
            }
            else
            {
                var entry = db.SortedSetPop(opts.Key);
                if (opts.Table)
                    RedisUtils.PrintTable(new[] { "Popped Member", "Score" }, new List<string[]> { new[] { entry.Value.Element.ToString(), entry.Value.Score.ToString() } });
                else
                    Console.WriteLine(Output.Green($"{entry.Value.Element}: {entry.Value.Score}"));
            }
            return 0;
        }

        /// <summary>
        /// Executes the ZPOPMIN command to remove and return members with the lowest scores.
        /// </summary>
        /// <param name="opts">The ZPopMinOptions containing instance, key, and count.</param>
        /// <param name="config">The RedisManager configuration.</param>
        /// <returns>Exit code (0 for success, non-zero for failure).</returns>
        public static int RunZPopMin(ZPopMinOptions opts, Config config)
        {
            var instance = RedisUtils.GetInstance(config, opts.Instance);
            using var redis = RedisUtils.ConnectRedis(instance);
            var db = redis.GetDatabase();
            
            if (opts.Count.HasValue)
            {
                var entries = db.SortedSetPop(opts.Key, opts.Count.Value);
                if (opts.Table)
                {
                    var rows = entries.Select(e => new string[] { e.Element.ToString(), e.Score.ToString() }).ToList();
                    RedisUtils.PrintTable(new[] { "Popped Member", "Score" }, rows);
                }
                else
                    foreach (var entry in entries)
                        Console.WriteLine(Output.Green($"{entry.Element}: {entry.Score}"));
            }
            else
            {
                var entry = db.SortedSetPop(opts.Key);
                if (opts.Table)
                    RedisUtils.PrintTable(new[] { "Popped Member", "Score" }, new List<string[]> { new[] { entry.Value.Element.ToString(), entry.Value.Score.ToString() } });
                else
                    Console.WriteLine(Output.Green($"{entry.Value.Element}: {entry.Value.Score}"));
            }
            return 0;
        }

        /// <summary>
        /// Executes the ZREMRANGEBYRANK command to remove members by rank range.
        /// </summary>
        /// <param name="opts">The ZRemRangeByRankOptions containing instance, key, start, and stop.</param>
        /// <param name="config">The RedisManager configuration.</param>
        /// <returns>Exit code (0 for success, non-zero for failure).</returns>
        public static int RunZRemRangeByRank(ZRemRangeByRankOptions opts, Config config)
        {
            var instance = RedisUtils.GetInstance(config, opts.Instance);
            using var redis = RedisUtils.ConnectRedis(instance);
            var db = redis.GetDatabase();
            
            var count = db.SortedSetRemoveRangeByRank(opts.Key, opts.Start, opts.Stop);
            
            if (opts.Table)
                RedisUtils.PrintTable(new[] { "Key", "Removed Count" }, new List<string[]> { new[] { opts.Key, count.ToString() } });
            else
                Console.WriteLine(Output.Green($"Removed {count} member(s)"));
            return 0;
        }

        /// <summary>
        /// Executes the ZREMRANGEBYSCORE command to remove members by score range.
        /// </summary>
        /// <param name="opts">The ZRemRangeByScoreOptions containing instance, key, min, and max.</param>
        /// <param name="config">The RedisManager configuration.</param>
        /// <returns>Exit code (0 for success, non-zero for failure).</returns>
        public static int RunZRemRangeByScore(ZRemRangeByScoreOptions opts, Config config)
        {
            var instance = RedisUtils.GetInstance(config, opts.Instance);
            using var redis = RedisUtils.ConnectRedis(instance);
            var db = redis.GetDatabase();
            
            var count = db.SortedSetRemoveRangeByScore(opts.Key, opts.Min, opts.Max);
            
            if (opts.Table)
                RedisUtils.PrintTable(new[] { "Key", "Removed Count" }, new List<string[]> { new[] { opts.Key, count.ToString() } });
            else
                Console.WriteLine(Output.Green($"Removed {count} member(s)"));
            return 0;
        }
    }
}