// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using System;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Runtime.Serialization;

namespace System.Xml
{
    internal enum StringHandleConstStringType
    {
        Type = 0,
        Root = 1,
        Item = 2
    }

    internal sealed class StringHandle : IEquatable<StringHandle>
    {
        private readonly XmlBufferReader _bufferReader;
        private StringHandleType _type;
        private int _key;
        private int _offset;
        private int _length;
        private static readonly string[] s_constStrings = {
                                            "type",
                                            "root",
                                            "item"
                                       };

        public StringHandle(XmlBufferReader bufferReader)
        {
            _bufferReader = bufferReader;
            SetValue(0, 0);
        }

        public void SetValue(int offset, int length)
        {
            _type = StringHandleType.UTF8;
            _offset = offset;
            _length = length;
        }

        public void SetConstantValue(StringHandleConstStringType constStringType)
        {
            _type = StringHandleType.ConstString;
            _key = (int)constStringType;
        }

        public void SetValue(int offset, int length, bool escaped)
        {
            _type = (escaped ? StringHandleType.EscapedUTF8 : StringHandleType.UTF8);
            _offset = offset;
            _length = length;
        }

        public void SetValue(int key)
        {
            _type = StringHandleType.Dictionary;
            _key = key;
        }

        public void SetValue(StringHandle value)
        {
            _type = value._type;
            _key = value._key;
            _offset = value._offset;
            _length = value._length;
        }

        public bool IsEmpty
        {
            get
            {
                if (_type == StringHandleType.UTF8)
                    return _length == 0;
                return Equals2(string.Empty);
            }
        }

        public bool IsXmlns
        {
            get
            {
                if (_type == StringHandleType.UTF8)
                {
                    if (_length != 5)
                        return false;
                    byte[] buffer = _bufferReader.Buffer;
                    int offset = _offset;
                    return buffer[offset + 0] == 'x' &&
                           buffer[offset + 1] == 'm' &&
                           buffer[offset + 2] == 'l' &&
                           buffer[offset + 3] == 'n' &&
                           buffer[offset + 4] == 's';
                }
                return Equals2("xmlns");
            }
        }

        public void ToPrefixHandle(PrefixHandle prefix)
        {
            Debug.Assert(_type == StringHandleType.UTF8);
            prefix.SetValue(_offset, _length);
        }

        public string GetString(XmlNameTable nameTable)
        {
            StringHandleType type = _type;
            if (type == StringHandleType.UTF8)
                return _bufferReader.GetString(_offset, _length, nameTable);
            if (type == StringHandleType.Dictionary)
                return nameTable.Add(_bufferReader.GetDictionaryString(_key).Value);
            if (type == StringHandleType.ConstString)
                return nameTable.Add(s_constStrings[_key]);
            // If none of the above, must be StringHandleType.EscapedUTF8
            Debug.Assert(type == StringHandleType.EscapedUTF8, "Should be EscapedUTF8");
            return _bufferReader.GetEscapedString(_offset, _length, nameTable);
        }

        public string GetString()
        {
            StringHandleType type = _type;
            if (type == StringHandleType.UTF8)
                return _bufferReader.GetString(_offset, _length);
            if (type == StringHandleType.Dictionary)
                return _bufferReader.GetDictionaryString(_key).Value;
            if (type == StringHandleType.ConstString)
                return s_constStrings[_key];
            // If none of the above, must be StringHandleType.EscapedUTF8
            Debug.Assert(type == StringHandleType.EscapedUTF8, "Should be EscapedUTF8");
            return _bufferReader.GetEscapedString(_offset, _length);
        }

        public byte[] GetString(out int offset, out int length)
        {
            StringHandleType type = _type;
            if (type == StringHandleType.UTF8)
            {
                offset = _offset;
                length = _length;
                return _bufferReader.Buffer;
            }
            if (type == StringHandleType.Dictionary)
            {
                byte[] buffer = _bufferReader.GetDictionaryString(_key).ToUTF8();
                offset = 0;
                length = buffer.Length;
                return buffer;
            }
            if (type == StringHandleType.ConstString)
            {
                byte[] buffer = XmlConverter.ToBytes(s_constStrings[_key]);
                offset = 0;
                length = buffer.Length;
                return buffer;
            }
            else
            {
                Debug.Assert(type == StringHandleType.EscapedUTF8);
                byte[] buffer = XmlConverter.ToBytes(_bufferReader.GetEscapedString(_offset, _length));
                offset = 0;
                length = buffer.Length;
                return buffer;
            }
        }

        public bool TryGetDictionaryString([NotNullWhen(true)] out XmlDictionaryString? value)
        {
            if (_type == StringHandleType.Dictionary)
            {
                value = _bufferReader.GetDictionaryString(_key);
                return true;
            }
            else if (IsEmpty)
            {
                value = XmlDictionaryString.Empty;
                return true;
            }

            value = null;
            return false;
        }

        public override string ToString()
        {
            return GetString();
        }

        private bool Equals2(int key2, XmlBufferReader bufferReader2)
        {
            StringHandleType type = _type;
            if (type == StringHandleType.Dictionary)
                return _bufferReader.Equals2(_key, key2, bufferReader2);
            if (type == StringHandleType.UTF8)
                return _bufferReader.Equals2(_offset, _length, bufferReader2.GetDictionaryString(key2).Value);
            Debug.Assert(type == StringHandleType.EscapedUTF8 || type == StringHandleType.ConstString);
            return GetString() == _bufferReader.GetDictionaryString(key2).Value;
        }

        private bool Equals2(XmlDictionaryString xmlString2)
        {
            StringHandleType type = _type;
            if (type == StringHandleType.Dictionary)
                return _bufferReader.Equals2(_key, xmlString2);
            if (type == StringHandleType.UTF8)
                return _bufferReader.Equals2(_offset, _length, xmlString2.ToUTF8());
            Debug.Assert(type == StringHandleType.EscapedUTF8 || type == StringHandleType.ConstString);
            return GetString() == xmlString2.Value;
        }

        private bool Equals2(string s2)
        {
            StringHandleType type = _type;
            if (type == StringHandleType.Dictionary)
                return _bufferReader.GetDictionaryString(_key).Value == s2;
            if (type == StringHandleType.UTF8)
                return _bufferReader.Equals2(_offset, _length, s2);
            Debug.Assert(type == StringHandleType.EscapedUTF8 || type == StringHandleType.ConstString);
            return GetString() == s2;
        }

        private bool Equals2(int offset2, int length2, XmlBufferReader bufferReader2)
        {
            StringHandleType type = _type;
            if (type == StringHandleType.Dictionary)
                return bufferReader2.Equals2(offset2, length2, _bufferReader.GetDictionaryString(_key).Value);
            if (type == StringHandleType.UTF8)
                return _bufferReader.Equals2(_offset, _length, bufferReader2, offset2, length2);
            Debug.Assert(type == StringHandleType.EscapedUTF8 || type == StringHandleType.ConstString);
            return GetString() == _bufferReader.GetString(offset2, length2);
        }

        public bool Equals([NotNullWhen(true)] StringHandle? other)
        {
            if (other is null)
                return false;
            StringHandleType type = other._type;
            if (type == StringHandleType.Dictionary)
                return Equals2(other._key, other._bufferReader);
            if (type == StringHandleType.UTF8)
                return Equals2(other._offset, other._length, other._bufferReader);
            Debug.Assert(type == StringHandleType.EscapedUTF8 || type == StringHandleType.ConstString);
            return Equals2(other.GetString());
        }

        public static bool operator ==(StringHandle s1, XmlDictionaryString xmlString2)
        {
            return s1.Equals2(xmlString2);
        }

        public static bool operator !=(StringHandle s1, XmlDictionaryString xmlString2)
        {
            return !s1.Equals2(xmlString2);
        }

        public static bool operator ==(StringHandle s1, string s2)
        {
            return s1.Equals2(s2);
        }

        public static bool operator !=(StringHandle s1, string s2)
        {
            return !s1.Equals2(s2);
        }

        public static bool operator ==(StringHandle s1, StringHandle s2)
        {
            return s1.Equals(s2);
        }

        public static bool operator !=(StringHandle s1, StringHandle s2)
        {
            return !s1.Equals(s2);
        }

        public int CompareTo(StringHandle that)
        {
            if (_type == StringHandleType.UTF8 && that._type == StringHandleType.UTF8)
                return _bufferReader.Compare(_offset, _length, that._offset, that._length);
            else
                return string.Compare(this.GetString(), that.GetString(), StringComparison.Ordinal);
        }

        public override bool Equals([NotNullWhen(true)] object? obj)
        {
            return Equals(obj as StringHandle);
        }

        public override int GetHashCode()
        {
            return GetString().GetHashCode();
        }

        private enum StringHandleType
        {
            Dictionary,
            UTF8,
            EscapedUTF8,
            ConstString
        }
    }
}