﻿using Lucene.Net.Analysis;
using Lucene.Net.Documents;
using Lucene.Net.Index;
using Lucene.Net.Search;
using Lucene.Net.Util;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;
using System.Text;
using Console = Lucene.Net.Util.SystemConsole;

namespace Lucene.Net.QueryParsers.Xml
{
    /*
     * 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 TestParser : LuceneTestCase
    {
        private static CoreParser builder;
        private static Store.Directory dir;
        private static IndexReader reader;
        private static IndexSearcher searcher;

        [OneTimeSetUp]
        public override void BeforeClass()
        {
            base.BeforeClass();

            // TODO: rewrite test (this needs to set QueryParser.enablePositionIncrements, too, for work with CURRENT):
            Analyzer analyzer = new MockAnalyzer(Random, MockTokenizer.WHITESPACE, true, MockTokenFilter.ENGLISH_STOPSET);
            //initialize the parser
            builder = new CorePlusExtensionsParser("contents", analyzer);

            TextReader d = new StreamReader(
                typeof(TestParser).getResourceAsStream("reuters21578.txt"), Encoding.ASCII);
            dir = NewDirectory();
            IndexWriter writer = new IndexWriter(dir, NewIndexWriterConfig(TEST_VERSION_CURRENT, analyzer));
            String line = d.ReadLine();
            while (line != null)
            {
                int endOfDate = line.IndexOf('\t');
                String date = line.Substring(0, endOfDate).Trim();
                String content = line.Substring(endOfDate).Trim();
                Document doc = new Document();
                doc.Add(NewTextField("date", date, Field.Store.YES));
                doc.Add(NewTextField("contents", content, Field.Store.YES));
                doc.Add(new Int32Field("date2", Convert.ToInt32(date), Field.Store.NO));
                writer.AddDocument(doc);
                line = d.ReadLine();
            }
            d.Dispose();
            writer.Dispose();
            reader = DirectoryReader.Open(dir);
            searcher = NewSearcher(reader);
        }

        [OneTimeTearDown]
        public override void AfterClass()
        {
            reader.Dispose();
            dir.Dispose();
            reader = null;
            searcher = null;
            dir = null;
            builder = null;
            base.AfterClass();
        }

        [Test]
        public void TestSimpleXML()
        {
            Query q = Parse("TermQuery.xml");
            DumpResults("TermQuery", q, 5);
        }

        [Test]
        public void TestSimpleTermsQueryXML()
        {
            Query q = Parse("TermsQuery.xml");
            DumpResults("TermsQuery", q, 5);
        }

        [Test]
        public void TestBooleanQueryXML()
        {
            Query q = Parse("BooleanQuery.xml");
            DumpResults("BooleanQuery", q, 5);
        }

        [Test]
        public void TestDisjunctionMaxQueryXML()
        {
            Query q = Parse("DisjunctionMaxQuery.xml");
            assertTrue(q is DisjunctionMaxQuery);
            DisjunctionMaxQuery d = (DisjunctionMaxQuery)q;
            assertEquals(0.0f, d.TieBreakerMultiplier, 0.0001f);
            assertEquals(2, d.Disjuncts.size());
            DisjunctionMaxQuery ndq = (DisjunctionMaxQuery)d.Disjuncts[1];
            assertEquals(1.2f, ndq.TieBreakerMultiplier, 0.0001f);
            assertEquals(1, ndq.Disjuncts.size());
        }

        [Test]
        public void TestRangeFilterQueryXML()
        {
            Query q = Parse("RangeFilterQuery.xml");
            DumpResults("RangeFilter", q, 5);
        }

        [Test]
        public void TestUserQueryXML()
        {
            Query q = Parse("UserInputQuery.xml");
            DumpResults("UserInput with Filter", q, 5);
        }

        [Test]
        public void TestCustomFieldUserQueryXML()
        {
            Query q = Parse("UserInputQueryCustomField.xml");
            int h = searcher.Search(q, null, 1000).TotalHits;
            assertEquals("UserInputQueryCustomField should produce 0 result ", 0, h);
        }

        [Test]
        public void TestLikeThisQueryXML()
        {
            Query q = Parse("LikeThisQuery.xml");
            DumpResults("like this", q, 5);
        }

        [Test]
        public void TestBoostingQueryXML()
        {
            Query q = Parse("BoostingQuery.xml");
            DumpResults("boosting ", q, 5);
        }

        [Test]
        public void TestFuzzyLikeThisQueryXML()
        {
            Query q = Parse("FuzzyLikeThisQuery.xml");
            //show rewritten fuzzyLikeThisQuery - see what is being matched on
            if (Verbose)
            {
                Console.WriteLine(q.Rewrite(reader));
            }
            DumpResults("FuzzyLikeThis", q, 5);
        }

        [Test]
        public void TestTermsFilterXML()
        {
            Query q = Parse("TermsFilterQuery.xml");
            DumpResults("Terms Filter", q, 5);
        }

        [Test]
        public void TestBoostingTermQueryXML()
        {
            Query q = Parse("BoostingTermQuery.xml");
            DumpResults("BoostingTermQuery", q, 5);
        }

        [Test]
        public void TestSpanTermXML()
        {
            Query q = Parse("SpanQuery.xml");
            DumpResults("Span Query", q, 5);
        }

        [Test]
        public void TestConstantScoreQueryXML()
        {
            Query q = Parse("ConstantScoreQuery.xml");
            DumpResults("ConstantScoreQuery", q, 5);
        }

        [Test]
        public void TestMatchAllDocsPlusFilterXML()
        {
            Query q = Parse("MatchAllDocsQuery.xml");
            DumpResults("MatchAllDocsQuery with range filter", q, 5);
        }

        [Test]
        public void TestBooleanFilterXML()
        {
            Query q = Parse("BooleanFilter.xml");
            DumpResults("Boolean filter", q, 5);
        }

        [Test]
        public void TestNestedBooleanQuery()
        {
            Query q = Parse("NestedBooleanQuery.xml");
            DumpResults("Nested Boolean query", q, 5);
        }

        [Test]
        public void TestCachedFilterXML()
        {
            Query q = Parse("CachedFilter.xml");
            DumpResults("Cached filter", q, 5);
        }

        [Test]
        public void TestDuplicateFilterQueryXML()
        {
            IList<AtomicReaderContext> leaves = searcher.TopReaderContext.Leaves;
            //AssumeTrue("", leaves.size() == 1); // LUCENENET NOTE: Not sure why this is here - the test is skipped
            Query q = Parse("DuplicateFilterQuery.xml");
            int h = searcher.Search(q, null, 1000).TotalHits;
            assertEquals("DuplicateFilterQuery should produce 1 result ", 1, h);
        }

        [Test]
        public void TestNumericRangeFilterQueryXML()
        {
            Query q = Parse("NumericRangeFilterQuery.xml");
            DumpResults("NumericRangeFilter", q, 5);
        }

        [Test]
        public void TestNumericRangeQueryQueryXML()
        {
            Query q = Parse("NumericRangeQueryQuery.xml");
            DumpResults("NumericRangeQuery", q, 5);
        }

        //================= Helper methods ===================================

        private Query Parse(String xmlFileName)
        {
            using (Stream xmlStream = typeof(TestParser).getResourceAsStream(xmlFileName))
            {
                Query result = builder.Parse(xmlStream);
                return result;
            }
        }

        private void DumpResults(String qType, Query q, int numDocs)
        {
            if (Verbose)
            {
                Console.WriteLine("TEST: query=" + q);
            }
            TopDocs hits = searcher.Search(q, null, numDocs);
            assertTrue(qType + " should produce results ", hits.TotalHits > 0);
            if (Verbose)
            {
                Console.WriteLine("=========" + qType + "============");
                ScoreDoc[] scoreDocs = hits.ScoreDocs;
                for (int i = 0; i < Math.Min(numDocs, hits.TotalHits); i++)
                {
                    Document ldoc = searcher.Doc(scoreDocs[i].Doc);
                    Console.WriteLine("[" + ldoc.Get("date") + "]" + ldoc.Get("contents"));
                }
                Console.WriteLine();
            }
        }
    }
}