﻿using Lucene.Net.Support;
using Lucene.Net.Util;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using JCG = J2N.Collections.Generic;

namespace Lucene.Net.Search.Suggest
{
    /*
     * 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.
     */

    public class TestInputIterator : LuceneTestCase
    {
        [Test]
        public void TestEmpty()
        {
            InputArrayEnumerator iterator = new InputArrayEnumerator(new Input[0]);
            IInputEnumerator wrapper = new SortedInputEnumerator(iterator, BytesRef.UTF8SortedAsUnicodeComparer);
            assertFalse(wrapper.MoveNext());
            wrapper = new UnsortedInputEnumerator(iterator);
            assertFalse(wrapper.MoveNext());
        }

        [Test]
        public void TestTerms()
        {
            Random random = Random;
            int num = AtLeast(10000);
#pragma warning disable 612, 618
            IComparer<BytesRef> comparer = random.nextBoolean() ? BytesRef.UTF8SortedAsUnicodeComparer : BytesRef.UTF8SortedAsUTF16Comparer;
#pragma warning restore 612, 618
            IDictionary<BytesRef, KeyValuePair<long, BytesRef>> sorted = new JCG.SortedDictionary<BytesRef, KeyValuePair<long, BytesRef>>(comparer);
            IDictionary<BytesRef, long> sortedWithoutPayload = new JCG.SortedDictionary<BytesRef, long>(comparer);
            IDictionary<BytesRef, KeyValuePair<long, ISet<BytesRef>>> sortedWithContext = new JCG.SortedDictionary<BytesRef, KeyValuePair<long, ISet<BytesRef>>>(comparer);
            IDictionary<BytesRef, KeyValuePair<long, KeyValuePair<BytesRef, ISet<BytesRef>>>> sortedWithPayloadAndContext = new JCG.SortedDictionary<BytesRef, KeyValuePair<long, KeyValuePair<BytesRef, ISet<BytesRef>>>>(comparer);
            Input[] unsorted = new Input[num];
            Input[] unsortedWithoutPayload = new Input[num];
            Input[] unsortedWithContexts = new Input[num];
            Input[] unsortedWithPayloadAndContext = new Input[num];
            ISet<BytesRef> ctxs;
            for (int i = 0; i < num; i++)
            {
                BytesRef key2;
                BytesRef payload;
                ctxs = new JCG.HashSet<BytesRef>();
                do
                {
                    key2 = new BytesRef(TestUtil.RandomUnicodeString(random));
                    payload = new BytesRef(TestUtil.RandomUnicodeString(random));
                    for (int j = 0; j < AtLeast(2); j++)
                    {
                        ctxs.add(new BytesRef(TestUtil.RandomUnicodeString(random)));
                    }
                } while (sorted.ContainsKey(key2));
                long value = random.Next();
                sortedWithoutPayload.Put(key2, value);
                sorted.Put(key2, new KeyValuePair<long, BytesRef>(value, payload));
                sortedWithContext.Put(key2, new KeyValuePair<long, ISet<BytesRef>>(value, ctxs));
                sortedWithPayloadAndContext.Put(key2, new KeyValuePair<long, KeyValuePair<BytesRef, ISet<BytesRef>>>(value, new KeyValuePair<BytesRef, ISet<BytesRef>>(payload, ctxs)));
                unsorted[i] = new Input(key2, value, payload);
                unsortedWithoutPayload[i] = new Input(key2, value);
                unsortedWithContexts[i] = new Input(key2, value, ctxs);
                unsortedWithPayloadAndContext[i] = new Input(key2, value, payload, ctxs);
            }

            // test the sorted iterator wrapper with payloads
            IInputEnumerator wrapper = new SortedInputEnumerator(new InputArrayEnumerator(unsorted), comparer);
            IEnumerator<KeyValuePair<BytesRef, KeyValuePair<long, BytesRef>>> expected = sorted.GetEnumerator();
            while (expected.MoveNext())
            {
                KeyValuePair<BytesRef, KeyValuePair<long, BytesRef>> entry = expected.Current;

                assertTrue(wrapper.MoveNext());
                assertEquals(entry.Key, wrapper.Current);
                assertEquals(Convert.ToInt64(entry.Value.Key), wrapper.Weight);
                assertEquals(entry.Value.Value, wrapper.Payload);
            }
            assertFalse(wrapper.MoveNext());

            // test the sorted iterator wrapper with contexts
            wrapper = new SortedInputEnumerator(new InputArrayEnumerator(unsortedWithContexts), comparer);
            IEnumerator<KeyValuePair<BytesRef, KeyValuePair<long, ISet<BytesRef>>>> actualEntries = sortedWithContext.GetEnumerator();
            while (actualEntries.MoveNext())
            {
                KeyValuePair<BytesRef, KeyValuePair<long, ISet<BytesRef>>> entry = actualEntries.Current;
                assertTrue(wrapper.MoveNext());
                assertEquals(entry.Key, wrapper.Current);
                assertEquals(Convert.ToInt64(entry.Value.Key), wrapper.Weight);
                ISet<BytesRef> actualCtxs = entry.Value.Value;
                assertEquals(actualCtxs, wrapper.Contexts);
            }
            assertFalse(wrapper.MoveNext());

            // test the sorted iterator wrapper with contexts and payload
            wrapper = new SortedInputEnumerator(new InputArrayEnumerator(unsortedWithPayloadAndContext), comparer);
            IEnumerator<KeyValuePair<BytesRef, KeyValuePair<long, KeyValuePair<BytesRef, ISet<BytesRef>>>>> expectedPayloadContextEntries = sortedWithPayloadAndContext.GetEnumerator();
            while (expectedPayloadContextEntries.MoveNext())
            {
                KeyValuePair<BytesRef, KeyValuePair<long, KeyValuePair<BytesRef, ISet<BytesRef>>>> entry = expectedPayloadContextEntries.Current;
                assertTrue(wrapper.MoveNext());
                assertEquals(entry.Key, wrapper.Current);
                assertEquals(Convert.ToInt64(entry.Value.Key), wrapper.Weight);
                ISet<BytesRef> actualCtxs = entry.Value.Value.Value;
                assertEquals(actualCtxs, wrapper.Contexts);
                BytesRef actualPayload = entry.Value.Value.Key;
                assertEquals(actualPayload, wrapper.Payload);
            }
            assertFalse(wrapper.MoveNext());

            // test the unsorted iterator wrapper with payloads
            wrapper = new UnsortedInputEnumerator(new InputArrayEnumerator(unsorted));
            IDictionary<BytesRef, KeyValuePair<long, BytesRef>> actual = new JCG.SortedDictionary<BytesRef, KeyValuePair<long, BytesRef>>();
            while (wrapper.MoveNext())
            {
                long value = wrapper.Weight;
                BytesRef payload = wrapper.Payload;
                actual.Put(BytesRef.DeepCopyOf(wrapper.Current), new KeyValuePair<long, BytesRef>(value, BytesRef.DeepCopyOf(payload)));
            }
            assertEquals(sorted, actual, aggressive: false);

            // test the sorted iterator wrapper without payloads
            IInputEnumerator wrapperWithoutPayload = new SortedInputEnumerator(new InputArrayEnumerator(unsortedWithoutPayload), comparer);
            IEnumerator<KeyValuePair<BytesRef, long>> expectedWithoutPayload = sortedWithoutPayload.GetEnumerator();
            while (expectedWithoutPayload.MoveNext())
            {
                KeyValuePair<BytesRef, long> entry = expectedWithoutPayload.Current;

                assertTrue(wrapperWithoutPayload.MoveNext());
                assertEquals(entry.Key, wrapperWithoutPayload.Current);
                assertEquals(Convert.ToInt64(entry.Value), wrapperWithoutPayload.Weight);
                assertNull(wrapperWithoutPayload.Payload);
            }
            assertFalse(wrapperWithoutPayload.MoveNext());

            // test the unsorted iterator wrapper without payloads
            wrapperWithoutPayload = new UnsortedInputEnumerator(new InputArrayEnumerator(unsortedWithoutPayload));
            IDictionary<BytesRef, long> actualWithoutPayload = new JCG.SortedDictionary<BytesRef, long>();
            while (wrapperWithoutPayload.MoveNext())
            {
                long value = wrapperWithoutPayload.Weight;
                assertNull(wrapperWithoutPayload.Payload);
                actualWithoutPayload.Put(BytesRef.DeepCopyOf(wrapperWithoutPayload.Current), value);
            }
            assertEquals(sortedWithoutPayload, actualWithoutPayload, aggressive: false);
        }

        public static long AsLong(BytesRef b)
        {
            return (((long)AsIntInternal(b, b.Offset) << 32) | AsIntInternal(b,
                b.Offset + 4) & 0xFFFFFFFFL);
        }

        private static int AsIntInternal(BytesRef b, int pos)
        {
            return ((b.Bytes[pos++] & 0xFF) << 24) | ((b.Bytes[pos++] & 0xFF) << 16)
                | ((b.Bytes[pos++] & 0xFF) << 8) | (b.Bytes[pos] & 0xFF);
        }
    }
}