/// <summary>
 /// Creates a new key record.
 /// </summary>
 /// <param name="name">The name.</param>
 /// <param name="recordClass">The record class.</param>
 /// <param name="timeToLive">The time-to-live.</param>
 /// <param name="flags">The flags.</param>
 /// <param name="protocol">The protocol.</param>
 /// <param name="algorithm">The algorithm.</param>
 protected KeyRecordBase(string name, RecordClass recordClass, int timeToLive, ushort flags, ProtocolType protocol, DnsSecAlgorithm algorithm)
     : base(name, RecordType.Key, recordClass, timeToLive)
 {
     this.Flags = flags;
     this.Protocol = protocol;
     this.Algorithm = algorithm;
 }

 public void WriteQuestion(Name name, RecordType qtype, RecordClass qclass = RecordClass.Internet)
 {
     WriteName(name);
     WriteUInt16((ushort)qtype);
     WriteUInt16((ushort)qclass);
     _questionCount++;
 }

		/// <summary>
		///   Creates a new instance of the DiffieHellmanKeyRecord class
		/// </summary>
		/// <param name="name"> Name of the record </param>
		/// <param name="recordClass"> Class of the record </param>
		/// <param name="timeToLive"> Seconds the record should be cached at most </param>
		/// <param name="flags"> Flags of the key </param>
		/// <param name="protocol"> Protocol for which the key is used </param>
		/// <param name="prime"> Binary data of the prime of the key </param>
		/// <param name="generator"> Binary data of the generator of the key </param>
		/// <param name="publicValue"> Binary data of the public value </param>
		public DiffieHellmanKeyRecord(string name, RecordClass recordClass, int timeToLive, ushort flags, ProtocolType protocol, byte[] prime, byte[] generator, byte[] publicValue)
			: base(name, recordClass, timeToLive, flags, protocol, DnsSecAlgorithm.DiffieHellman)
		{
			Prime = prime ?? new byte[] { };
			Generator = generator ?? new byte[] { };
			PublicValue = publicValue ?? new byte[] { };
		}

        public ResourceRecord(DnsReader br)
        {
            _domain = br.ReadDomain();
            _qtype = (RecordType)br.ReadInt16();
            _qclass = (RecordClass)br.ReadInt16();
            _ttl = br.ReadInt32();

            int recordLength = br.ReadInt16();
            if (recordLength != 0)
            {
                switch (_qtype)
                {
                    case RecordType.A:     _record = new ARecord(br);      break;
                    case RecordType.CNAME: _record = new CNAMERecord(br);  break;
                    case RecordType.MX:    _record = new MXRecord(br);     break;
                    case RecordType.NS:    _record = new NSRecord(br);     break;
                    case RecordType.SOA:   _record = new SOARecord(br);    break;
                    case RecordType.TXT:   _record = new TXTRecord(br);    break;
                    case RecordType.PTR:   _record = new PTRERecord(br);	break;

                    // NetBIOS related records
                    case RecordType.NB:    _record = new NBRecord(br);     break;

                    default:
                        br += recordLength;
                        break;
                }
            }
        }

 private DnsResponse(ushort messageId, DnsName queryName, RecordType queryType, RecordClass queryClass)
 {
     this.MessageId = messageId;
     this.QueryName = queryName;
     this.QueryType = queryType;
     this.QueryClass = queryClass;
 }

 public LogRecord(String message, RecordClass recordClass, TimeSpan? runningTime, DateTime timeStamp)
 {
     this.message = message;
       this.recordClass = recordClass;
       this.runningTime = runningTime;
       this.timeStamp = timeStamp;
 }

		protected DnsRecordBase(string name, RecordType recordType, RecordClass recordClass, int timeToLive)
		{
			Name = name ?? String.Empty;
			RecordType = recordType;
			RecordClass = recordClass;
			TimeToLive = timeToLive;
		}

 internal ResourceRecord(string name, RecordType type, RecordClass rClass, DateTime expiry)
 {
     _name = name;
     _type = type;
     _class = rClass;
     _expiry = expiry;
 }

		/// <summary>
		///   Creates a new instance of the CDsRecord class
		/// </summary>
		/// <param name="name"> Name of the record </param>
		/// <param name="recordClass"> Class of the record </param>
		/// <param name="timeToLive"> Seconds the record should be cached at most </param>
		/// <param name="keyTag"> Key tag </param>
		/// <param name="algorithm"> Algorithm used </param>
		/// <param name="digestType"> Type of the digest </param>
		/// <param name="digest"> Binary data of the digest </param>
		public CDsRecord(DomainName name, RecordClass recordClass, int timeToLive, ushort keyTag, DnsSecAlgorithm algorithm, DnsSecDigestType digestType, byte[] digest)
			: base(name, RecordType.Ds, recordClass, timeToLive)
		{
			KeyTag = keyTag;
			Algorithm = algorithm;
			DigestType = digestType;
			Digest = digest ?? new byte[] { };
		}

 /// <summary>
 /// Creates a new instance of the DsRecord class.
 /// </summary>
 /// <param name="name">Name of the record.</param>
 /// <param name="recordClass">Class of the record.</param>
 /// <param name="timeToLive">Seconds the record should be cached at most.</param>
 /// <param name="keyTag">Key tag.</param>
 /// <param name="algorithm">Algorithm used.</param>
 /// <param name="digestType">Type of the digest.</param>
 /// <param name="digest">Binary data of the digest.</param>
 public DsRecord(string name, RecordClass recordClass, int timeToLive, ushort keyTag, DnsSecAlgorithm algorithm, DnsSecDigestType digestType, byte[] digest)
     : base(name, RecordType.Ds, recordClass, timeToLive)
 {
     this.KeyTag = keyTag;
     this.Algorithm = algorithm;
     this.DigestType = digestType;
     this.Digest = digest ?? new byte[] { };
 }

		public NSec3ParamRecord(string name, RecordClass recordClass, int timeToLive, DnsSecAlgorithm hashAlgorithm, byte flags, ushort iterations, byte[] salt)
			: base(name, RecordType.NSec3Param, recordClass, timeToLive)
		{
			HashAlgorithm = hashAlgorithm;
			Flags = flags;
			Iterations = iterations;
			Salt = salt ?? new byte[] { };
		}

		public DnsKeyRecord(string name, RecordClass recordClass, int timeToLive, ushort flags, byte protocol, DnsSecAlgorithm algorithm, byte[] publicKey)
			: base(name, RecordType.DnsKey, recordClass, timeToLive)
		{
			Flags = flags;
			Protocol = protocol;
			Algorithm = algorithm;
			PublicKey = publicKey ?? new byte[] { };
		}

 protected DnsMessageBase(ushort messageId, DnsName queryName, RecordType queryType, RecordClass queryClass)
     : this()
 {
     this.MessageId = messageId;
     this.QueryCount = 1;
     this.QueryName = queryName;
     this.QueryType = queryType;
     this.QueryClass = queryClass;
 }

 public ResourceRecord(Domain domain, byte[] data, RecordType type,
         RecordClass klass = RecordClass.IN, TimeSpan ttl = default(TimeSpan))
 {
     this.domain = domain;
     this.type = type;
     this.klass = klass;
     this.ttl = ttl;
     this.data = data;
 }

        internal IP4AddressRecord(string name, RecordType type, RecordClass rClass, DateTime expiry, PacketReader reader)
            : base(name, type, rClass, expiry)
        {
            ushort dataLen = reader.ReadUShort();
            int pos = reader.Position;

            _address = new IPAddress(reader.ReadBytes(dataLen));

            reader.Position = pos + dataLen;
        }

        internal PointerRecord(string name, RecordType type, RecordClass rClass, DateTime expiry, PacketReader reader)
            : base(name, type, rClass, expiry)
        {
            ushort dataLen = reader.ReadUShort();
            int pos = reader.Position;

            _targetName = reader.ReadName();

            reader.Position = pos + dataLen;
        }

 static DnsMessage DnsResolve(string name, RecordType recordType, RecordClass recordClass)
 {
     DnsClient dnsClient;
     if (WindowsNameServicesManager.NameServerHookMethod != WindowsNameServicesManager.NameServerHookMethodType.ChangeNS)
         dnsClient = DnsClient.Default;
     else
     {
         dnsClient = GetNonDefaultDnsClient();
     }
     return dnsClient.Resolve(name, recordType, recordClass);
 }

        protected ResourceRecordBase(DnsName name, RecordType recordType, RecordClass recordClass, uint timeToLive)
        {
            if (name == null)
            {
                throw new ArgumentNullException(nameof(name));
            }

            this.Name = name;
            this.RecordType = recordType;
            this.RecordClass = recordClass;
            this.TimeToLive = timeToLive;
        }

		/// <summary>
		///   Queries a dns server for specified records.
		/// </summary>
		/// <param name="name"> Domain, that should be queried </param>
		/// <param name="recordType"> Type the should be queried </param>
		/// <param name="recordClass"> Class the should be queried </param>
		/// <returns> The complete response of the dns server </returns>
		public DnsMessage Resolve(string name, RecordType recordType, RecordClass recordClass)
		{
			if (String.IsNullOrEmpty(name))
			{
				throw new ArgumentException("Name must be provided", "name");
			}

			DnsMessage message = new DnsMessage() { IsQuery = true, OperationCode = OperationCode.Query, IsRecursionDesired = true, IsEDnsEnabled = true };
			message.Questions.Add(new DnsQuestion(name, recordType, recordClass));

			return SendMessage(message);
		}

 /// <summary>
 /// Creates a new instance of the SigRecord class.
 /// </summary>
 /// <param name="name">Name of the record.</param>
 /// <param name="recordClass">Class of the record.</param>
 /// <param name="timeToLive">Seconds the record should be cached at most.</param>
 /// <param name="typeCovered"><see cref="RecordType">Record type</see> that is covered by this record.</param>
 /// <param name="algorithm"><see cref="DnsSecAlgorithm">Algorithm</see> that is used for signature.</param>
 /// <param name="labels">Label count of original record that is covered by this record.</param>
 /// <param name="originalTimeToLive">Original time to live value of original record that is covered by this record.</param>
 /// <param name="signatureExpiration">Signature is valid until this date.</param>
 /// <param name="signatureInception">Signature is valid from this date.</param>
 /// <param name="keyTag">Key tag.</param>
 /// <param name="signersName">Domain name of generator of the signature.</param>
 /// <param name="signature">Binary data of the signature.</param>
 public SigRecord(string name, RecordClass recordClass, int timeToLive, RecordType typeCovered, DnsSecAlgorithm algorithm, byte labels, int originalTimeToLive, DateTime signatureExpiration, DateTime signatureInception, ushort keyTag, string signersName, byte[] signature)
     : base(name, RecordType.Sig, recordClass, timeToLive)
 {
     this.TypeCovered = typeCovered;
     this.Algorithm = algorithm;
     this.Labels = labels;
     this.OriginalTimeToLive = originalTimeToLive;
     this.SignatureExpiration = signatureExpiration;
     this.SignatureInception = signatureInception;
     this.KeyTag = keyTag;
     this.SignersName = signersName ?? String.Empty;
     this.Signature = signature ?? new byte[] { };
 }