﻿using Lucene.Net.Analysis;
using Lucene.Net.QueryParsers.Classic;
using Lucene.Net.QueryParsers.Xml.Builders;
using Lucene.Net.Search;
using System;
using System.IO;
using System.Xml;

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.
     */

    /// <summary>
    /// Assembles a <see cref="IQueryBuilder"/> which uses only core Lucene Query objects
    /// </summary>
    public class CoreParser : IQueryBuilder
    {
        protected Analyzer m_analyzer;
        protected QueryParser m_parser;
        protected QueryBuilderFactory m_queryFactory;
        protected FilterBuilderFactory m_filterFactory;
        //Controls the max size of the LRU cache used for QueryFilter objects parsed.
        public static int maxNumCachedFilters = 20;

        /// <summary>
        /// Construct an XML parser that uses a single instance <see cref="QueryParser"/> for handling
        /// UserQuery tags - all parse operations are synchronised on this parser
        /// </summary>
        /// <param name="analyzer"></param>
        /// <param name="parser">A <see cref="QueryParser"/> which will be synchronized on during parse calls.</param>
        public CoreParser(Analyzer analyzer, QueryParser parser)
            : this(null, analyzer, parser)
        {
        }

        /// <summary>
        /// Constructs an XML parser that creates a <see cref="QueryParser"/> for each UserQuery request.
        /// </summary>
        /// <param name="defaultField">The default field name used by <see cref="QueryParser"/>s constructed for UserQuery tags</param>
        /// <param name="analyzer"></param>
        public CoreParser(string defaultField, Analyzer analyzer)
            : this(defaultField, analyzer, null)
        {
        }

        protected CoreParser(string defaultField, Analyzer analyzer, QueryParser parser)
        {
            this.m_analyzer = analyzer;
            this.m_parser = parser;
            m_filterFactory = new FilterBuilderFactory();
            m_filterFactory.AddBuilder("RangeFilter", new RangeFilterBuilder());
            m_filterFactory.AddBuilder("NumericRangeFilter", new NumericRangeFilterBuilder());

            m_queryFactory = new QueryBuilderFactory();
            m_queryFactory.AddBuilder("TermQuery", new TermQueryBuilder());
            m_queryFactory.AddBuilder("TermsQuery", new TermsQueryBuilder(analyzer));
            m_queryFactory.AddBuilder("MatchAllDocsQuery", new MatchAllDocsQueryBuilder());
            m_queryFactory.AddBuilder("BooleanQuery", new BooleanQueryBuilder(m_queryFactory));
            m_queryFactory.AddBuilder("NumericRangeQuery", new NumericRangeQueryBuilder());
            m_queryFactory.AddBuilder("DisjunctionMaxQuery", new DisjunctionMaxQueryBuilder(m_queryFactory));
            if (parser != null)
            {
                m_queryFactory.AddBuilder("UserQuery", new UserInputQueryBuilder(parser));
            }
            else
            {
                m_queryFactory.AddBuilder("UserQuery", new UserInputQueryBuilder(defaultField, analyzer));
            }
            m_queryFactory.AddBuilder("FilteredQuery", new FilteredQueryBuilder(m_filterFactory, m_queryFactory));
            m_queryFactory.AddBuilder("ConstantScoreQuery", new ConstantScoreQueryBuilder(m_filterFactory));

            m_filterFactory.AddBuilder("CachedFilter", new CachedFilterBuilder(m_queryFactory,
                m_filterFactory, maxNumCachedFilters));

            SpanQueryBuilderFactory sqof = new SpanQueryBuilderFactory();

            SpanNearBuilder snb = new SpanNearBuilder(sqof);
            sqof.AddBuilder("SpanNear", snb);
            m_queryFactory.AddBuilder("SpanNear", snb);

            BoostingTermBuilder btb = new BoostingTermBuilder();
            sqof.AddBuilder("BoostingTermQuery", btb);
            m_queryFactory.AddBuilder("BoostingTermQuery", btb);

            SpanTermBuilder snt = new SpanTermBuilder();
            sqof.AddBuilder("SpanTerm", snt);
            m_queryFactory.AddBuilder("SpanTerm", snt);

            SpanOrBuilder sot = new SpanOrBuilder(sqof);
            sqof.AddBuilder("SpanOr", sot);
            m_queryFactory.AddBuilder("SpanOr", sot);

            SpanOrTermsBuilder sots = new SpanOrTermsBuilder(analyzer);
            sqof.AddBuilder("SpanOrTerms", sots);
            m_queryFactory.AddBuilder("SpanOrTerms", sots);

            SpanFirstBuilder sft = new SpanFirstBuilder(sqof);
            sqof.AddBuilder("SpanFirst", sft);
            m_queryFactory.AddBuilder("SpanFirst", sft);

            SpanNotBuilder snot = new SpanNotBuilder(sqof);
            sqof.AddBuilder("SpanNot", snot);
            m_queryFactory.AddBuilder("SpanNot", snot);
        }

        public virtual Query Parse(Stream xmlStream)
        {
            return GetQuery(ParseXML(xmlStream).DocumentElement);
        }

        // LUCENENET specific overload for TextReader
        public virtual Query Parse(TextReader xmlTextReader)
        {
            return GetQuery(ParseXML(xmlTextReader).DocumentElement);
        }

        // LUCENENET specific overload for XmlReader
        public virtual Query Parse(XmlReader xmlReader)
        {
            return GetQuery(ParseXML(xmlReader).DocumentElement);
        }

        // LUCENENET specific overload for XmlDocument
        public virtual Query Parse(XmlDocument xmlDocument)
        {
            return GetQuery(xmlDocument.DocumentElement);
        }

        public virtual void AddQueryBuilder(string nodeName, IQueryBuilder builder)
        {
            m_queryFactory.AddBuilder(nodeName, builder);
        }

        public virtual void AddFilterBuilder(string nodeName, IFilterBuilder builder)
        {
            m_filterFactory.AddBuilder(nodeName, builder);
        }

        private static XmlDocument ParseXML(Stream pXmlFile)
        {
            XmlDocument doc = new XmlDocument();
            try
            {
                doc.Load(pXmlFile);
            }
            catch (Exception se)
            {
                throw new ParserException("Error parsing XML stream:" + se, se);
            }
            return doc;
        }

        // LUCENENET specific overload for TextReader
        private static XmlDocument ParseXML(TextReader pXmlFile)
        {
            XmlDocument doc = new XmlDocument();
            try
            {
                doc.Load(pXmlFile);
            }
            catch (Exception se)
            {
                throw new ParserException("Error parsing XML stream:" + se, se);
            }
            return doc;
        }

        // LUCENENET specific overload for XmlReader
        private static XmlDocument ParseXML(XmlReader pXmlFile)
        {
            XmlDocument doc = new XmlDocument();
            try
            {
                doc.Load(pXmlFile);
            }
            catch (Exception se)
            {
                throw new ParserException("Error parsing XML stream:" + se, se);
            }
            return doc;
        }

        public virtual Query GetQuery(XmlElement e)
        {
            return m_queryFactory.GetQuery(e);
        }
    }
}