// <copyright file="MetricViewTests.cs" company="OpenTelemetry Authors">
// Copyright The OpenTelemetry Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// </copyright>

using System.Diagnostics.Metrics;
using OpenTelemetry.Internal;
using OpenTelemetry.Tests;
using Xunit;

namespace OpenTelemetry.Metrics.Tests
{
    public class MetricViewTests : MetricTestsBase
    {
        private const int MaxTimeToAllowForFlush = 10000;

        [Fact]
        public void ViewToRenameMetric()
        {
            using var meter = new Meter(Utils.GetCurrentMethodName());
            var exportedItems = new List<Metric>();
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView("name1", "renamed")
                .AddInMemoryExporter(exportedItems)
                .Build();

            // Expecting one metric stream.
            var counterLong = meter.CreateCounter<long>("name1");
            counterLong.Add(10);
            meterProvider.ForceFlush(MaxTimeToAllowForFlush);
            Assert.Single(exportedItems);
            var metric = exportedItems[0];
            Assert.Equal("renamed", metric.Name);
        }

        [Theory]
        [MemberData(nameof(MetricTestData.InvalidInstrumentNames), MemberType = typeof(MetricTestData))]
        public void AddViewWithInvalidNameThrowsArgumentException(string viewNewName)
        {
            var exportedItems = new List<Metric>();

            using var meter1 = new Meter("AddViewWithInvalidNameThrowsArgumentException");

            var ex = Assert.Throws<ArgumentException>(() => Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter1.Name)
                .AddView("name1", viewNewName)
                .AddInMemoryExporter(exportedItems)
                .Build());

            Assert.Contains($"Custom view name {viewNewName} is invalid.", ex.Message);

            ex = Assert.Throws<ArgumentException>(() => Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter1.Name)
                .AddView("name1", new MetricStreamConfiguration() { Name = viewNewName })
                .AddInMemoryExporter(exportedItems)
                .Build());

            Assert.Contains($"Custom view name {viewNewName} is invalid.", ex.Message);
        }

        [Fact]
        public void AddViewWithNullMetricStreamConfigurationThrowsArgumentnullException()
        {
            var exportedItems = new List<Metric>();

            using var meter1 = new Meter("AddViewWithInvalidNameThrowsArgumentException");

            Assert.Throws<ArgumentNullException>(() => Sdk.CreateMeterProviderBuilder()
               .AddMeter(meter1.Name)
               .AddView("name1", (MetricStreamConfiguration)null)
               .AddInMemoryExporter(exportedItems)
               .Build());
        }

        [Fact]
        public void AddViewWithNameThrowsInvalidArgumentExceptionWhenConflict()
        {
            var exportedItems = new List<Metric>();

            using var meter1 = new Meter("AddViewWithGuaranteedConflictThrowsInvalidArgumentException");

            Assert.Throws<ArgumentException>(() => Sdk.CreateMeterProviderBuilder()
               .AddMeter(meter1.Name)
               .AddView("instrumenta.*", name: "newname")
               .AddInMemoryExporter(exportedItems)
               .Build());
        }

        [Fact]
        public void AddViewWithNameInMetricStreamConfigurationThrowsInvalidArgumentExceptionWhenConflict()
        {
            var exportedItems = new List<Metric>();

            using var meter1 = new Meter("AddViewWithGuaranteedConflictThrowsInvalidArgumentException");

            Assert.Throws<ArgumentException>(() => Sdk.CreateMeterProviderBuilder()
               .AddMeter(meter1.Name)
               .AddView("instrumenta.*", new MetricStreamConfiguration() { Name = "newname" })
               .AddInMemoryExporter(exportedItems)
               .Build());
        }

        [Fact]
        public void AddViewWithExceptionInUserCallbackAppliedDefault()
        {
            var exportedItems = new List<Metric>();

            using var meter1 = new Meter("AddViewWithExceptionInUserCallback");
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
               .AddMeter(meter1.Name)
               .AddView((instrument) => { throw new Exception("bad"); })
               .AddInMemoryExporter(exportedItems)
               .Build();

            using (var inMemoryEventListener = new InMemoryEventListener(OpenTelemetrySdkEventSource.Log))
            {
                var counter1 = meter1.CreateCounter<long>("counter1");
                counter1.Add(1);
                Assert.Single(inMemoryEventListener.Events.Where((e) => e.EventId == 41));
            }

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);

            // Counter is still reported with default config
            // even if View is ignored due to View exception.
            Assert.Single(exportedItems);
        }

        [Fact]
        public void AddViewWithExceptionInUserCallbackNoDefault()
        {
            var exportedItems = new List<Metric>();

            using var meter1 = new Meter("AddViewWithExceptionInUserCallback");
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
               .AddMeter(meter1.Name)
               .AddView((instrument) => { throw new Exception("bad"); })
               .AddView("*", MetricStreamConfiguration.Drop)
               .AddInMemoryExporter(exportedItems)
               .Build();

            using (var inMemoryEventListener = new InMemoryEventListener(OpenTelemetrySdkEventSource.Log))
            {
                var counter1 = meter1.CreateCounter<long>("counter1");
                counter1.Add(1);
                Assert.Single(inMemoryEventListener.Events.Where((e) => e.EventId == 41));
            }

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);

            // Counter is not reported.
            // as the View is ignored due to View exception.
            // and Default is suppressed with * -> Drop
            Assert.Empty(exportedItems);
        }

        [Fact]
        public void AddViewsWithAndWithoutExceptionInUserCallback()
        {
            var exportedItems = new List<Metric>();

            using var meter1 = new Meter("AddViewWithExceptionInUserCallback");
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
               .AddMeter(meter1.Name)
               .AddView((instrument) => { throw new Exception("bad"); })
               .AddView((instrument) => { return new MetricStreamConfiguration() { Name = "newname" }; })
               .AddInMemoryExporter(exportedItems)
               .Build();

            using (var inMemoryEventListener = new InMemoryEventListener(OpenTelemetrySdkEventSource.Log))
            {
                var counter1 = meter1.CreateCounter<long>("counter1");
                counter1.Add(1);
                Assert.Single(inMemoryEventListener.Events.Where((e) => e.EventId == 41));
            }

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);

            // Counter is still reported with 2nd View
            // even if 1st View is ignored due to View exception.
            Assert.Single(exportedItems);
            Assert.Equal("newname", exportedItems[0].Name);
        }

        [Theory]
        [MemberData(nameof(MetricTestData.InvalidHistogramBoundaries), MemberType = typeof(MetricTestData))]
        public void AddViewWithInvalidHistogramBoundsThrowsArgumentException(double[] boundaries)
        {
            var ex = Assert.Throws<ArgumentException>(() => Sdk.CreateMeterProviderBuilder()
                .AddView("name1", new ExplicitBucketHistogramConfiguration { Boundaries = boundaries }));

            Assert.Contains("Histogram boundaries must be in ascending order with distinct values", ex.Message);
        }

        [Theory]
        [MemberData(nameof(MetricTestData.InvalidHistogramBoundaries), MemberType = typeof(MetricTestData))]
        public void AddViewWithInvalidHistogramBoundsIgnored(double[] boundaries)
        {
            var exportedItems = new List<Metric>();

            using var meter1 = new Meter("AddViewWithInvalidHistogramBoundsIgnored");

            var counter1 = meter1.CreateCounter<long>("counter1");

            using (var provider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter1.Name)
                .AddView((instrument) =>
                {
                    return instrument.Name == counter1.Name
                        ? new ExplicitBucketHistogramConfiguration() { Boundaries = boundaries }
                        : null;
                })
                .AddInMemoryExporter(exportedItems)
                .Build())
            {
                counter1.Add(1);
            }

            // Counter is aggregated with default configuration
            // as the View config is ignored due to invalid histogram bounds.
            Assert.Single(exportedItems);
        }

        [Theory]
        [MemberData(nameof(MetricTestData.ValidInstrumentNames), MemberType = typeof(MetricTestData))]
        public void ViewWithValidNameExported(string viewNewName)
        {
            var exportedItems = new List<Metric>();

            using var meter1 = new Meter("ViewWithInvalidNameIgnoredTest");
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter1.Name)
                .AddView("name1", viewNewName)
                .AddInMemoryExporter(exportedItems)
                .Build();

            var counterLong = meter1.CreateCounter<long>("name1");
            counterLong.Add(10);
            meterProvider.ForceFlush(MaxTimeToAllowForFlush);

            // Expecting one metric stream.
            Assert.Single(exportedItems);
            var metric = exportedItems[0];
            Assert.Equal(viewNewName, metric.Name);
        }

        [Fact]
        public void ViewToRenameMetricConditionally()
        {
            using var meter1 = new Meter($"{Utils.GetCurrentMethodName()}.1");
            using var meter2 = new Meter($"{Utils.GetCurrentMethodName()}.2");

            var exportedItems = new List<Metric>();

            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter1.Name)
                .AddMeter(meter2.Name)
                .AddView((instrument) =>
                {
                    if (instrument.Meter.Name.Equals(meter2.Name, StringComparison.OrdinalIgnoreCase)
                        && instrument.Name.Equals("name1", StringComparison.OrdinalIgnoreCase))
                    {
                        return new MetricStreamConfiguration() { Name = "name1_Renamed", Description = "new description" };
                    }
                    else
                    {
                        return null;
                    }
                })
                .AddInMemoryExporter(exportedItems)
                .Build();

            // Without views only 1 stream would be
            // exported (the 2nd one gets dropped due to
            // name conflict). Due to renaming with Views,
            // we expect 2 metric streams here.
            var counter1 = meter1.CreateCounter<long>("name1", "unit", "original_description");
            var counter2 = meter2.CreateCounter<long>("name1", "unit", "original_description");
            counter1.Add(10);
            counter2.Add(10);
            meterProvider.ForceFlush(MaxTimeToAllowForFlush);
            Assert.Equal(2, exportedItems.Count);
            Assert.Equal("name1", exportedItems[0].Name);
            Assert.Equal("name1_Renamed", exportedItems[1].Name);
            Assert.Equal("original_description", exportedItems[0].Description);
            Assert.Equal("new description", exportedItems[1].Description);
        }

        [Theory]
        [MemberData(nameof(MetricTestData.InvalidInstrumentNames), MemberType = typeof(MetricTestData))]
        public void ViewWithInvalidNameIgnoredConditionally(string viewNewName)
        {
            using var meter1 = new Meter("ViewToRenameMetricConditionallyTest");
            var exportedItems = new List<Metric>();
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter1.Name)

                // since here it's a func, we can't validate the name right away
                // so the view is allowed to be added, but upon instrument creation it's going to be ignored.
                .AddView((instrument) =>
                {
                    if (instrument.Meter.Name.Equals(meter1.Name, StringComparison.OrdinalIgnoreCase)
                        && instrument.Name.Equals("name1", StringComparison.OrdinalIgnoreCase))
                    {
                        // invalid instrument name as per the spec
                        return new MetricStreamConfiguration() { Name = viewNewName, Description = "new description" };
                    }
                    else
                    {
                        return null;
                    }
                })
                .AddInMemoryExporter(exportedItems)
                .Build();

            // Because the MetricStreamName passed is invalid, the view is ignored,
            // and default aggregation is used.
            var counter1 = meter1.CreateCounter<long>("name1", "unit", "original_description");
            counter1.Add(10);

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);

            Assert.Single(exportedItems);
        }

        [Theory]
        [MemberData(nameof(MetricTestData.ValidInstrumentNames), MemberType = typeof(MetricTestData))]
        public void ViewWithValidNameConditionally(string viewNewName)
        {
            using var meter1 = new Meter("ViewToRenameMetricConditionallyTest");
            var exportedItems = new List<Metric>();
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter1.Name)
                .AddView((instrument) =>
                {
                    if (instrument.Meter.Name.Equals(meter1.Name, StringComparison.OrdinalIgnoreCase)
                        && instrument.Name.Equals("name1", StringComparison.OrdinalIgnoreCase))
                    {
                        // invalid instrument name as per the spec
                        return new MetricStreamConfiguration() { Name = viewNewName, Description = "new description" };
                    }
                    else
                    {
                        return null;
                    }
                })
                .AddInMemoryExporter(exportedItems)
                .Build();

            // Expecting one metric stream.
            var counter1 = meter1.CreateCounter<long>("name1", "unit", "original_description");
            counter1.Add(10);

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);

            // Expecting one metric stream.
            Assert.Single(exportedItems);
            var metric = exportedItems[0];
            Assert.Equal(viewNewName, metric.Name);
        }

        [Fact]
        public void ViewWithNullCustomNameTakesInstrumentName()
        {
            var exportedItems = new List<Metric>();

            using var meter = new Meter("ViewToRenameMetricConditionallyTest");

            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView((instrument) =>
                {
                    if (instrument.Name.Equals("name1", StringComparison.OrdinalIgnoreCase))
                    {
                        // null View name
                        return new MetricStreamConfiguration() { };
                    }
                    else
                    {
                        return null;
                    }
                })
                .AddInMemoryExporter(exportedItems)
                .Build();

            // Expecting one metric stream.
            // Since the View name was null, the instrument name was used instead
            var counter1 = meter.CreateCounter<long>("name1", "unit", "original_description");
            counter1.Add(10);

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);

            // Expecting one metric stream.
            Assert.Single(exportedItems);
            var metric = exportedItems[0];
            Assert.Equal(counter1.Name, metric.Name);
        }

        [Fact]
        public void ViewToProduceMultipleStreamsFromInstrument()
        {
            using var meter = new Meter(Utils.GetCurrentMethodName());
            var exportedItems = new List<Metric>();
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView("name1", "renamedStream1")
                .AddView("name1", "renamedStream2")
                .AddInMemoryExporter(exportedItems)
                .Build();

            // Expecting two metric stream.
            var counterLong = meter.CreateCounter<long>("name1");
            counterLong.Add(10);
            meterProvider.ForceFlush(MaxTimeToAllowForFlush);
            Assert.Equal(2, exportedItems.Count);
            Assert.Equal("renamedStream1", exportedItems[0].Name);
            Assert.Equal("renamedStream2", exportedItems[1].Name);
        }

        [Fact]
        public void ViewToProduceMultipleStreamsWithDuplicatesFromInstrument()
        {
            using var meter = new Meter(Utils.GetCurrentMethodName());
            var exportedItems = new List<Metric>();
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView("name1", "renamedStream1")
                .AddView("name1", "renamedStream2")
                .AddView("name1", "renamedStream2")
                .AddInMemoryExporter(exportedItems)
                .Build();

            // Expecting three metric stream.
            // the second .AddView("name1", "renamedStream2")
            // produces a conflicting metric stream.
            var counterLong = meter.CreateCounter<long>("name1");
            counterLong.Add(10);
            meterProvider.ForceFlush(MaxTimeToAllowForFlush);
            Assert.Equal(3, exportedItems.Count);
            Assert.Equal("renamedStream1", exportedItems[0].Name);
            Assert.Equal("renamedStream2", exportedItems[1].Name);
            Assert.Equal("renamedStream2", exportedItems[2].Name);
        }

        [Fact]
        public void ViewWithHistogramConfigurationIgnoredWhenAppliedToNonHistogram()
        {
            using var meter = new Meter(Utils.GetCurrentMethodName());
            var exportedItems = new List<Metric>();
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView("NotAHistogram", new ExplicitBucketHistogramConfiguration() { Name = "ImAHistogram" })
                .AddInMemoryExporter(exportedItems)
                .Build();

            var counter = meter.CreateCounter<long>("NotAHistogram");
            counter.Add(10);
            meterProvider.ForceFlush(MaxTimeToAllowForFlush);

            Assert.Single(exportedItems);
            var metric = exportedItems[0];

            Assert.Equal("NotAHistogram", metric.Name);

            List<MetricPoint> metricPoints = new List<MetricPoint>();
            foreach (ref readonly var mp in metric.GetMetricPoints())
            {
                metricPoints.Add(mp);
            }

            Assert.Single(metricPoints);
            var metricPoint = metricPoints[0];
            Assert.Equal(10, metricPoint.GetSumLong());
        }

        [Fact]
        public void ViewToProduceCustomHistogramBound()
        {
            using var meter = new Meter(Utils.GetCurrentMethodName());
            var exportedItems = new List<Metric>();
            var boundaries = new double[] { 10, 20 };
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView("MyHistogram", new ExplicitBucketHistogramConfiguration() { Name = "MyHistogramDefaultBound" })
                .AddView("MyHistogram", new ExplicitBucketHistogramConfiguration() { Boundaries = boundaries })
                .AddInMemoryExporter(exportedItems)
                .Build();

            var histogram = meter.CreateHistogram<long>("MyHistogram");
            histogram.Record(-10);
            histogram.Record(0);
            histogram.Record(1);
            histogram.Record(9);
            histogram.Record(10);
            histogram.Record(11);
            histogram.Record(19);
            meterProvider.ForceFlush(MaxTimeToAllowForFlush);
            Assert.Equal(2, exportedItems.Count);
            var metricDefault = exportedItems[0];
            var metricCustom = exportedItems[1];

            Assert.Equal("MyHistogramDefaultBound", metricDefault.Name);
            Assert.Equal("MyHistogram", metricCustom.Name);

            List<MetricPoint> metricPointsDefault = new List<MetricPoint>();
            foreach (ref readonly var mp in metricDefault.GetMetricPoints())
            {
                metricPointsDefault.Add(mp);
            }

            Assert.Single(metricPointsDefault);
            var histogramPoint = metricPointsDefault[0];

            var count = histogramPoint.GetHistogramCount();
            var sum = histogramPoint.GetHistogramSum();

            Assert.Equal(40, sum);
            Assert.Equal(7, count);

            int index = 0;
            int actualCount = 0;
            var expectedBucketCounts = new long[] { 2, 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
            foreach (var histogramMeasurement in histogramPoint.GetHistogramBuckets())
            {
                Assert.Equal(expectedBucketCounts[index], histogramMeasurement.BucketCount);
                index++;
                actualCount++;
            }

            Assert.Equal(Metric.DefaultHistogramBounds.Length + 1, actualCount);

            List<MetricPoint> metricPointsCustom = new List<MetricPoint>();
            foreach (ref readonly var mp in metricCustom.GetMetricPoints())
            {
                metricPointsCustom.Add(mp);
            }

            Assert.Single(metricPointsCustom);
            histogramPoint = metricPointsCustom[0];

            count = histogramPoint.GetHistogramCount();
            sum = histogramPoint.GetHistogramSum();

            Assert.Equal(40, sum);
            Assert.Equal(7, count);

            index = 0;
            actualCount = 0;
            expectedBucketCounts = new long[] { 5, 2, 0 };
            foreach (var histogramMeasurement in histogramPoint.GetHistogramBuckets())
            {
                Assert.Equal(expectedBucketCounts[index], histogramMeasurement.BucketCount);
                index++;
                actualCount++;
            }

            Assert.Equal(boundaries.Length + 1, actualCount);
        }

        [Theory]
        [MemberData(nameof(MetricTestData.ValidHistogramMinMax), MemberType = typeof(MetricTestData))]
        public void HistogramMinMax(double[] values, HistogramConfiguration histogramConfiguration, double expectedMin, double expectedMax)
        {
            using var meter = new Meter(Utils.GetCurrentMethodName());
            var histogram = meter.CreateHistogram<double>("MyHistogram");
            var exportedItems = new List<Metric>();
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView(histogram.Name, histogramConfiguration)
                .AddInMemoryExporter(exportedItems)
                .Build();

            for (var i = 0; i < values.Length; i++)
            {
                histogram.Record(values[i]);
            }

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);

            var metricPoints = new List<MetricPoint>();
            foreach (ref readonly var mp in exportedItems[0].GetMetricPoints())
            {
                metricPoints.Add(mp);
            }

            var histogramPoint = metricPoints[0];
            if (histogramPoint.TryGetHistogramMinMaxValues(out double min, out double max))
            {
                Assert.Equal(expectedMin, min);
                Assert.Equal(expectedMax, max);
            }
            else
            {
                Assert.Fail("MinMax expected");
            }
        }

        [Theory]
        [MemberData(nameof(MetricTestData.InvalidHistogramMinMax), MemberType = typeof(MetricTestData))]
        public void HistogramMinMaxNotPresent(double[] values, HistogramConfiguration histogramConfiguration)
        {
            using var meter = new Meter(Utils.GetCurrentMethodName());
            var histogram = meter.CreateHistogram<double>("MyHistogram");
            var exportedItems = new List<Metric>();
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView(histogram.Name, histogramConfiguration)
                .AddInMemoryExporter(exportedItems)
                .Build();

            for (var i = 0; i < values.Length; i++)
            {
                histogram.Record(values[i]);
            }

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);

            var metricPoints = new List<MetricPoint>();
            foreach (ref readonly var mp in exportedItems[0].GetMetricPoints())
            {
                metricPoints.Add(mp);
            }

            var histogramPoint = metricPoints[0];
            Assert.False(histogramPoint.TryGetHistogramMinMaxValues(out double _, out double _));
        }

        [Fact]
        public void ViewToSelectTagKeys()
        {
            using var meter = new Meter(Utils.GetCurrentMethodName());
            var exportedItems = new List<Metric>();
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView("FruitCounter", new MetricStreamConfiguration()
                {
                    TagKeys = new string[] { "name" },
                    Name = "NameOnly",
                })
                .AddView("FruitCounter", new MetricStreamConfiguration()
                {
                    TagKeys = new string[] { "size" },
                    Name = "SizeOnly",
                })
                .AddView("FruitCounter", new MetricStreamConfiguration()
                {
                    TagKeys = Array.Empty<string>(),
                    Name = "NoTags",
                })
                .AddInMemoryExporter(exportedItems)
                .Build();

            var counter = meter.CreateCounter<long>("FruitCounter");
            counter.Add(10, new("name", "apple"), new("color", "red"), new("size", "small"));
            counter.Add(10, new("name", "apple"), new("color", "red"), new("size", "small"));

            counter.Add(10, new("name", "apple"), new("color", "red"), new("size", "medium"));
            counter.Add(10, new("name", "apple"), new("color", "red"), new("size", "medium"));

            counter.Add(10, new("name", "apple"), new("color", "red"), new("size", "large"));
            counter.Add(10, new("name", "apple"), new("color", "red"), new("size", "large"));

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);
            Assert.Equal(3, exportedItems.Count);
            var metric = exportedItems[0];
            Assert.Equal("NameOnly", metric.Name);
            List<MetricPoint> metricPoints = new List<MetricPoint>();
            foreach (ref readonly var mp in metric.GetMetricPoints())
            {
                metricPoints.Add(mp);
            }

            // Only one point expected "apple"
            Assert.Single(metricPoints);

            metric = exportedItems[1];
            Assert.Equal("SizeOnly", metric.Name);
            metricPoints.Clear();
            foreach (ref readonly var mp in metric.GetMetricPoints())
            {
                metricPoints.Add(mp);
            }

            // 3 points small,medium,large expected
            Assert.Equal(3, metricPoints.Count);

            metric = exportedItems[2];
            Assert.Equal("NoTags", metric.Name);
            metricPoints.Clear();
            foreach (ref readonly var mp in metric.GetMetricPoints())
            {
                metricPoints.Add(mp);
            }

            // Single point expected.
            Assert.Single(metricPoints);
        }

        [Fact]
        public void ViewToDropSingleInstrument()
        {
            using var meter = new Meter(Utils.GetCurrentMethodName());
            var exportedItems = new List<Metric>();
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView("counterNotInteresting", MetricStreamConfiguration.Drop)
                .AddInMemoryExporter(exportedItems)
                .Build();

            // Expecting one metric stream.
            var counterInteresting = meter.CreateCounter<long>("counterInteresting");
            var counterNotInteresting = meter.CreateCounter<long>("counterNotInteresting");
            counterInteresting.Add(10);
            counterNotInteresting.Add(10);

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);
            Assert.Single(exportedItems);
            var metric = exportedItems[0];
            Assert.Equal("counterInteresting", metric.Name);
        }

        [Fact]
        public void ViewToDropSingleInstrumentObservableCounter()
        {
            using var meter = new Meter(Utils.GetCurrentMethodName());
            var exportedItems = new List<Metric>();
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView("observableCounterNotInteresting", MetricStreamConfiguration.Drop)
                .AddInMemoryExporter(exportedItems)
                .Build();

            // Expecting one metric stream.
            meter.CreateObservableCounter("observableCounterNotInteresting", () => { return 10; }, "ms");
            meter.CreateObservableCounter("observableCounterInteresting", () => { return 10; }, "ms");

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);
            Assert.Single(exportedItems);
            var metric = exportedItems[0];
            Assert.Equal("observableCounterInteresting", metric.Name);
        }

        [Fact]
        public void ViewToDropSingleInstrumentObservableGauge()
        {
            using var meter = new Meter(Utils.GetCurrentMethodName());
            var exportedItems = new List<Metric>();
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView("observableGaugeNotInteresting", MetricStreamConfiguration.Drop)
                .AddInMemoryExporter(exportedItems)
                .Build();

            // Expecting one metric stream.
            meter.CreateObservableGauge("observableGaugeNotInteresting", () => { return 10; }, "ms");
            meter.CreateObservableGauge("observableGaugeInteresting", () => { return 10; }, "ms");

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);
            Assert.Single(exportedItems);
            var metric = exportedItems[0];
            Assert.Equal("observableGaugeInteresting", metric.Name);
        }

        [Fact]
        public void ViewToDropMultipleInstruments()
        {
            using var meter = new Meter(Utils.GetCurrentMethodName());
            var exportedItems = new List<Metric>();
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView("server*", MetricStreamConfiguration.Drop)
                .AddInMemoryExporter(exportedItems)
                .Build();

            // Expecting two client metric streams as both server* are dropped.
            var serverRequests = meter.CreateCounter<long>("server.requests");
            var serverExceptions = meter.CreateCounter<long>("server.exceptions");
            var clientRequests = meter.CreateCounter<long>("client.requests");
            var clientExceptions = meter.CreateCounter<long>("client.exceptions");
            serverRequests.Add(10);
            serverExceptions.Add(10);
            clientRequests.Add(10);
            clientExceptions.Add(10);

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);
            Assert.Equal(2, exportedItems.Count);
            Assert.Equal("client.requests", exportedItems[0].Name);
            Assert.Equal("client.exceptions", exportedItems[1].Name);
        }

        [Fact]
        public void ViewToDropAndRetainInstrument()
        {
            using var meter = new Meter(Utils.GetCurrentMethodName());
            var exportedItems = new List<Metric>();
            using var meterProvider = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView("server.requests", MetricStreamConfiguration.Drop)
                .AddView("server.requests", "server.request_renamed")
                .AddInMemoryExporter(exportedItems)
                .Build();

            // Expecting one metric stream even though a View is asking
            // to drop the instrument, because another View is matching
            // the instrument, which asks to aggregate with defaults
            // and a use a new name for the resulting metric.
            var serverRequests = meter.CreateCounter<long>("server.requests");
            serverRequests.Add(10);

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);
            Assert.Single(exportedItems);
            Assert.Equal("server.request_renamed", exportedItems[0].Name);
        }

        [Fact]
        public void ViewConflict_OneInstrument_DifferentDescription()
        {
            var exportedItems = new List<Metric>();

            using var meter = new Meter($"{Utils.GetCurrentMethodName()}");
            var meterProviderBuilder = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView("instrumentName", new MetricStreamConfiguration() { Description = "newDescription1" })
                .AddView("instrumentName", new MetricStreamConfiguration() { Description = "newDescription2" })
                .AddInMemoryExporter(exportedItems);

            using var meterProvider = meterProviderBuilder.Build();

            var instrument = meter.CreateCounter<long>("instrumentName", "instrumentUnit", "instrumentDescription");

            instrument.Add(10);

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);
            Assert.Equal(2, exportedItems.Count);

            var metric1 = exportedItems[0];
            var metric2 = exportedItems[1];
            Assert.Equal("newDescription1", metric1.Description);
            Assert.Equal("newDescription2", metric2.Description);

            List<MetricPoint> metric1MetricPoints = new List<MetricPoint>();
            foreach (ref readonly var mp in metric1.GetMetricPoints())
            {
                metric1MetricPoints.Add(mp);
            }

            Assert.Single(metric1MetricPoints);
            var metricPoint1 = metric1MetricPoints[0];
            Assert.Equal(10, metricPoint1.GetSumLong());

            List<MetricPoint> metric2MetricPoints = new List<MetricPoint>();
            foreach (ref readonly var mp in metric2.GetMetricPoints())
            {
                metric2MetricPoints.Add(mp);
            }

            Assert.Single(metric2MetricPoints);
            var metricPoint2 = metric2MetricPoints[0];
            Assert.Equal(10, metricPoint2.GetSumLong());
        }

        [Fact]
        public void ViewConflict_TwoDistinctInstruments_ThreeStreams()
        {
            var exportedItems = new List<Metric>();

            using var meter = new Meter($"{Utils.GetCurrentMethodName()}");
            var meterProviderBuilder = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView((instrument) =>
                {
                    return new MetricStreamConfiguration() { Name = "MetricStreamA", Description = "description" };
                })
                .AddView((instrument) =>
                {
                    return instrument.Description == "description1"
                        ? new MetricStreamConfiguration() { Name = "MetricStreamB" }
                        : new MetricStreamConfiguration() { Name = "MetricStreamC" };
                })
                .AddInMemoryExporter(exportedItems);

            using var meterProvider = meterProviderBuilder.Build();

            var instrument1 = meter.CreateCounter<long>("name", "unit", "description1");
            var instrument2 = meter.CreateCounter<long>("name", "unit", "description2");

            instrument1.Add(10);
            instrument2.Add(10);

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);
            Assert.Equal(3, exportedItems.Count);

            var metricA = exportedItems[0];
            var metricB = exportedItems[1];
            var metricC = exportedItems[2];

            Assert.Equal("MetricStreamA", metricA.Name);
            Assert.Equal(20, GetAggregatedValue(metricA));

            Assert.Equal("MetricStreamB", metricB.Name);
            Assert.Equal(10, GetAggregatedValue(metricB));

            Assert.Equal("MetricStreamC", metricC.Name);
            Assert.Equal(10, GetAggregatedValue(metricC));

            long GetAggregatedValue(Metric metric)
            {
                var metricPoints = new List<MetricPoint>();
                foreach (ref readonly var mp in metric.GetMetricPoints())
                {
                    metricPoints.Add(mp);
                }

                Assert.Single(metricPoints);
                return metricPoints[0].GetSumLong();
            }
        }

        [Fact]
        public void ViewConflict_TwoIdenticalInstruments_TwoViews_DifferentTags()
        {
            var exportedItems = new List<Metric>();

            using var meter = new Meter($"{Utils.GetCurrentMethodName()}");
            var meterProviderBuilder = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView((instrument) =>
                {
                    return new MetricStreamConfiguration { TagKeys = new[] { "key1" } };
                })
                .AddView((instrument) =>
                {
                    return new MetricStreamConfiguration { TagKeys = new[] { "key2" } };
                })
                .AddInMemoryExporter(exportedItems);

            using var meterProvider = meterProviderBuilder.Build();

            var instrument1 = meter.CreateCounter<long>("name");
            var instrument2 = meter.CreateCounter<long>("name");

            var tags = new KeyValuePair<string, object>[]
            {
                new("key1", "value"),
                new("key2", "value"),
            };

            instrument1.Add(10, tags);
            instrument2.Add(10, tags);

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);

            Assert.Equal(2, exportedItems.Count);
            var metric1 = new List<Metric>() { exportedItems[0] };
            var metric2 = new List<Metric>() { exportedItems[1] };
            var tag1 = new List<KeyValuePair<string, object>> { tags[0] };
            var tag2 = new List<KeyValuePair<string, object>> { tags[1] };

            Assert.Equal("name", exportedItems[0].Name);
            Assert.Equal("name", exportedItems[1].Name);
            Assert.Equal(20, GetLongSum(metric1));
            Assert.Equal(20, GetLongSum(metric2));
            CheckTagsForNthMetricPoint(metric1, tag1, 1);
            CheckTagsForNthMetricPoint(metric2, tag2, 1);
        }

        [Fact]
        public void ViewConflict_TwoIdenticalInstruments_TwoViews_SameTags()
        {
            var exportedItems = new List<Metric>();

            using var meter = new Meter($"{Utils.GetCurrentMethodName()}");
            var meterProviderBuilder = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView((instrument) =>
                {
                    return new MetricStreamConfiguration { TagKeys = new[] { "key1" } };
                })
                .AddView((instrument) =>
                {
                    return new MetricStreamConfiguration { TagKeys = new[] { "key1" } };
                })
                .AddInMemoryExporter(exportedItems);

            using var meterProvider = meterProviderBuilder.Build();

            var instrument1 = meter.CreateCounter<long>("name");
            var instrument2 = meter.CreateCounter<long>("name");

            var tags = new KeyValuePair<string, object>[]
            {
                new("key1", "value"),
                new("key2", "value"),
            };

            instrument1.Add(10, tags);
            instrument2.Add(10, tags);

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);

            Assert.Equal(2, exportedItems.Count);

            var metric1 = new List<Metric>() { exportedItems[0] };
            var tag1 = new List<KeyValuePair<string, object>> { tags[0] };
            Assert.Equal("name", exportedItems[0].Name);
            Assert.Equal(20, GetLongSum(metric1));
            CheckTagsForNthMetricPoint(metric1, tag1, 1);

            var metric2 = new List<Metric>() { exportedItems[1] };
            var tag2 = new List<KeyValuePair<string, object>> { tags[0] };
            Assert.Equal("name", exportedItems[1].Name);
            Assert.Equal(20, GetLongSum(metric2));
            CheckTagsForNthMetricPoint(metric2, tag2, 1);
        }

        [Fact]
        public void ViewConflict_TwoIdenticalInstruments_TwoViews_DifferentHistogramBounds()
        {
            var exportedItems = new List<Metric>();

            using var meter = new Meter($"{Utils.GetCurrentMethodName()}");
            var meterProviderBuilder = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView((instrument) =>
                {
                    return new ExplicitBucketHistogramConfiguration { Boundaries = new[] { 5.0, 10.0 } };
                })
                .AddView((instrument) =>
                {
                    return new ExplicitBucketHistogramConfiguration { Boundaries = new[] { 10.0, 20.0 } };
                })
                .AddInMemoryExporter(exportedItems);

            using var meterProvider = meterProviderBuilder.Build();

            var instrument1 = meter.CreateHistogram<long>("name");
            var instrument2 = meter.CreateHistogram<long>("name");

            instrument1.Record(15);
            instrument2.Record(15);

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);

            Assert.Equal(2, exportedItems.Count);
            var metric1 = exportedItems[0];
            var metric2 = exportedItems[1];

            Assert.Equal("name", exportedItems[0].Name);
            Assert.Equal("name", exportedItems[1].Name);

            var metricPoints = new List<MetricPoint>();
            foreach (ref readonly var mp in metric1.GetMetricPoints())
            {
                metricPoints.Add(mp);
            }

            Assert.Single(metricPoints);
            var metricPoint = metricPoints[0];
            Assert.Equal(2, metricPoint.GetHistogramCount());
            Assert.Equal(30, metricPoint.GetHistogramSum());

            var index = 0;
            var actualCount = 0;
            var expectedBucketCounts = new long[] { 0, 0, 2 };
            foreach (var histogramMeasurement in metricPoint.GetHistogramBuckets())
            {
                Assert.Equal(expectedBucketCounts[index], histogramMeasurement.BucketCount);
                index++;
                actualCount++;
            }

            metricPoints = new List<MetricPoint>();
            foreach (ref readonly var mp in metric2.GetMetricPoints())
            {
                metricPoints.Add(mp);
            }

            Assert.Single(metricPoints);
            metricPoint = metricPoints[0];
            Assert.Equal(2, metricPoint.GetHistogramCount());
            Assert.Equal(30, metricPoint.GetHistogramSum());

            index = 0;
            actualCount = 0;
            expectedBucketCounts = new long[] { 0, 2, 0 };
            foreach (var histogramMeasurement in metricPoint.GetHistogramBuckets())
            {
                Assert.Equal(expectedBucketCounts[index], histogramMeasurement.BucketCount);
                index++;
                actualCount++;
            }
        }

        [Fact]
        public void ViewConflict_TwoInstruments_OneMatchesView()
        {
            var exportedItems = new List<Metric>();

            using var meter = new Meter($"{Utils.GetCurrentMethodName()}");
            var meterProviderBuilder = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView((instrument) =>
                {
                    if (instrument.Name == "name")
                    {
                        return new MetricStreamConfiguration { Name = "othername", TagKeys = new[] { "key1" } };
                    }
                    else
                    {
                        return null;
                    }
                })
                .AddInMemoryExporter(exportedItems);

            using var meterProvider = meterProviderBuilder.Build();

            var instrument1 = meter.CreateCounter<long>("name");
            var instrument2 = meter.CreateCounter<long>("othername");

            var tags = new KeyValuePair<string, object>[]
            {
                new("key1", "value"),
                new("key2", "value"),
            };

            instrument1.Add(10, tags);
            instrument2.Add(10, tags);

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);

            Assert.Equal(2, exportedItems.Count);
            var metric1 = new List<Metric>() { exportedItems[0] };
            var metric2 = new List<Metric>() { exportedItems[1] };

            var tags1 = new List<KeyValuePair<string, object>> { tags[0] };
            var tags2 = new List<KeyValuePair<string, object>> { tags[0], tags[1] };

            Assert.Equal("othername", exportedItems[0].Name);
            Assert.Equal("othername", exportedItems[1].Name);

            Assert.Equal(10, GetLongSum(metric1));
            Assert.Equal(10, GetLongSum(metric2));

            CheckTagsForNthMetricPoint(metric1, tags1, 1);
            CheckTagsForNthMetricPoint(metric2, tags2, 1);
        }

        [Fact]
        public void ViewConflict_TwoInstruments_ConflictAvoidedBecauseSecondInstrumentIsDropped()
        {
            var exportedItems = new List<Metric>();

            using var meter = new Meter($"{Utils.GetCurrentMethodName()}");
            var meterProviderBuilder = Sdk.CreateMeterProviderBuilder()
                .AddMeter(meter.Name)
                .AddView((instrument) =>
                {
                    if (instrument.Name == "name")
                    {
                        return new MetricStreamConfiguration { Name = "othername" };
                    }
                    else
                    {
                        return MetricStreamConfiguration.Drop;
                    }
                })
                .AddInMemoryExporter(exportedItems);

            using var meterProvider = meterProviderBuilder.Build();

            var instrument1 = meter.CreateCounter<long>("name");
            var instrument2 = meter.CreateCounter<long>("othername");

            instrument1.Add(10);
            instrument2.Add(20);

            meterProvider.ForceFlush(MaxTimeToAllowForFlush);

            Assert.Single(exportedItems);
            var metric1 = new List<Metric>() { exportedItems[0] };

            Assert.Equal("othername", exportedItems[0].Name);
            Assert.Equal(10, GetLongSum(metric1));
        }
    }
}