Review & Rating

namespace ReviewRating.Ratings;

// ─── The contract for calculating aggregate ratings ──
// Any algorithm — simple average, weighted, Bayesian —       // Level 2
// implements this one method. The service doesn't care
// HOW the rating is calculated, only that it gets a
// number back between 1.0 and 5.0.
public interface IRatingStrategy
{
    string Name { get; }
    double Calculate(IReadOnlyList<IReview> reviews);
}

// ─── SimpleAverage ────────────────────────────────────
// Sum all ratings, divide by count. The most basic          // Level 2
// approach. Fair when you have thousands of reviews,
// but easily manipulated with a handful of fake ones.
public sealed class SimpleAverage : IRatingStrategy
{
    public string Name => "Simple Average";

    public double Calculate(IReadOnlyList<IReview> reviews)
    {
        if (reviews.Count == 0) return 0;
        return Math.Round(
            reviews.Average(r => r.Rating), 2);
    }
}

// ─── WeightedAverage ──────────────────────────────────
// Recent reviews matter more. A review from yesterday       // Level 2
// counts more than one from 2 years ago. Uses exponential
// decay: weight = e^(-lambda * daysAgo).
public sealed class WeightedAverage : IRatingStrategy
{
    private readonly double _decayLambda;
    private readonly ITimeProvider _timeProvider;              // Level 6

    public string Name => "Weighted Average (time-decay)";

    public WeightedAverage(ITimeProvider timeProvider,
        double decayLambda = 0.01)
    {
        _timeProvider = timeProvider;
        _decayLambda = decayLambda;
    }

    public double Calculate(IReadOnlyList<IReview> reviews)
    {
        if (reviews.Count == 0) return 0;

        var now = _timeProvider.UtcNow;                       // Level 6
        double weightedSum = 0, totalWeight = 0;

        foreach (var review in reviews)
        {
            var daysAgo = (now - review.CreatedAt).TotalDays;
            var weight = Math.Exp(-_decayLambda * daysAgo);
            weightedSum += review.Rating * weight;
            totalWeight += weight;
        }

        return totalWeight > 0
            ? Math.Round(weightedSum / totalWeight, 2)
            : 0;
    }
}

// ─── BayesianAverage ──────────────────────────────────
// Pulls toward the global average when review count is      // Level 2
// low. A product with 2 reviews at 5.0 stars shouldn't
// outrank one with 500 reviews at 4.7. The "confidence
// parameter" C controls how many reviews are needed
// before the product's own average dominates.
public sealed class BayesianAverage : IRatingStrategy
{
    private readonly double _globalAverage;
    private readonly int _confidenceParameter;                // Level 2

    public string Name => "Bayesian Average";

    public BayesianAverage(double globalAverage = 3.5,
        int confidenceParameter = 10)
    {
        _globalAverage = globalAverage;
        _confidenceParameter = confidenceParameter;
    }

    public double Calculate(IReadOnlyList<IReview> reviews)
    {
        if (reviews.Count == 0) return _globalAverage;

        var sum = reviews.Sum(r => r.Rating);
        // Bayesian formula: (C * globalAvg + sum) / (C + count)
        var result = (_confidenceParameter * _globalAverage + sum)
            / (_confidenceParameter + reviews.Count);
        return Math.Round(result, 2);
    }
}

namespace ReviewRating.Moderation;

// ─── The contract for a single moderation check ──────
// Each check examines the review and returns a result:      // Level 3
// pass, reject, or flag for human review. The pipeline
// runs them in sequence — any failure stops the chain.
public interface IModerationStrategy
{
    string Name { get; }
    ModerationResult Check(IReview review);
}

public record ModerationResult(
    bool Passed,
    string? Reason = null,
    ReviewStatus SuggestedStatus = ReviewStatus.Approved);

// ─── SpamDetector ─────────────────────────────────────
// Catches low-effort spam: too short, ALL CAPS,             // Level 3
// repeated characters ("aaaaaaa"), or suspicious URLs.
public sealed class SpamDetector : IModerationStrategy
{
    public string Name => "Spam Detector";

    public ModerationResult Check(IReview review)
    {
        if (string.IsNullOrWhiteSpace(review.Text))
            return new(false, "Review text is empty.",
                ReviewStatus.Rejected);

        if (review.Text.Length < 10)                          // Level 5
            return new(false, "Review too short (min 10 chars).",
                ReviewStatus.Rejected);

        // Check for ALL CAPS (more than 80% uppercase)
        var upperRatio = (double)review.Text.Count(char.IsUpper)
            / review.Text.Length;
        if (upperRatio > 0.8 && review.Text.Length > 20)
            return new(false, "Excessive capitalization detected.",
                ReviewStatus.Flagged);

        // Check for repeated characters
        if (HasRepeatedChars(review.Text, 5))
            return new(false, "Repeated character spam detected.",
                ReviewStatus.Rejected);

        return new(true);
    }

    private static bool HasRepeatedChars(string text, int threshold)
    {
        int count = 1;
        for (int i = 1; i < text.Length; i++)
        {
            count = text[i] == text[i - 1] ? count + 1 : 1;
            if (count >= threshold) return true;
        }
        return false;
    }
}

// ─── ProfanityFilter ──────────────────────────────────
// Checks review text against a blocklist of banned          // Level 3
// words. In production, this would use a proper NLP
// service — here we keep it simple with a word list.
public sealed class ProfanityFilter : IModerationStrategy
{
    private readonly HashSet<string> _blockedWords;

    public string Name => "Profanity Filter";

    public ProfanityFilter(IEnumerable<string>? blockedWords = null)
    {
        _blockedWords = new HashSet<string>(
            blockedWords ?? ["spam", "scam", "fake"],
            StringComparer.OrdinalIgnoreCase);
    }

    public ModerationResult Check(IReview review)
    {
        var words = review.Text.Split(' ',
            StringSplitOptions.RemoveEmptyEntries);

        var found = words.FirstOrDefault(w =>
            _blockedWords.Contains(w.Trim('.', ',', '!', '?')));

        return found is not null
            ? new(false, $"Blocked word detected: '{found}'.",
                ReviewStatus.Rejected)
            : new(true);
    }
}

// ─── PurchaseVerifier ─────────────────────────────────
// For product reviews, checks if the reviewer actually      // Level 3
// bought the product. Non-verified reviews are flagged
// rather than rejected — they're still allowed but
// carry less trust.
public sealed class PurchaseVerifier : IModerationStrategy
{
    public string Name => "Purchase Verifier";

    public ModerationResult Check(IReview review)
    {
        // Only applies to product reviews
        if (review is not ProductReview pr)
            return new(true);

        return pr.IsVerifiedPurchase
            ? new(true)
            : new(true, "Unverified purchase — review will be marked.",
                ReviewStatus.Approved);
    }
}

// ─── ModerationPipeline ───────────────────────────────
// Runs all moderation strategies in sequence.               // Level 3
// If ANY check fails, the review is rejected/flagged
// immediately — no need to run remaining checks.
// This is Strategy-as-Pipeline: same interface, chained.
public sealed class ModerationPipeline
{
    private readonly List<IModerationStrategy> _strategies = [];

    public ModerationPipeline(
        params IModerationStrategy[] strategies)
    {
        _strategies.AddRange(strategies);
    }

    public ModerationResult RunAll(IReview review)
    {
        foreach (var strategy in _strategies)
        {
            var result = strategy.Check(review);
            if (!result.Passed)
                return result;  // Short-circuit on first failure
        }
        return new ModerationResult(true);
    }

    public void AddStrategy(IModerationStrategy strategy)    // Level 5
    {
        ArgumentNullException.ThrowIfNull(strategy);
        _strategies.Add(strategy);
    }
}

namespace ReviewRating;

// ─── IReviewObserver ─────────────────────────────────
// Observers get notified when reviews are submitted,        // Level 4
// approved, or rejected. Each observer reacts in its
// own way without the service knowing what they do.
public interface IReviewObserver
{
    void OnReviewSubmitted(IReview review);
    void OnReviewApproved(IReview review);
    void OnReviewRejected(IReview review, string reason);
}

// ─── Observer Implementations ─────────────────────────
public sealed class SellerNotifier : IReviewObserver          // Level 4
{
    public void OnReviewSubmitted(IReview review) { }
    public void OnReviewApproved(IReview review) =>
        Console.WriteLine($"[Seller] New approved review: {review.Rating} stars");
    public void OnReviewRejected(IReview review, string reason) { }
}

public sealed class EmailNotifier : IReviewObserver           // Level 4
{
    public void OnReviewSubmitted(IReview review) =>
        Console.WriteLine($"[Email] Review received — pending moderation.");
    public void OnReviewApproved(IReview review) =>
        Console.WriteLine($"[Email] Your review was published!");
    public void OnReviewRejected(IReview review, string reason) =>
        Console.WriteLine($"[Email] Your review was rejected: {reason}");
}

public sealed class AnalyticsLogger : IReviewObserver         // Level 4
{
    public void OnReviewSubmitted(IReview review) =>
        Console.WriteLine($"[Analytics] review_submitted rating={review.Rating}");
    public void OnReviewApproved(IReview review) =>
        Console.WriteLine($"[Analytics] review_approved id={review.ReviewId}");
    public void OnReviewRejected(IReview review, string reason) =>
        Console.WriteLine($"[Analytics] review_rejected reason={reason}");
}

public sealed class AggregateUpdater : IReviewObserver        // Level 4
{
    private readonly IRatingStrategy _ratingStrategy;
    private readonly ConcurrentDictionary<string, double> _cache = new();

    public AggregateUpdater(IRatingStrategy ratingStrategy)
    {
        _ratingStrategy = ratingStrategy;
    }

    public void OnReviewApproved(IReview review)
    {
        // Recalculate aggregate would happen here            // Level 4
        Console.WriteLine($"[Aggregate] Rating cache updated for review {review.ReviewId}");
    }
    public void OnReviewSubmitted(IReview review) { }
    public void OnReviewRejected(IReview review, string reason) { }
}

// ─── RateLimiter ──────────────────────────────────────
// Prevents review bombing: max N reviews per user           // Level 5
// per time window. Uses a sliding window approach.
public sealed class RateLimiter
{
    private readonly ConcurrentDictionary<string, List<DateTimeOffset>>
        _submissions = new();
    private readonly int _maxPerWindow;
    private readonly TimeSpan _window;
    private readonly ITimeProvider _timeProvider;              // Level 6

    public RateLimiter(ITimeProvider timeProvider,
        int maxPerWindow = 5, int windowMinutes = 60)
    {
        _timeProvider = timeProvider;
        _maxPerWindow = maxPerWindow;
        _window = TimeSpan.FromMinutes(windowMinutes);
    }

    public ReviewResult<bool> CheckLimit(string userId)
    {
        var now = _timeProvider.UtcNow;
        var timestamps = _submissions.GetOrAdd(userId, _ => []);

        lock (timestamps)                                     // Level 5
        {
            // Remove expired entries
            timestamps.RemoveAll(t => now - t > _window);

            if (timestamps.Count >= _maxPerWindow)
                return ReviewResult<bool>.Fail(
                    $"Rate limit exceeded. Max {_maxPerWindow} reviews per {_window.TotalMinutes} minutes.");

            timestamps.Add(now);
            return ReviewResult<bool>.Ok(true);
        }
    }
}

// ─── ReviewService ────────────────────────────────────
// The orchestrator. Validates, moderates, stores,           // Level 0 (evolved)
// calculates ratings, and notifies observers.
public interface IModerationService                           // Level 6
{
    ModerationResult Moderate(IReview review);
}

public interface IRatingCalculator                            // Level 6
{
    double CalculateRating(IReadOnlyList<IReview> reviews);
}

public interface ITimeProvider                                 // Level 6
{
    DateTimeOffset UtcNow { get; }
}

public sealed class SystemTimeProvider : ITimeProvider         // Level 6
{
    public DateTimeOffset UtcNow => DateTimeOffset.UtcNow;
}

public sealed class ReviewService
{
    private readonly ConcurrentDictionary<string, List<IReview>>
        _reviewsByTarget = new();                              // Level 0
    private readonly List<IReviewObserver> _observers = [];   // Level 4
    private readonly IModerationService _moderationService;    // Level 6
    private readonly IRatingCalculator _ratingCalculator;      // Level 6
    private readonly RateLimiter _rateLimiter;                 // Level 5
    private readonly object _lock = new();                     // Level 5

    public ReviewService(
        IModerationService moderationService,
        IRatingCalculator ratingCalculator,
        RateLimiter rateLimiter)
    {
        _moderationService = moderationService;
        _ratingCalculator = ratingCalculator;
        _rateLimiter = rateLimiter;
    }

    // ─ Observer management ─                                // Level 4
    public void Subscribe(IReviewObserver observer) =>
        _observers.Add(observer);
    public void Unsubscribe(IReviewObserver observer) =>
        _observers.Remove(observer);

    // ─ Submit a review ─
    public ReviewResult<IReview> SubmitReview(IReview review)
    {
        // Step 1: Validate input                              // Level 5
        if (review.Rating < 1 || review.Rating > 5)
            return ReviewResult<IReview>.Fail(
                "Rating must be between 1 and 5.");

        if (string.IsNullOrWhiteSpace(review.Text))
            return ReviewResult<IReview>.Fail(
                "Review text is required.");

        // Step 2: Rate limiting                               // Level 5
        var rateCheck = _rateLimiter.CheckLimit(review.UserId);
        if (!rateCheck.IsSuccess)
            return ReviewResult<IReview>.Fail(rateCheck.Error!);

        // Step 3: Moderation pipeline                         // Level 3
        var modResult = _moderationService.Moderate(review);
        if (!modResult.Passed)
        {
            review.Status = modResult.SuggestedStatus;
            NotifyRejected(review, modResult.Reason ?? "Moderation failed");
            return ReviewResult<IReview>.Fail(
                $"Review rejected: {modResult.Reason}");
        }

        // Step 4: Store the review                            // Level 0
        lock (_lock)
        {
            var targetId = GetTargetId(review);
            var reviews = _reviewsByTarget.GetOrAdd(targetId, _ => []);

            // Check for duplicate                              // Level 5
            if (reviews.Any(r =>
                r.UserId == review.UserId &&
                r.Status == ReviewStatus.Approved))
                return ReviewResult<IReview>.Fail(
                    "You have already reviewed this item.");

            review.Status = ReviewStatus.Approved;
            reviews.Add(review);
        }

        // Step 5: Notify observers                            // Level 4
        NotifySubmitted(review);
        NotifyApproved(review);

        return ReviewResult<IReview>.Ok(review);
    }

    // ─ Get aggregate rating ─                                // Level 2
    public double GetRating(string targetId)
    {
        if (!_reviewsByTarget.TryGetValue(targetId, out var reviews))
            return 0;
        var approved = reviews
            .Where(r => r.Status == ReviewStatus.Approved)
            .ToList();
        return _ratingCalculator.CalculateRating(approved);
    }

    // ─ Get reviews with pagination ─                         // Level 7
    public IReadOnlyList<IReview> GetReviews(string targetId,
        int page = 1, int pageSize = 10)
    {
        if (!_reviewsByTarget.TryGetValue(targetId, out var reviews))
            return [];

        return reviews
            .Where(r => r.Status == ReviewStatus.Approved)
            .OrderByDescending(r => r.CreatedAt)
            .Skip((page - 1) * pageSize)
            .Take(pageSize)
            .ToList();
    }

    private static string GetTargetId(IReview review) => review switch
    {
        ProductReview pr => $"product:{pr.ProductId}",
        SellerReview sr => $"seller:{sr.SellerId}",
        DeliveryReview dr => $"delivery:{dr.OrderId}",
        _ => $"unknown:{review.ReviewId}"
    };

    private void NotifySubmitted(IReview review) =>
        _observers.ForEach(o => o.OnReviewSubmitted(review));
    private void NotifyApproved(IReview review) =>
        _observers.ForEach(o => o.OnReviewApproved(review));
    private void NotifyRejected(IReview review, string reason) =>
        _observers.ForEach(o => o.OnReviewRejected(review, reason));
}

using ReviewRating;
using ReviewRating.Models;
using ReviewRating.Ratings;
using ReviewRating.Moderation;

// ─── DI Wiring ────────────────────────────────────────

// Level 6: Adapter — wraps ModerationPipeline behind
// the IModerationService interface for DI
var timeProvider = new SystemTimeProvider();

var pipeline = new ModerationPipeline(
    new SpamDetector(),
    new ProfanityFilter(),
    new PurchaseVerifier());

// Level 6: Wrap pipeline in a service adapter
IModerationService moderationService = new ModerationServiceAdapter(pipeline);

// Level 2: Pick a rating strategy (swap via config)
IRatingStrategy ratingStrategy = new BayesianAverage(
    globalAverage: 3.5, confidenceParameter: 10);
IRatingCalculator ratingCalculator = new RatingCalculatorAdapter(ratingStrategy);

// Level 5: Rate limiter (5 reviews per hour per user)
var rateLimiter = new RateLimiter(timeProvider,
    maxPerWindow: 5, windowMinutes: 60);

// Level 0: Create the service
var service = new ReviewService(
    moderationService, ratingCalculator, rateLimiter);

// Level 4: Register observers
service.Subscribe(new SellerNotifier());
service.Subscribe(new EmailNotifier());
service.Subscribe(new AnalyticsLogger());
service.Subscribe(new AggregateUpdater(ratingStrategy));

// ─── Demo ─────────────────────────────────────────────
Console.WriteLine("=== Review & Rating System Demo ===\n");

// Submit a valid product review
var result1 = service.SubmitReview(new ProductReview
{
    UserId = "user-42",
    ProductId = "laptop-x1",
    Rating = 5,
    Text = "Absolutely love this laptop. Battery lasts all day!",
    IsVerifiedPurchase = true
});
Console.WriteLine($"Review 1: {(result1.IsSuccess ? "Accepted" : result1.Error)}\n");

// Submit a spam review (too short)
var result2 = service.SubmitReview(new ProductReview
{
    UserId = "spammer-99",
    ProductId = "laptop-x1",
    Rating = 1,
    Text = "bad",  // Too short — spam detector catches this
    IsVerifiedPurchase = false
});
Console.WriteLine($"Review 2: {(result2.IsSuccess ? "Accepted" : result2.Error)}\n");

// Submit a seller review
var result3 = service.SubmitReview(new SellerReview
{
    UserId = "user-55",
    SellerId = "seller-abc",
    Rating = 4,
    Text = "Good communication, fast shipping. Minor packaging issue.",
    CommunicationRating = 5
});
Console.WriteLine($"Review 3: {(result3.IsSuccess ? "Accepted" : result3.Error)}\n");

// Check aggregate rating
var rating = service.GetRating("product:laptop-x1");
Console.WriteLine($"Laptop X1 rating (Bayesian): {rating}/5.0");

// ─── Adapter classes (thin wrappers for DI) ───────────
public sealed class ModerationServiceAdapter : IModerationService
{
    private readonly ModerationPipeline _pipeline;
    public ModerationServiceAdapter(ModerationPipeline p) => _pipeline = p;
    public ModerationResult Moderate(IReview review) => _pipeline.RunAll(review);
}

public sealed class RatingCalculatorAdapter : IRatingCalculator
{
    private readonly IRatingStrategy _strategy;
    public RatingCalculatorAdapter(IRatingStrategy s) => _strategy = s;
    public double CalculateRating(IReadOnlyList<IReview> reviews) =>
        _strategy.Calculate(reviews);
}