using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Threading.Tasks;

using FastRng;
using FastRng.Distributions;

using NUnit.Framework;

namespace FastRngTests;

[ExcludeFromCodeCoverage]
public class GetIntTests
{
    #region Channel-Based
    
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    [Category(TestCategories.INT)]
    public void ChannelGetMax()
    {
        var random = new Random();
        var randomMax = random.Next();
        
        using var rng = new MultiChannelRng<float>();
        for(var n = 0; n < 10_000; n++)
        {
            var value = rng.GetUniformInt(randomMax);
            Assert.That(value, Is.GreaterThanOrEqualTo(0));
            Assert.That(value, Is.LessThanOrEqualTo(randomMax));
        }
    }
    
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    [Category(TestCategories.INT)]
    public void ChannelGetMaxDistributionCheck()
    {
        var random = new Random();
        var randomMax = random.Next(3, 33);
        var freqCheck = new IntFrequencyAnalysis(randomMax);
        using var rng = new MultiChannelRng<float>();
        
        for(var n = 0; n < 10_000; n++)
        {
            var value = rng.GetUniformInt(randomMax);
            freqCheck.CountThis(value);
            
            Assert.That(value, Is.GreaterThanOrEqualTo(0));
            Assert.That(value, Is.LessThanOrEqualTo(randomMax));
        }
        
        var distribution = freqCheck.NormalizeAndPlotEvents(TestContext.WriteLine);
        var max = distribution.Max();
        var min = distribution.Min();
        Assert.That(max - min, Is.LessThanOrEqualTo(0.27f));
    }
    
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    [Category(TestCategories.INT)]
    public void ChannelGetMinMax()
    {
        var random = new Random();
        var randomMin = random.Next();
        int randomMax;
        do
        {
            randomMax = random.Next();
        } while (randomMax < randomMin);
        
        using var rng = new MultiChannelRng<float>();
        for(var n = 0; n < 10_000; n++)
        {
            var value = rng.GetUniformInt(randomMin, randomMax);
            Assert.That(value, Is.GreaterThanOrEqualTo(randomMin));
            Assert.That(value, Is.LessThanOrEqualTo(randomMax));
        }
    }
    
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    [Category(TestCategories.INT)]
    public void ChannelGetMinMaxDistributionCheck()
    {
        var random = new Random();
        var randomMin = random.Next(0, 16);
        var randomMax = random.Next(randomMin + 10, 33);
        
        var freqCheck = new IntFrequencyAnalysis(randomMax - randomMin);
        using var rng = new MultiChannelRng<float>();
        
        for(var n = 0; n < 10_000; n++)
        {
            var value = rng.GetUniformInt(randomMin, randomMax);
            freqCheck.CountThis(value - randomMin);
            
            Assert.That(value, Is.GreaterThanOrEqualTo(randomMin));
            Assert.That(value, Is.LessThanOrEqualTo(randomMax));
        }
        
        var distribution = freqCheck.NormalizeAndPlotEvents(TestContext.WriteLine);
        var max = distribution.Max();
        var min = distribution.Min();
        Assert.That(max - min, Is.LessThanOrEqualTo(0.27f));
    }
    
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    [Category(TestCategories.INT)]
    public void ChannelCheckMinMax01()
    {
        var expectedMax = 3;

        var max = int.MinValue;
        var min = int.MaxValue;
        using var rng = new MultiChannelRng<float>();
        for(var n = 0; n < 10_000; n++)
        {
            var value = rng.GetUniformInt(expectedMax);
            if (value < min)
                min = value;
            
            if (value > max)
                max = value;
            
            Assert.That(value, Is.GreaterThanOrEqualTo(0));
            Assert.That(value, Is.LessThanOrEqualTo(expectedMax));
        }
        
        Assert.That(min, Is.EqualTo(0));
        Assert.That(max, Is.EqualTo(expectedMax - 1));
    }
    
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    [Category(TestCategories.INT)]
    public void ChannelCheckMinMax02()
    {
        var expectedMin = 2;
        var expectedMax = 6;

        var max = int.MinValue;
        var min = int.MaxValue;
        using var rng = new MultiChannelRng<float>();
        for(var n = 0; n < 10_000; n++)
        {
            var value = rng.GetUniformInt(expectedMin, expectedMax);
            if (value < min)
                min = value;
            
            if (value > max)
                max = value;
            
            Assert.That(value, Is.GreaterThanOrEqualTo(expectedMin));
            Assert.That(value, Is.LessThanOrEqualTo(expectedMax));
        }
        
        Assert.That(min, Is.EqualTo(expectedMin));
        Assert.That(max, Is.EqualTo(expectedMax - 1));
    }
    
    #endregion
    
    #region Multithreaded
    
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    [Category(TestCategories.INT)]
    public void MultithreadedGetMax()
    {
        var random = new Random();
        var randomMax = random.Next();
        
        using var rng = new MultiThreadedRng<float>();
        for(var n = 0; n < 10_000; n++)
        {
            var value = rng.GetUniformInt(randomMax);
            Assert.That(value, Is.GreaterThanOrEqualTo(0));
            Assert.That(value, Is.LessThanOrEqualTo(randomMax));
        }
    }
    
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    [Category(TestCategories.INT)]
    public void MultithreadedGetMaxDistributionCheck()
    {
        var random = new Random();
        var randomMax = random.Next(3, 33);
        var freqCheck = new IntFrequencyAnalysis(randomMax);
        using var rng = new MultiThreadedRng<float>();
        
        for(var n = 0; n < 10_000; n++)
        {
            var value = rng.GetUniformInt(randomMax);
            freqCheck.CountThis(value);
            
            Assert.That(value, Is.GreaterThanOrEqualTo(0));
            Assert.That(value, Is.LessThanOrEqualTo(randomMax));
        }
        
        var distribution = freqCheck.NormalizeAndPlotEvents(TestContext.WriteLine);
        var max = distribution.Max();
        var min = distribution.Min();
        Assert.That(max - min, Is.LessThanOrEqualTo(0.27f));
    }
    
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    [Category(TestCategories.INT)]
    public void MultithreadedGetMinMax()
    {
        var random = new Random();
        var randomMin = random.Next();
        int randomMax;
        do
        {
            randomMax = random.Next();
        } while (randomMax < randomMin);
        
        using var rng = new MultiThreadedRng<float>();
        for(var n = 0; n < 10_000; n++)
        {
            var value = rng.GetUniformInt(randomMin, randomMax);
            Assert.That(value, Is.GreaterThanOrEqualTo(randomMin));
            Assert.That(value, Is.LessThanOrEqualTo(randomMax));
        }
    }
    
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    [Category(TestCategories.INT)]
    public void MultithreadedGetMinMaxDistributionCheck()
    {
        var random = new Random();
        var randomMin = random.Next(0, 16);
        var randomMax = random.Next(randomMin + 10, 33);
        
        var freqCheck = new IntFrequencyAnalysis(randomMax - randomMin);
        using var rng = new MultiThreadedRng<float>();
        
        for(var n = 0; n < 10_000; n++)
        {
            var value = rng.GetUniformInt(randomMin, randomMax);
            freqCheck.CountThis(value - randomMin);
            
            Assert.That(value, Is.GreaterThanOrEqualTo(randomMin));
            Assert.That(value, Is.LessThanOrEqualTo(randomMax));
        }
        
        var distribution = freqCheck.NormalizeAndPlotEvents(TestContext.WriteLine);
        var max = distribution.Max();
        var min = distribution.Min();
        Assert.That(max - min, Is.LessThanOrEqualTo(0.27f));
    }
    
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    [Category(TestCategories.INT)]
    public void MultithreadedCheckMinMax01()
    {
        var expectedMax = 3;

        var max = int.MinValue;
        var min = int.MaxValue;
        using var rng = new MultiThreadedRng<float>();
        for(var n = 0; n < 10_000; n++)
        {
            var value = rng.GetUniformInt(expectedMax);
            if (value < min)
                min = value;
            
            if (value > max)
                max = value;
            
            Assert.That(value, Is.GreaterThanOrEqualTo(0));
            Assert.That(value, Is.LessThanOrEqualTo(expectedMax));
        }
        
        Assert.That(min, Is.EqualTo(0));
        Assert.That(max, Is.EqualTo(expectedMax - 1));
    }
    
    [Test]
    [Category(TestCategories.COVER)]
    [Category(TestCategories.NORMAL)]
    [Category(TestCategories.INT)]
    public void MultithreadedCheckMinMax02()
    {
        var expectedMin = 2;
        var expectedMax = 6;

        var max = int.MinValue;
        var min = int.MaxValue;
        using var rng = new MultiThreadedRng<float>();
        for(var n = 0; n < 10_000; n++)
        {
            var value = rng.GetUniformInt(expectedMin, expectedMax);
            if (value < min)
                min = value;
            
            if (value > max)
                max = value;
            
            Assert.That(value, Is.GreaterThanOrEqualTo(expectedMin));
            Assert.That(value, Is.LessThanOrEqualTo(expectedMax));
        }
        
        Assert.That(min, Is.EqualTo(expectedMin));
        Assert.That(max, Is.EqualTo(expectedMax - 1));
    }
    
    #endregion
}