﻿using Lucene.Net.Support;
using NUnit.Framework;
using System;
using Assert = Lucene.Net.TestFramework.Assert;

namespace Lucene.Net.Facet.Taxonomy
{

    using BytesRef = Lucene.Net.Util.BytesRef;
    using SortedSetDocValuesFacetField = Lucene.Net.Facet.SortedSet.SortedSetDocValuesFacetField;
    using TestUtil = Lucene.Net.Util.TestUtil;

    /*
     * Licensed to the Apache Software Foundation (ASF) under one or more
     * contributor license agreements.  See the NOTICE file distributed with
     * this work for additional information regarding copyright ownership.
     * The ASF licenses this file to You 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.
     */
    [TestFixture]
    public class TestFacetLabel : FacetTestCase
    {

        [Test]
        public virtual void TestBasic()
        {
            Assert.AreEqual(0, (new FacetLabel()).Length);
            Assert.AreEqual(1, (new FacetLabel("hello")).Length);
            Assert.AreEqual(2, (new FacetLabel("hello", "world")).Length);
        }

        [Test]
        public virtual void TestToString()
        {
            // When the category is empty, we expect an empty string
            Assert.AreEqual("FacetLabel: []", (new FacetLabel()).ToString());
            // one category
            Assert.AreEqual("FacetLabel: [hello]", (new FacetLabel("hello")).ToString());
            // more than one category
            Assert.AreEqual("FacetLabel: [hello, world]", (new FacetLabel("hello", "world")).ToString());
        }

        [Test]
        public virtual void TestGetComponent()
        {
            string[] components = new string[AtLeast(10)];
            for (int i = 0; i < components.Length; i++)
            {
                components[i] = Convert.ToString(i);
            }
            FacetLabel cp = new FacetLabel(components);
            for (int i = 0; i < components.Length; i++)
            {
                Assert.AreEqual(i, Convert.ToInt32(cp.Components[i]));
            }
        }

        [Test]
        public virtual void TestDefaultConstructor()
        {
            // test that the default constructor (no parameters) currently
            // defaults to creating an object with a 0 initial capacity.
            // If we change this default later, we also need to change this
            // test.
            FacetLabel p = new FacetLabel();
            Assert.AreEqual(0, p.Length);
            Assert.AreEqual("FacetLabel: []", p.ToString());
        }

        [Test]
        public virtual void TestSubPath()
        {
            FacetLabel p = new FacetLabel("hi", "there", "man");
            Assert.AreEqual(p.Length, 3);

            FacetLabel p1 = p.Subpath(2);
            Assert.AreEqual(2, p1.Length);
            Assert.AreEqual("FacetLabel: [hi, there]", p1.ToString());

            p1 = p.Subpath(1);
            Assert.AreEqual(1, p1.Length);
            Assert.AreEqual("FacetLabel: [hi]", p1.ToString());

            p1 = p.Subpath(0);
            Assert.AreEqual(0, p1.Length);
            Assert.AreEqual("FacetLabel: []", p1.ToString());

            // with all the following lengths, the prefix should be the whole path 
            int[] lengths = new int[] { 3, -1, 4 };
            for (int i = 0; i < lengths.Length; i++)
            {
                p1 = p.Subpath(lengths[i]);
                Assert.AreEqual(3, p1.Length);
                Assert.AreEqual("FacetLabel: [hi, there, man]", p1.ToString());
                Assert.AreEqual(p, p1);
            }
        }

        [Test]
        public virtual void TestEquals()
        {
            Assert.AreEqual(new FacetLabel(), new FacetLabel());
            Assert.False((new FacetLabel()).Equals(new FacetLabel("hi")));
            Assert.False((new FacetLabel()).Equals(Convert.ToInt32(3)));
            Assert.AreEqual(new FacetLabel("hello", "world"), new FacetLabel("hello", "world"));
        }

        [Test]
        public virtual void TestHashCode()
        {
            Assert.AreEqual((new FacetLabel()).GetHashCode(), (new FacetLabel()).GetHashCode());
            Assert.False((new FacetLabel()).GetHashCode() == (new FacetLabel("hi")).GetHashCode());
            Assert.AreEqual((new FacetLabel("hello", "world")).GetHashCode(), (new FacetLabel("hello", "world")).GetHashCode());
        }

        [Test]
        public virtual void TestLongHashCode()
        {
            Assert.AreEqual((new FacetLabel()).Int64HashCode(), (new FacetLabel()).Int64HashCode());
            Assert.False((new FacetLabel()).Int64HashCode() == (new FacetLabel("hi")).Int64HashCode());
            Assert.AreEqual((new FacetLabel("hello", "world")).Int64HashCode(), (new FacetLabel("hello", "world")).Int64HashCode());
        }

        [Test]
        public virtual void TestArrayConstructor()
        {
            FacetLabel p = new FacetLabel("hello", "world", "yo");
            Assert.AreEqual(3, p.Length);
            Assert.AreEqual("FacetLabel: [hello, world, yo]", p.ToString());
        }

        [Test]
        public virtual void TestCompareTo()
        {
            FacetLabel p = new FacetLabel("a", "b", "c", "d");
            FacetLabel pother = new FacetLabel("a", "b", "c", "d");
            Assert.AreEqual(0, pother.CompareTo(p));
            Assert.AreEqual(0, p.CompareTo(pother));
            pother = new FacetLabel();
            Assert.True(pother.CompareTo(p) < 0);
            Assert.True(p.CompareTo(pother) > 0);
            pother = new FacetLabel("a", "b_", "c", "d");
            Assert.True(pother.CompareTo(p) > 0);
            Assert.True(p.CompareTo(pother) < 0);
            pother = new FacetLabel("a", "b", "c");
            Assert.True(pother.CompareTo(p) < 0);
            Assert.True(p.CompareTo(pother) > 0);
            pother = new FacetLabel("a", "b", "c", "e");
            Assert.True(pother.CompareTo(p) > 0);
            Assert.True(p.CompareTo(pother) < 0);
        }

        [Test]
        public virtual void TestEmptyNullComponents()
        {
            // LUCENE-4724: CategoryPath should not allow empty or null components
            string[][] components_tests = new string[][]
        {
            new string[] {"", "test"},
            new string[] {"test", ""},
            new string[] {"test", "", "foo"},
            new string[] {null, "test"},
            new string[] {"test", null},
            new string[] {"test", null, "foo"}
        };

            foreach (string[] components in components_tests)
            {
                try
                {
                    Assert.NotNull(new FacetLabel(components));
                    fail("empty or null components should not be allowed: " + Arrays.ToString(components));
                }
                catch (ArgumentException)
                {
                    // expected
                }
                try
                {
                    new FacetField("dim", components);
                    fail("empty or null components should not be allowed: " + Arrays.ToString(components));
                }
                catch (ArgumentException)
                {
                    // expected
                }
                try
                {
                    new AssociationFacetField(new BytesRef(), "dim", components);
                    fail("empty or null components should not be allowed: " + Arrays.ToString(components));
                }
                catch (ArgumentException)
                {
                    // expected
                }
                try
                {
                    new Int32AssociationFacetField(17, "dim", components);
                    fail("empty or null components should not be allowed: " + Arrays.ToString(components));
                }
                catch (ArgumentException)
                {
                    // expected
                }
                try
                {
                    new SingleAssociationFacetField(17.0f, "dim", components);
                    fail("empty or null components should not be allowed: " + Arrays.ToString(components));
                }
                catch (ArgumentException)
                {
                    // expected
                }
            }
            try
            {
                new FacetField(null, new string[] { "abc" });
                fail("empty or null components should not be allowed");
            }
            catch (ArgumentException)
            {
                // expected
            }
            try
            {
                new FacetField("", new string[] { "abc" });
                fail("empty or null components should not be allowed");
            }
            catch (ArgumentException)
            {
                // expected
            }
            try
            {
                new Int32AssociationFacetField(17, null, new string[] { "abc" });
                fail("empty or null components should not be allowed");
            }
            catch (ArgumentException)
            {
                // expected
            }
            try
            {
                new Int32AssociationFacetField(17, "", new string[] { "abc" });
                fail("empty or null components should not be allowed");
            }
            catch (ArgumentException)
            {
                // expected
            }
            try
            {
                new SingleAssociationFacetField(17.0f, null, new string[] { "abc" });
                fail("empty or null components should not be allowed");
            }
            catch (ArgumentException)
            {
                // expected
            }
            try
            {
                new SingleAssociationFacetField(17.0f, "", new string[] { "abc" });
                fail("empty or null components should not be allowed");
            }
            catch (ArgumentException)
            {
                // expected
            }
            try
            {
                new AssociationFacetField(new BytesRef(), null, new string[] { "abc" });
                fail("empty or null components should not be allowed");
            }
            catch (ArgumentException)
            {
                // expected
            }
            try
            {
                new AssociationFacetField(new BytesRef(), "", new string[] { "abc" });
                fail("empty or null components should not be allowed");
            }
            catch (ArgumentException)
            {
                // expected
            }
            try
            {
                new SortedSetDocValuesFacetField(null, "abc");
                fail("empty or null components should not be allowed");
            }
            catch (ArgumentException)
            {
                // expected
            }
            try
            {
                new SortedSetDocValuesFacetField("", "abc");
                fail("empty or null components should not be allowed");
            }
            catch (ArgumentException)
            {
                // expected
            }
            try
            {
                new SortedSetDocValuesFacetField("dim", null);
                fail("empty or null components should not be allowed");
            }
            catch (ArgumentException)
            {
                // expected
            }
            try
            {
                new SortedSetDocValuesFacetField("dim", "");
                fail("empty or null components should not be allowed");
            }
            catch (ArgumentException)
            {
                // expected
            }
        }

        [Test]
        public virtual void TestLongPath()
        {
            string bigComp = null;
            while (true)
            {
                int len = FacetLabel.MAX_CATEGORY_PATH_LENGTH;
                bigComp = TestUtil.RandomSimpleString(Random, len, len);
                if (bigComp.IndexOf('\u001f') != -1)
                {
                    continue;
                }
                break;
            }

            try
            {
                Assert.NotNull(new FacetLabel("dim", bigComp));
                fail("long paths should not be allowed; len=" + bigComp.Length);
            }
            catch (ArgumentException)
            {
                // expected
            }
        }
    }

}