using Lucene.Net.Support;
using System;
using System.Text;

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

    using BytesRef = Lucene.Net.Util.BytesRef;

    /// <summary>
    ///  A Term represents a word from text.  this is the unit of search.  It is
    ///  composed of two elements, the text of the word, as a string, and the name of
    ///  the field that the text occurred in.
    ///
    ///  Note that terms may represent more than words from text fields, but also
    ///  things like dates, email addresses, urls, etc.
    /// </summary>
#if FEATURE_SERIALIZABLE
    [Serializable]
#endif
    public sealed class Term : IComparable<Term>, IEquatable<Term> // LUCENENET specific - class implements IEquatable<T>
    {
        /// <summary>
        /// Constructs a Term with the given field and bytes.
        /// <p>Note that a null field or null bytes value results in undefined
        /// behavior for most Lucene APIs that accept a Term parameter.
        ///
        /// <p>WARNING: the provided BytesRef is not copied, but used directly.
        /// Therefore the bytes should not be modified after construction, for
        /// example, you should clone a copy by <seealso cref="BytesRef#deepCopyOf"/>
        /// rather than pass reused bytes from a TermsEnum.
        /// </summary>
        public Term(string fld, BytesRef bytes)
        {
            Field = fld;
            Bytes = bytes;
        }

        /// <summary>
        /// Constructs a Term with the given field and text.
        /// <p>Note that a null field or null text value results in undefined
        /// behavior for most Lucene APIs that accept a Term parameter.
        /// </summary>
        public Term(string fld, string text)
            : this(fld, new BytesRef(text))
        {
        }

        /// <summary>
        /// Constructs a Term with the given field and empty text.
        /// this serves two purposes: 1) reuse of a Term with the same field.
        /// 2) pattern for a query.
        /// </summary>
        /// <param name="fld"> field's name </param>
        public Term(string fld)
            : this(fld, new BytesRef())
        {
        }

        /// <summary>
        /// Returns the field of this term.   The field indicates
        ///  the part of a document which this term came from.
        /// </summary>
        public string Field { get; internal set; }

        /// <summary>
        /// Returns the text of this term.  In the case of words, this is simply the
        ///  text of the word.  In the case of dates and other types, this is an
        ///  encoding of the object as a string.
        /// </summary>
        public string Text()
        {
            return ToString(Bytes);
        }

        /// <summary>
        /// Returns human-readable form of the term text. If the term is not unicode,
        /// the raw bytes will be printed instead.
        /// </summary>
        public static string ToString(BytesRef termText)
        {
            // the term might not be text, but usually is. so we make a best effort
            Encoding decoder = new UTF8Encoding(false, true);
            try
            {
                return decoder.GetString(termText.Bytes, termText.Offset, termText.Length);
            }
            catch
            {
                return termText.ToString();
            }
        }

        /// <summary>
        /// Returns the bytes of this term.
        /// </summary>
        public BytesRef Bytes { get; internal set; }

        public override bool Equals(object obj)
        {
            Term t = obj as Term;
            return this.Equals(t);
        }

        public override int GetHashCode()
        {
            const int prime = 31;
            int result = 1;
            result = prime * result + ((Field == null) ? 0 : Field.GetHashCode());
            result = prime * result + ((Bytes == null) ? 0 : Bytes.GetHashCode());
            return result;
        }

        /// <summary>
        /// Compares two terms, returning a negative integer if this
        ///  term belongs before the argument, zero if this term is equal to the
        ///  argument, and a positive integer if this term belongs after the argument.
        ///
        ///  The ordering of terms is first by field, then by text.
        /// </summary>
        public int CompareTo(Term other)
        {
            int compare = Field.CompareToOrdinal(other.Field);
            if (compare == 0)
            {
                return Bytes.CompareTo(other.Bytes);
            }
            else
            {
                return compare;
            }
        }

        /// <summary>
        /// Resets the field and text of a Term.
        /// <p>WARNING: the provided BytesRef is not copied, but used directly.
        /// Therefore the bytes should not be modified after construction, for
        /// example, you should clone a copy rather than pass reused bytes from
        /// a TermsEnum.
        /// </summary>
        internal void Set(string fld, BytesRef bytes)
        {
            Field = fld;
            this.Bytes = bytes;
        }

        public bool Equals(Term other)
        {
            if (object.ReferenceEquals(null, other))
            {
                return object.ReferenceEquals(null, this);
            }
            if (object.ReferenceEquals(this, other))
            {
                return true;
            }

            if (this.GetType() != other.GetType())
            {
                return false;
            }

            if (string.Compare(this.Field, other.Field, StringComparison.Ordinal) != 0)
            {
                return false;
            }

            if (Bytes == null)
            {
                if (other.Bytes != null)
                {
                    return false;
                }
            }
            else if (!Bytes.Equals(other.Bytes))
            {
                return false;
            }

            return true;
        }

        public override string ToString()
        {
            return Field + ":" + Text();
        }
    }
}