root/apps/outlook/branches/1.6/DotTelSystem/Lookup/LookupResult.cs @ 646

///<summary>
/// Author: Ben Dowling & Nick Brunwin
///------------------------
///Copyright (c) 2008, Telnic Ltd.
///
///All rights reserved.
///
///Redistribution and use in source and binary forms, with or 
///without modification, are permitted provided that the following 
///conditions are met:
///
///*    Redistributions of source code must retain the above 
///     copyright notice, this list of conditions and the 
///     following disclaimer. 
///*    Redistributions in binary form must reproduce the above 
///     copyright notice, this list of conditions and the following
///     disclaimer in the documentation and/or other materials 
///     provided with the distribution. 
///*    Neither the name of the Telnic Ltd. nor the names of its 
///     contributors may be used to endorse or promote products 
///     derived from this software without specific prior written
///     permission. 
///
///THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
///CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
///INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
///MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
///DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 
///CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
///SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
///LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
///USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 
///AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
///LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
///IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
///THE POSSIBILITY OF SUCH DAMAGE.
///--------------------------
///</summary>
using System;
using org.telnic.outlook.dns;
using System.Xml;
using org.telnic.outlook.util;
using System.Collections;
using System.Collections.Generic;
using org.telnic.outlook.dns.records;
using org.telnic.outlook.dns.records.txt;
using org.telnic.outlook.uri;
using System.Text;
using org.telnic.outlook.prefs;

namespace org.telnic.outlook.lookup
{

    /// <summary> The Class LookupResult.</summary>
    [Serializable]
    public class LookupResult
    {
        /// <summary> The Constant ONE_MONTH.</summary>
        private const long ONE_MONTH = 60 * 60 * 24 * 30;

        /// <summary> The telname.</summary>
        private string telname;

        private string publicTelname;

        /// <summary> The naptr records.</summary>
        private System.Collections.ArrayList naptrRecords;
        /// <summary> The status of the naptr lookup.</summary>
        private LookupWorker.LookupStatus naptrStatus;

        public LookupWorker.LookupStatus NaptrStatus
        {
            set
            {
                naptrStatus = value;
            }
            get
            {
                return naptrStatus;
            }
        }

        /// <summary> The txt records.</summary>
        private System.Collections.ArrayList locRecords;
        /// <summary> The status of the txt lookup.</summary>
        private LookupWorker.LookupStatus locStatus;

        public LookupWorker.LookupStatus LocStatus
        {
            set
            {
                locStatus = value;
            }
            get
            {
                return locStatus;
            }
        }

        /// <summary> The txt records.</summary>
        private System.Collections.ArrayList txtRecords;
        /// <summary> The status of the txt lookup.</summary>
        private LookupWorker.LookupStatus txtStatus;

        public LookupWorker.LookupStatus TxtStatus
        {
            set
            {
                txtStatus = value;
            }
            get
            {
                return txtStatus;
            }
        }

        /// <summary> The version records.</summary>
        private System.Collections.ArrayList versionRecords;
        /// <summary> The status of the txt lookup.</summary>
        private LookupWorker.LookupStatus versionStatus;

        public LookupWorker.LookupStatus VersionStatus
        {
            set
            {
                versionStatus = value;
            }
            get
            {
                return versionStatus;
            }
        }

        /// <summary> The txt records.</summary>
        private System.Collections.ArrayList nInfoRecords;
        /// <summary> The status of the txt lookup.</summary>
        private LookupWorker.LookupStatus nInfoStatus;

        public LookupWorker.LookupStatus NInfoStatus
        {
            set
            {
                nInfoStatus = value;
            }
            get
            {
                return nInfoStatus;
            }
        }

        /// <summary> The keyword records.</summary>
        private System.Collections.ArrayList keywordRecords;
        /// <summary> The status of the keyword lookup.</summary>
        private LookupWorker.LookupStatus keywordStatus;

        public LookupWorker.LookupStatus KeywordStatus
        {
            set
            {
                keywordStatus = value;
            }
            get
            {
                return keywordStatus;
            }
        }

        /// <summary> The long label records.</summary>
        private System.Collections.ArrayList longLabelRecords;


        /// <summary>
        /// Check for equality based on matching resource records
        /// don't compare TTL etc
        /// </summary>
        /// <param name="lr">The LookupResult to compare it to</param>
        /// <returns>True if the results contain the same records</returns>
        public bool Equals(LookupResult lr)
        {
            if (lr == null)
            {
                // return false if we got a successful lookup
                if (naptrStatus == LookupWorker.LookupStatus.Ok && txtStatus == LookupWorker.LookupStatus.Ok 
                    && locStatus == LookupWorker.LookupStatus.Ok && nInfoStatus == LookupWorker.LookupStatus.Ok
                    && keywordStatus == LookupWorker.LookupStatus.Ok && versionStatus == LookupWorker.LookupStatus.Ok)
                {
                    return false;
                }
                // if we didn't get a successful lookup then we wouldn't have cached the result,
                // so assume that there has been no change
                return true;
            }


            // check if we've got the same telname            
            if (telname != lr.telname) return false;

            // check if we've got the same dds           
            if (ddsValue != lr.ddsValue) return false;

            // check if we've got the pddxVersion          
            if (pddxVersion != lr.pddxVersion) return false;

            // if neither of us have any records then we must be the same (empty)
            if (!HasResults() && !lr.HasResults()) return true;

            // check that we have the same number of records
            try
            {
                if (naptrRecords.Count != lr.NaptrRecords.Count) return false;
                if (txtRecords.Count != lr.TxtRecords.Count) return false;
                if (locRecords.Count != lr.LocRecords.Count) return false;
                if (nInfoRecords.Count != lr.NInfoRecords.Count) return false;
                if (keywordRecords.Count != lr.KeywordRecords.Count) return false;
                if (longLabelRecords.Count != lr.longLabelRecords.Count) return false;
                if (versionRecords.Count != lr.versionRecords.Count) return false;
            }
            catch (Exception)
            {
                // one of us doesn't have any records, so we can't be the same
                return false;
            }

            if (!this.CompareNaptrLists(naptrRecords, lr.naptrRecords))
            {
                return false;
            }
            if (!this.CompareNaptrLists(lr.naptrRecords, naptrRecords))
            {
                return false;
            }

            if (!this.CompareTxtRecordLists(txtRecords, lr.txtRecords))
            {
                return false;
            }
            if (!this.CompareTxtRecordLists(lr.txtRecords, txtRecords))
            {
                return false;
            }

            if (!this.CompareNInfoRecordLists(nInfoRecords, lr.NInfoRecords))
            {
                return false;
            }
            if (!this.CompareNInfoRecordLists(lr.NInfoRecords, nInfoRecords))
            {
                return false;
            }

            if (!this.CompareLocRecordLists(locRecords, lr.locRecords))
            {
                return false;
            }
            if (!this.CompareLocRecordLists(lr.locRecords, locRecords))
            {
                return false;
            }

            if (!this.CompareKeywordRecordLists(keywordRecords, lr.keywordRecords))
            {
                return false;
            }
            if (!this.CompareKeywordRecordLists(lr.keywordRecords, keywordRecords))
            {
                return false;
            }

            if (!this.CompareLongLabelRecordLists(longLabelRecords, lr.longLabelRecords))
            {
                return false;
            }
            if (!this.CompareLongLabelRecordLists(lr.longLabelRecords, longLabelRecords))
            {
                return false;
            }

            if (!this.CompareTxtRecordLists(versionRecords, lr.versionRecords))
            {
                return false;
            }
            if (!this.CompareTxtRecordLists(lr.versionRecords, versionRecords))
            {
                return false;
            }

            return true;
        }

        private bool CompareNaptrLists(ArrayList first, ArrayList second)
        {
            for (int i = 0; i < first.Count; i++)
            {
                bool notfound = true;
                DNSTelnameNaptrResourceRecord r1 = (DNSTelnameNaptrResourceRecord)first[i];
                for (int j = 0; j < second.Count; j++)
                {
                    DNSTelnameNaptrResourceRecord r2 = (DNSTelnameNaptrResourceRecord)second[j];
                    // make sure both are the same type
                    // compare replaceStr if they're NTN
                    // compare URIs if they are terminal
                    if (r1.NonTerminal == r2.NonTerminal)
                    {
                        if ((r1.NonTerminal && r1.replaceStr == r2.replaceStr) 
                                                            || (r1.Uri == r2.Uri && r1.ServiceStr == r2.ServiceStr))
                        {
                            notfound = false;
                            break;
                        }
                    }
                }
                if (notfound)
                {
                    return false;
                }
            }
            return true;
        }

        private bool CompareTxtRecordLists(ArrayList first, ArrayList second)
        {
            if (first.Count == second.Count)
            {
                foreach(DNSTxtResourceRecord r1 in first)
                {
                    bool found = false;
                    foreach (DNSTxtResourceRecord r2 in second)
                    {
                        if (r1.Equals(r2))
                        {
                            found = true;
                        }
                    }
                    if (!found)
                    {
                        return false;
                    }
                }
                return true;
            }
            return false;
        }

        private bool CompareNInfoRecordLists(ArrayList first, ArrayList second)
        {
            if (first.Count == second.Count)
            {
                foreach (DNSNInfoResourceRecord r1 in first)
                {
                    bool found = false;
                    foreach (DNSNInfoResourceRecord r2 in second)
                    {
                        if (r1.Equals(r2))
                        {
                            found = true;
                        }
                    }
                    if (!found)
                    {
                        return false;
                    }
                }
                return true;
            }
            return false;
        }

        private bool CompareKeywordRecordLists(ArrayList first, ArrayList second)
        {
            if (first.Count == second.Count)
            {
                foreach (DNSTxtResourceRecord r1 in first)
                {
                    bool found = false;
                    foreach (DNSTxtResourceRecord r2 in second)
                    {
                        if (r1.Equals(r2))
                        {
                            found = true;
                        }
                    }
                    if (!found)
                    {
                        return false;
                    }
                }
                return true;
            }
            return false;
        }

        private bool CompareLongLabelRecordLists(ArrayList first, ArrayList second)
        {
            if (first.Count == second.Count)
            {
                foreach (DNSTxtResourceRecord r1 in first)
                {
                    bool found = false;
                    foreach (DNSTxtResourceRecord r2 in second)
                    {
                        if (r1.Equals(r2))
                        {
                            found = true;
                        }
                    }
                    if (!found)
                    {
                        return false;
                    }
                }
                return true;
            }
            return false;
        }

        private bool CompareLocRecordLists(ArrayList first, ArrayList second)
        {
            for (int i = 0; i < first.Count; i++)
            {
                bool notfound = true;
                DNSLocResourceRecord r1 = (DNSLocResourceRecord)first[i];
                for (int j = 0; j < second.Count; j++)
                {
                    DNSLocResourceRecord r2 = (DNSLocResourceRecord)second[j];
                    if (r1.Latitude == r2.Latitude && r1.Longitude == r2.Longitude)
                    {
                        notfound = false;
                        break;
                    }
                }
                if (notfound)
                {
                    return false;
                }
            }
            return true;
        }

        /// <summary>
        /// returns true if there is at least one actual result (TXT or NAPTR or LOC)
        /// </summary>
        /// <returns>true if there is at least one actual result (TXT or NAPTR or LOC)</returns>
        public bool HasResults()
        {
            if (naptrRecords != null && naptrRecords.Count > 0) return true;
            if (txtRecords != null && txtRecords.Count > 0) return true;
            if (locRecords != null && locRecords.Count > 0) return true;
            if (nInfoRecords != null && nInfoRecords.Count > 0) return true;
            if (keywordRecords != null && keywordRecords.Count > 0) return true;
            if (longLabelRecords != null && longLabelRecords.Count > 0) return true;
            //Version Records deliberately not included

            return false;
        }

        /// <summary> stores the time (in seconds) that this record was last updated</summary>
        private long updated = 0;

        // stores how long this record is valid for in seconds
        // record expires at (updated + ttl) seconds
        /// <summary> The ttl.</summary>
        private long ttl = LookupResult.ONE_MONTH;


        /// <summary> The Constructor.
        /// 
        /// </summary>
        /// <param name="telname">the telname
        /// </param>
        public LookupResult(string telname, string publicTelname)
        {
            this.telname = telname;
            this.publicTelname = publicTelname;
        }


        // returns how many seconds this lookup is valid for
        /// <summary> Valid for.
        /// 
        /// </summary>
        /// <returns> the long
        /// </returns>
        public virtual long validFor()
        {
            // none of the results should be null, so if they are set ttl to 0
            if (txtRecords == null && naptrRecords == null && locRecords == null && nInfoRecords == null && keywordRecords == null && versionRecords == null)
            {
                ttl = 0;
            }   // if we don't have any actual results we can't work out a ttl, so set to 0
            else if (txtRecords.Count == 0 && naptrRecords.Count == 0 && locRecords.Count == 0 && nInfoRecords.Count == 0 && keywordRecords.Count == 0 && versionRecords.Count == 0)
            {
                ttl = 0;
            }
            return (updated + ttl) - ((System.DateTime.Now.Ticks - 621355968000000000) / 10000 / 1000);
        }

        /// <summary> Gets the naptr records.
        /// 
        /// </summary>
        /// <returns> the naptr records
        /// </returns>
        /// <summary> Sets the naptr records. If there are any long labels matching a naptr it updates it's long label field
        /// 
        /// </summary>
        /// <param name="naptrRecords">the naptr records
        /// </param>
        virtual public System.Collections.ArrayList NaptrRecords
        {
            get
            {
                lock (this)
                {
                    return naptrRecords;
                }
            }

            set
            {
                lock (this)
                {
                    this.naptrRecords = value;
                    //naptrRecords.Sort();
                    updated = (System.DateTime.Now.Ticks - 621355968000000000) / 10000 / 1000;
                    setMinTtl(this.naptrRecords);
                    if (!(this.longLabelRecords == null))
                    {
                        foreach (DNSTelnameNaptrResourceRecord naptr in this.naptrRecords)
                        {
                            foreach (DNSLongLabelTxtResourceRecord label in this.longLabelRecords)
                            {
                                if ((naptr.Order == label.Order) && (naptr.Preference == label.Priority))
                                {
                                    Logger.Log(Logger.Section.Lookups, "Long label matched " + label.TxtStr);  
                                    naptr.LongLabels = label.LongLabels;
                                }
                            }
                        }
                    }
                }
            }

        }

        virtual public System.Collections.ArrayList LocRecords
        {
            get
            {
                lock (this)
                {
                    return locRecords;
                }
            }

            set
            {
                lock (this)
                {
                    this.locRecords = value;
                    updated = (System.DateTime.Now.Ticks - 621355968000000000) / 10000 / 1000;
                    setMinTtl(this.locRecords);
                }
            }
        }

        virtual public System.Collections.ArrayList NInfoRecords
        {
            get
            {
                lock (this)
                {
                    return this.nInfoRecords;
                }
            }

            set
            {
                lock (this)
                {
                    this.nInfoRecords = value;
                    this.updated = (System.DateTime.Now.Ticks - 621355968000000000) / 10000 / 1000;
                    this.setMinTtl(this.nInfoRecords);
                }
            }
        }

        /// <summary>
        /// Checks for existing Naptrs and tries to match them to update their longLabel field
        /// </summary>
        virtual public System.Collections.ArrayList LongLabelRecords
        {
            get
            {
                lock (this)
                {
                    return this.longLabelRecords;
                }
            }

            set
            {
                lock (this)
                {
                    this.longLabelRecords = value;
                    //naptrRecords.Sort();
                    this.updated = (System.DateTime.Now.Ticks - 621355968000000000) / 10000 / 1000;
                    this.setMinTtl(this.longLabelRecords);

                    if (!(this.naptrRecords == null))
                    {
                        foreach (DNSTelnameNaptrResourceRecord naptr in this.naptrRecords)
                        {
                            foreach (DNSLongLabelTxtResourceRecord label in this.longLabelRecords)
                            {
                                if ((naptr.Order == label.Order) && (naptr.Preference == label.Priority))
                                {
                                    Logger.Log(Logger.Section.Lookups, "Long label matched " + label.TxtStr);
                                    naptr.LongLabels = label.LongLabels;
                                }
                            }
                        }
                    }
                }
            }
        }



        /// <summary> Gets the txt records.
        /// 
        /// </summary>
        /// <returns> the txt records
        /// </returns>
        /// <summary> Sets the txt records. 
        /// Removes and process service messages. Removes keywords. Removes long labels and adds them to their own list.
        /// </summary>
        /// <param name="txtRecords">the txt records
        /// </param>
        virtual public System.Collections.ArrayList TxtRecords
        {
            get
            {
                lock (this)
                {
                    return txtRecords;
                }
            }

            set
            {
                lock (this)
                {
                    if (this.txtRecords == null)
                    {
                        this.txtRecords = value;
                    }
                    else
                    {
                        this.txtRecords.AddRange(value);
                    }
                    Logger.Log(Logger.Section.Lookups, this.txtRecords.Count + " txt entries found.");
                    updated = (System.DateTime.Now.Ticks - 621355968000000000) / 10000 / 1000;
                    setMinTtl(this.txtRecords);
                    //interpret understood service messages
                    List<DNSTxtResourceRecord> toBeRemoved = new List<DNSTxtResourceRecord>();
                    ArrayList addLongLabels = new ArrayList();
                    this.txtRecords.Reverse();
                    foreach (DNSTxtResourceRecord txtRecord in this.txtRecords)
                    {
                        if (typeof(DNSTxtServiceMessageResourceRecord).IsInstanceOfType(txtRecord))
                        {
                            ((DNSTxtServiceMessageResourceRecord)txtRecord).Process(this);
                            toBeRemoved.Add((DNSTxtResourceRecord)txtRecord);
                        }
                        if (typeof(DNSLongLabelTxtResourceRecord).IsInstanceOfType(txtRecord))
                        {
                            addLongLabels.Add((DNSLongLabelTxtResourceRecord)txtRecord);
                            toBeRemoved.Add((DNSTxtResourceRecord)txtRecord);
                        }
                        if (typeof(DNSStructuredKeywordsTxtResourceRecord).IsInstanceOfType(txtRecord))
                        {
                            toBeRemoved.Add((DNSTxtResourceRecord)txtRecord);
                        }
                    }
                    foreach (DNSTxtResourceRecord o in toBeRemoved)
                    {
                        this.txtRecords.Remove(o);
                    }
                    this.LongLabelRecords = addLongLabels;
                }
            }
        }

        /// <summary>
        /// Removes and process service messages. Removes keywords. Removes long labels and adds them to their own list.
        /// </summary>
        virtual public System.Collections.ArrayList VersionRecords
        {
            get
            {
                lock (this)
                {
                    return versionRecords;
                }
            }

            set
            {
                lock (this)
                {
                    this.versionRecords = value;
                    this.versionRecords.Reverse() ;
                    updated = (System.DateTime.Now.Ticks - 621355968000000000) / 10000 / 1000;
                    setMinTtl(this.versionRecords);
                    ArrayList toBeRemoved = new ArrayList();
                    ArrayList pddxRecords = new ArrayList();
                    ArrayList addKeywords = new ArrayList();
                    ArrayList addLongLabels = new ArrayList();
                    foreach (DNSTxtResourceRecord versionRecord in this.versionRecords)
                    {
                        if (typeof(DNSPDDXTxtServiceMessageResourceRecord).IsInstanceOfType(versionRecord))
                        {
                            Logger.Log(Logger.Section.Lookups, "Version Record Found pddxVersion = " + PddxVersion);
                            pddxRecords.Add((DNSPDDXTxtServiceMessageResourceRecord)versionRecord);
                            ((DNSPDDXTxtServiceMessageResourceRecord)versionRecord).Process(this);
                            Logger.Log(Logger.Section.Lookups, "Version Record Found pddxVersion = " + PddxVersion);
                            toBeRemoved.Add((DNSTxtResourceRecord)versionRecord);
                        }
                        if (typeof(DNSStructuredKeywordsTxtResourceRecord).IsInstanceOfType(versionRecord))
                        {
                            addKeywords.Add((DNSStructuredKeywordsTxtResourceRecord)versionRecord);
                            toBeRemoved.Add((DNSTxtResourceRecord)versionRecord);
                        }
                        if (typeof(DNSDDSTxtServiceMessageResourceRecord).IsInstanceOfType(versionRecord))
                        {
                            ((DNSDDSTxtServiceMessageResourceRecord)versionRecord).Process(this);
                            toBeRemoved.Add((DNSTxtResourceRecord)versionRecord);
                        }
                        if (typeof(DNSLongLabelTxtResourceRecord).IsInstanceOfType(versionRecord))
                        {
                            addLongLabels.Add((DNSLongLabelTxtResourceRecord)versionRecord);
                            toBeRemoved.Add((DNSTxtResourceRecord)versionRecord);
                        }
                      
                    }
                    foreach (DNSTxtResourceRecord o in toBeRemoved)
                    {
                        this.versionRecords.Remove(o);
                    }
                    this.txtRecords = this.versionRecords;
                    this.versionRecords = pddxRecords;
                    this.KeywordRecords = addKeywords;
                    this.LongLabelRecords = addLongLabels;
                }
            }
        }

        /// <summary>
        /// Removes any records which aren't keywords
        /// </summary>
        virtual public System.Collections.ArrayList KeywordRecords
        {
            get
            {
                lock (this)
                {
                    return keywordRecords;
                }
            }

            set
            {
                lock (this)
                {
                    this.keywordRecords = value;
                    //Logger.Log(Logger.Section.Lookups, this.keywordRecords.Count + " keyword entries found when PDDX <> 1.");
                    //txtRecords.Sort();
                    updated = (System.DateTime.Now.Ticks - 621355968000000000) / 10000 / 1000;
                    setMinTtl(this.keywordRecords);
                    //get rid of service messages so they don't get in the way
                    List<DNSTxtResourceRecord> toBeRemoved = new List<DNSTxtResourceRecord>();
                    foreach (DNSTxtResourceRecord txtRecord in this.keywordRecords)
                    {
                        if (!typeof(DNSStructuredKeywordsTxtResourceRecord).IsInstanceOfType(txtRecord))
                        {
                            toBeRemoved.Add((DNSTxtResourceRecord)txtRecord);
                        }
                    }
                    foreach (DNSTxtResourceRecord o in toBeRemoved)
                    {
                        this.keywordRecords.Remove(o);
                    }
                    
                }
            }

        }


      

        private bool canBeFriended = true;
        /// <summary>
        /// True if the domain this result is for can be friended
        /// </summary>
        public bool CanBeFriended
        {
            get
            {
                return this.canBeFriended;
            }

            set
            {
                this.canBeFriended = value;
            }
        }

        private string pddxVersion = "";
        /// <summary>
        /// The Version found in the PDDX version record
        /// </summary>
        public string PddxVersion
        {
            get
            {
                return this.pddxVersion;
            }

            set
            {
                this.pddxVersion = value;
            }
        }

        private string ddsValue = null;
        /// <summary>
        /// Returns the vlaue of the DDS
        /// </summary>
        public string DdsValue
        {
            get
            {
                return this.ddsValue;
            }

            set
            {
                this.ddsValue = value;
            }
        }

        /// <summary> Gets the telname.
        /// 
        /// </summary>
        /// <returns> the telname
        /// </returns>
        virtual public System.String Telname
        {
            get
            {
                return telname;
            }
        }

        /// <summary>
        /// Gets the telname for this result that should be presented to the user
        /// </summary>
        virtual public string PublicTelname
        {
            get
            {
                return this.publicTelname;
            }
        }

        /// <summary> Checks if is valid.
        /// Return true if this result has expired
        /// ie. the time now is past the ttl
        /// </summary>
        /// <returns> true, if is valid
        /// </returns>
        virtual public bool Valid
        {

            get
            {
                try
                {
                    long valid = validFor();
                    return valid >= -1;
                }
                catch (Exception)
                {
                    return false;
                }
            }

        }

        /// <summary>
        /// set the ttl of this object to the minimum ttl of all the given records
        /// </summary>
        /// <param name="resourceRecords"></param>
        private void setMinTtl(System.Collections.ArrayList resourceRecords)
        {
            foreach (DNSResourceRecord d in resourceRecords)
            {
                long currentTtl = d.TTL;
                if (currentTtl < ttl)
                {
                    ttl = currentTtl;
                }
            }
        }

        private static string[] specialDomains = null;

        /// <summary>
        /// Evaluates whether the domain is a special domain name that doesn't get displayed to the user
        /// </summary>
        /// <param name="domain">The domain name that may be special</param>
        /// <returns>True if the domain name is special</returns>
        private static bool IsSpecialDomain(string domain)
        {
            if(LookupResult.specialDomains == null)
            {
                LookupResult.specialDomains = Preferences.GetPreference("list.specialdomains").Split(',');
            }
            foreach (string dom in LookupResult.specialDomains)
            {
                if (dom == domain)
                {
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// Generates an XML representation of this results object
        /// </summary>
        /// <returns></returns>
        public XmlElement XML()
        {
            // create the root element
            XmlDocument doc = new XmlDocument();
            XmlElement root = doc.CreateElement("TelnicLookupResults");

            // create child nodes and add them
            XmlElement domainElement = doc.CreateElement("Domain");
            if (TelnameChecker.IsEnum(telname))
            {
                domainElement.InnerText = UriHandler.getInstance().FormatEnum(telname);
            }
            else
            {
                //domainElement.InnerText = this.publicTelname;
                //string[] crumbs = this.publicTelname.Substring(0, this.publicTelname.Length - 4).Split('.');
                string[] crumbs = this.publicTelname.Substring(0, this.publicTelname.Length - 4).Split('.');
                if (crumbs.Length > 0)
                {
                    if (LookupResult.IsSpecialDomain(crumbs[crumbs.Length - 1]) && (crumbs.Length > 1))
                    {
                        domainElement.InnerText = crumbs[crumbs.Length - 2];
                    }
                    else
                    {
                        domainElement.InnerText = crumbs[crumbs.Length - 1];
                    }
                    XmlElement crumbsElement = doc.CreateElement("Crumbs");
                    for (int i = 0; i < crumbs.Length; i++)
                    {
                        XmlElement crumbElement = doc.CreateElement("Crumb");
                        XmlElement crumbNameElement = doc.CreateElement("CrumbName");
                        crumbNameElement.InnerText = Gnu.Inet.Encoding.IDNA.ToUnicode(crumbs[i]);
                        crumbElement.AppendChild(crumbNameElement);
                        if (i > 0)
                        {
                            StringBuilder s = new StringBuilder();
                            for (int j = i; j < crumbs.Length; j++)
                            {
                                s.Append(crumbs[j]);
                                s.Append('.');
                            }
                            s.Append("tel");
                            XmlElement crumbLinkElement = doc.CreateElement("CrumbLink");
                            crumbLinkElement.InnerText = s.ToString();
                            crumbElement.AppendChild(crumbLinkElement);
                        }
                        crumbsElement.AppendChild(crumbElement);
                    }
                    root.AppendChild(crumbsElement);
                }
                else
                {
                    domainElement.InnerText = crumbs[crumbs.Length - 1];
                }
            }
            root.AppendChild(domainElement);

            if (naptrStatus != LookupWorker.LookupStatus.Ok)
            {
                XmlElement naptrStatusElement = doc.CreateElement("NaptrErrorStatus");
                naptrStatusElement.InnerText = LookupWorker.FormatStatus(NaptrStatus);
                root.AppendChild(naptrStatusElement);
            }

            if (keywordStatus != LookupWorker.LookupStatus.Ok)
            {
                XmlElement keywordStatusElement = doc.CreateElement("KeywordErrorStatus");
                keywordStatusElement.InnerText = LookupWorker.FormatStatus(KeywordStatus);
                root.AppendChild(keywordStatusElement);
            }

            if (txtStatus != LookupWorker.LookupStatus.Ok)
            {
                XmlElement txtStatusElement = doc.CreateElement("TxtRecordErrorStatus");
                txtStatusElement.InnerText = LookupWorker.FormatStatus(TxtStatus);
                root.AppendChild(txtStatusElement);
            }

            if (locStatus != LookupWorker.LookupStatus.Ok)
            {
                XmlElement locStatusElement = doc.CreateElement("LocRecordErrorStatus");
                locStatusElement.InnerText = LookupWorker.FormatStatus(LocStatus);
                root.AppendChild(locStatusElement);
            }

            if (this.nInfoStatus != LookupWorker.LookupStatus.Ok)
            {
                XmlElement nInfoStatusElement = doc.CreateElement("NInfoRecordErrorStatus");
                nInfoStatusElement.InnerText = LookupWorker.FormatStatus(this.nInfoStatus);
                root.AppendChild(nInfoStatusElement);
            }
            if (this.naptrRecords.Count == 0 && this.locRecords.Count == 0 && this.txtRecords.Count == 0 && (this.nInfoRecords == null  || this.nInfoRecords.Count == 0 )
                && (this.keywordRecords == null || this.keywordRecords.Count == 0))
            {
                XmlElement messageElement = doc.CreateElement("Message");
                messageElement.InnerText = DotTelSystem.Properties.Resources.LookUpResult_Message_NoRecordsExistOnThisDomain;
                root.AppendChild(messageElement);
            }

            XmlElement ttlElement = doc.CreateElement("ValidFor");
            try
            {
                ttlElement.InnerText = validFor().ToString();
            }
            catch (Exception)
            {
                ttlElement.InnerText = "";
            }
            root.AppendChild(ttlElement);

            XmlElement lastLookUpTimeElement = doc.CreateElement("LastLookUpTime");
            DateTime lastLookUpDateTime = new DateTime((this.updated * 10000000L) + 621355968000000000);
            lastLookUpTimeElement.InnerXml = System.Xml.XmlConvert.ToString(lastLookUpDateTime,
                                                                                    XmlDateTimeSerializationMode.Local);
            root.AppendChild(lastLookUpTimeElement);

            if (this.ddsValue != null)
            {
                XmlElement ddsValueElement = doc.CreateElement("ddsValue");
                Logger.Log(Logger.Section.Results_Screen, "DDS - " + this.ddsValue);
                ddsValueElement.InnerXml = GetSafeValue(this.ddsValue);
                Logger.Log(Logger.Section.Results_Screen, "DDS - " + ddsValueElement.InnerXml);
                root.AppendChild(ddsValueElement);
            }
           


            // add the NAPTR results
            XmlElement naptrResultsElement = doc.CreateElement("NaptrResults");
            root.AppendChild(naptrResultsElement);

            if (NaptrRecords != null)
            {
                foreach (DNSTelnameNaptrResourceRecord rr in NaptrRecords)
                {
                
                    if (rr.NonTerminal)
                    {
                        XmlElement naptrRecord = doc.CreateElement("NonTerminalNaptrRecord");
                        naptrResultsElement.AppendChild(naptrRecord);

                        XmlElement displayElement = doc.CreateElement("DisplayName");
                        displayElement.InnerText = rr.NTNDisplayName;
                        naptrRecord.AppendChild(displayElement);

                        Logger.Log(Logger.Section.Results_Screen, "Non terminal: " + rr.ReplaceStr);
                        XmlElement uriElement = doc.CreateElement("Uri");
                        uriElement.InnerText = Uri.UnescapeDataString(rr.ReplaceStr).Replace("\\", "\\\\");
                        naptrRecord.AppendChild(uriElement);

                        if (rr.LongLabels.Count > 0)
                        {
                            XmlElement longLabelsElement = doc.CreateElement("LongLabels");
                            foreach (string longLabel in rr.LongLabels)
                            {
                                XmlElement longLabelElement = doc.CreateElement("LongLabel");
                                XmlElement longLabelNameElement = doc.CreateElement("LongLabelName");

                                longLabelNameElement.InnerText = GetSafeValue(longLabel);
                                longLabelElement.AppendChild(longLabelNameElement);
                                longLabelsElement.AppendChild(longLabelElement);
                            }
                            naptrRecord.AppendChild(longLabelsElement);
                        }
                    }
                    else
                    {
                        if (UriHandler.getInstance().Launchable(rr.ServiceType) ||
                        (typeof(DNSUnlinkedTelnameNaptrResourceRecord).IsInstanceOfType(rr) && ((DNSUnlinkedTelnameNaptrResourceRecord)rr).Display))
                        {
                            XmlElement naptrRecord = doc.CreateElement("TerminalNaptrRecord");
                            naptrResultsElement.AppendChild(naptrRecord);

                            XmlElement serviceElement = doc.CreateElement("ServiceType");
                            serviceElement.InnerText = rr.ServiceType;
                            naptrRecord.AppendChild(serviceElement);

                            XmlElement serviceNameElement = doc.CreateElement("ServiceName");
                            serviceNameElement.InnerText = UriHandler.getInstance().ServiceName(rr.ServiceType);
                            naptrRecord.AppendChild(serviceNameElement);

                            XmlElement uriElement = doc.CreateElement("Uri");
                            uriElement.InnerText = rr.Uri.Replace("\\", "\\\\");
                            naptrRecord.AppendChild(uriElement);

                            XmlElement nameElement = doc.CreateElement("Name");

                            if (typeof(DNSUnlinkedTelnameNaptrResourceRecord).IsInstanceOfType(rr))
                            {
                                nameElement.InnerText = ((DNSUnlinkedTelnameNaptrResourceRecord)rr).Text;
                            }
                            else
                            {
                                nameElement.InnerText = UriHandler.getInstance().Format(rr.ServiceType, rr.Uri);
                                XmlElement launchElement = doc.CreateElement("Launchable");
                                launchElement.InnerText = "true";
                                naptrRecord.AppendChild(launchElement);
                            }
                            naptrRecord.AppendChild(nameElement);

                            XmlElement categoriesElement = doc.CreateElement("LocationIndicatorHints");
                            XmlElement categoriesCountElement = doc.CreateElement("Count");
                            categoriesCountElement.InnerText = rr.Catagories.Count.ToString();
                            categoriesElement.AppendChild(categoriesCountElement);

                            foreach (string lih in rr.Catagories)
                            {
                                XmlElement categoryElement = doc.CreateElement("LocationIndicatorHint");
                                XmlElement categoryNameElement = doc.CreateElement("Name");
                                categoryNameElement.InnerText = lih;
                                categoryElement.AppendChild(categoryNameElement);
                                XmlElement categoryPTElement = doc.CreateElement("PresentedText");
                                categoryPTElement.InnerText = DNSTelnameNaptrResourceRecord.GetLocationIndicatorHintPresentedText(lih);
                                categoryElement.AppendChild(categoryPTElement);
                                categoriesElement.AppendChild(categoryElement);
                            }

                            XmlElement concatenatedCategoriesElement = doc.CreateElement("ConcatenatedCategories");
                            if (rr.Catagories.Count > 0)
                            {
                                string[] cats = rr.Catagories.ToArray();
                                for (int i = 0; i < cats.Length; i++)
                                {
                                    cats[i] = DNSTelnameNaptrResourceRecord.GetLocationIndicatorHintPresentedText(cats[i]);
                                }
                                concatenatedCategoriesElement.InnerText = String.Join(
                                                    DotTelSystem.Properties.Resources.LookUpResult_LocationIndicatorHintsSeparator, cats);
                            }
                            else
                            {
                                concatenatedCategoriesElement.InnerText = " ";
                            }
                            categoriesElement.AppendChild(concatenatedCategoriesElement);

                            naptrRecord.AppendChild(categoriesElement);

                            XmlElement iconElement = doc.CreateElement("Icon");
                            iconElement.InnerText = UriHandler.getInstance().GetIcon(rr.ServiceType, rr.Catagories, rr.WasEncrypted);
                            naptrRecord.AppendChild(iconElement);

                            XmlElement labelsElement = doc.CreateElement("XLabels");
                            XmlElement xlblCount = doc.CreateElement("Count");
                            xlblCount.InnerText = rr.Labels.Count.ToString();
                            labelsElement.AppendChild(xlblCount);
                            foreach (string label in rr.Labels)
                            {
                                XmlElement labelElement = doc.CreateElement("XLabel");
                                XmlElement labelNameElement = doc.CreateElement("XLabelName");
                                labelNameElement.InnerText = GetSafeValue(label).Replace('-', ' ').Replace(':', ' '); 
                                labelElement.AppendChild(labelNameElement);
                                labelsElement.AppendChild(labelElement);
                            }
                            naptrRecord.AppendChild(labelsElement);
                            
                            if (rr.LongLabels.Count > 0)
                            {
                                Logger.Log(Logger.Section.Results_Screen, "Long Label count: " + rr.LongLabels.Count);
                                XmlElement longLabelsElement = doc.CreateElement("LongLabels");
                                foreach (string longLabel in rr.LongLabels)
                                {
                                    XmlElement longLabelElement = doc.CreateElement("LongLabel");
                                    XmlElement longLabelNameElement = doc.CreateElement("LongLabelName");
                                    longLabelNameElement.InnerText = GetSafeValue(longLabel);
                                    longLabelElement.AppendChild(longLabelNameElement);
                                    longLabelsElement.AppendChild(longLabelElement);
                                }
                                naptrRecord.AppendChild(longLabelsElement);
                            }

                         
                        }
                       
                    }
                   
                }

            }

            // add the LOC results
            XmlElement locResultsElement = doc.CreateElement("LocResults");
            root.AppendChild(locResultsElement);

            if (this.LocRecords != null)
            {
                foreach (DNSLocResourceRecord rr in this.LocRecords)
                {
                    XmlElement locRecord = doc.CreateElement("LocRecord");
                    locResultsElement.AppendChild(locRecord);

                    XmlElement lonElement = doc.CreateElement("Longitude");
                    lonElement.InnerText = rr.Longitude;
                    locRecord.AppendChild(lonElement);

                    XmlElement latElement = doc.CreateElement("Latitude");
                    latElement.InnerText = rr.Latitude;
                    locRecord.AppendChild(latElement);

                    XmlElement altElement = doc.CreateElement("Altitude");
                    altElement.InnerText = rr.Altitude;
                    locRecord.AppendChild(altElement);

                    XmlElement locEscElement = doc.CreateElement("LocationWithEscapedQuotes");
                    locEscElement.InnerText = String.Format("{0} {1}", rr.Longitude, rr.Latitude).Replace("'", "\\'");
                    locRecord.AppendChild(locEscElement);
                }
            }

            // add the TXT results
            //Commented out because we shouldn't be displaying an txtRecords
            if (pddxVersion == "1")
            {
                XmlElement txtResultsElement = doc.CreateElement("TxtResults");
                root.AppendChild(txtResultsElement);

                if (TxtRecords != null)
                {
                    foreach (DNSTxtResourceRecord rr in TxtRecords)
                    {
                        if (!typeof(DNSEnhancedTxtResourceRecord).IsInstanceOfType(rr))
                        {
                            XmlElement txtRecord = doc.CreateElement("TxtRecord");
                            txtResultsElement.AppendChild(txtRecord);

                            XmlElement stringElement = doc.CreateElement("String");
                            stringElement.InnerText = stringElement.InnerText = GetSafeValue(rr.TxtStr);
                            txtRecord.AppendChild(stringElement);
                        }
                    }
                }
            }

            // add the Keyword results
            XmlElement keywordResultsElement = doc.CreateElement("KeywordResults");
            root.AppendChild(keywordResultsElement);

            if (KeywordRecords != null)
            {
                foreach (DNSTxtResourceRecord rr in KeywordRecords)
                {
                    if (typeof(DNSEnhancedTxtResourceRecord).IsInstanceOfType(rr))
                    {
                        if (typeof(DNSStructuredKeywordsTxtResourceRecord).IsInstanceOfType(rr))
                        {
                            XmlElement keywordRecord = doc.CreateElement("EnhancedTxtRecord");
                            keywordResultsElement.AppendChild(keywordRecord);

                            DNSStructuredKeywordsTxtResourceRecord dnssktrr = (DNSStructuredKeywordsTxtResourceRecord)rr;

                            if (dnssktrr.FreeText != null)
                            {
                                XmlElement typeElement = doc.CreateElement("Type");
                                typeElement.InnerText = "FreeText";
                                keywordRecord.AppendChild(typeElement);

                                XmlElement pairElement = doc.CreateElement("PrimaryPair");
                                XmlElement keyElement = doc.CreateElement("Key");
                                keyElement.InnerText = "";
                                pairElement.AppendChild(keyElement);

                                string value = GetSafeValue(dnssktrr.FreeText);
                                //string value = System.Security.SecurityElement.Escape(StripCharactersHTMLFears(dnssktrr.FreeText));
                                if (value != "")
                                {
                                    XmlElement valueElement = doc.CreateElement("Value");
                                    valueElement.InnerText =  value;
                                    pairElement.AppendChild(valueElement);
                                }
                                keywordRecord.AppendChild(pairElement);
                            }
                        }
                    }
                }
                foreach (DNSTxtResourceRecord rr in KeywordRecords)
                {
                    if (typeof(DNSEnhancedTxtResourceRecord).IsInstanceOfType(rr))
                    {
                        if (typeof(DNSStructuredKeywordsTxtResourceRecord).IsInstanceOfType(rr))
                        {
                            XmlElement keywordRecord = doc.CreateElement("EnhancedTxtRecord");
                            keywordResultsElement.AppendChild(keywordRecord);

                            DNSStructuredKeywordsTxtResourceRecord dnssktrr = (DNSStructuredKeywordsTxtResourceRecord)rr;

                            XmlElement countElement = doc.CreateElement("Count");
                            countElement.InnerText = "" + dnssktrr.KeywordsAndValues.Count;
                            keywordRecord.AppendChild(countElement);
                            bool primary = true;
                            foreach (KeyValuePair<string, string> kvp in dnssktrr.KeywordsAndValues)
                            {
                                XmlElement typeElement = doc.CreateElement("Type");
                                if (dnssktrr.IsStructured())
                                {
                                    typeElement.InnerText = "Structured";
                                  }
                                else
                                {
                                    typeElement.InnerText = "Other";
                                }
                                keywordRecord.AppendChild(typeElement);

                                //string key = System.Security.SecurityElement.Escape(StripCharactersHTMLFears(kvp.Key));
                                //string value = System.Security.SecurityElement.Escape(StripCharactersHTMLFears(kvp.Value));
                                string key = GetSafeValue(kvp.Key);
                                string value = GetSafeValue(kvp.Value);
                                XmlElement pairElement = null;
                                if (primary && dnssktrr.IsStructured())
                                {
                                    primary = false;
                                    pairElement = doc.CreateElement("PrimaryPair");
                                }
                                else
                                {
                                    pairElement = doc.CreateElement("Pair");
                                }
                                XmlElement keyElement = doc.CreateElement("Key");
                                keyElement.InnerText = key;
                                pairElement.AppendChild(keyElement);
                                Logger.Log(Logger.Section.Results_Screen,"Key: " + key);
                                XmlElement keyNameElement = doc.CreateElement("Key-name");
                                keyNameElement.InnerText = dnssktrr.KeysToHumanReadableValues[kvp.Key];


                                pairElement.AppendChild(keyNameElement);

                                if (value != "")
                                {
                                    XmlElement valueElement = doc.CreateElement("Value");
                                    if (value.EndsWith(":"))
                                    {
                                        valueElement.InnerText = value.Substring(0,value.Length-1);
                                    }
                                    else
                                    {
                                        valueElement.InnerText = value;
                                    }
                                    
                                    pairElement.AppendChild(valueElement);
                                }

                                keywordRecord.AppendChild(pairElement);
                                
                            }
                        }
                    }
                }
            }

            XmlElement nInfoResultsElement = doc.CreateElement("NInfoResults");
            root.AppendChild(nInfoResultsElement);

            if (NInfoRecords != null)
            {
                foreach (DNSNInfoResourceRecord rr in this.NInfoRecords)
                {
                    XmlElement nInfoRecord = doc.CreateElement("NInfoRecord");
                    nInfoResultsElement.AppendChild(nInfoRecord);

                    XmlElement stringElement = doc.CreateElement("String");
                    stringElement.InnerText = GetSafeValue(rr.TxtStr);
                    //stringElement.InnerText = System.Security.SecurityElement.Escape(StripCharactersHTMLFears(rr.TxtStr))
                    //      .Replace("\r\n", "<br />").Replace("\n", "<br />").Replace("\r", "<br />").Replace("&apos;", "&#39;");
                    nInfoRecord.AppendChild(stringElement);
                }
            }
            return root;
            
        }

        private string GetSafeValue(string p)
        {
            return System.Security.SecurityElement.Escape(StripCharactersHTMLFears(p))
                .Replace("\r\n", "<br />").Replace("\n", "<br />").Replace("\r", "<br />")
                .Replace("&apos;", "&#39;");
        }

        /*private static void MakeLabelText(string label, XmlElement labelNameElement)
        {
            labelNameElement.InnerText = System.Security.SecurityElement.Escape(StripCharactersHTMLFears(label))
                .Replace("\r\n", "<br />").Replace("\n", "<br />").Replace("\r", "<br />")
                .Replace("&apos;", "&#39;").Replace('-', ' ').Replace(':', ' ');
        }*/


        /// <summary>
        /// There are certain characters that XML can't handle so these must be removed before they are passed
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        private static string StripCharactersHTMLFears(string s)
        {
            StringBuilder sb = new StringBuilder(s.Length);
            foreach (char c in s)
            {
                int i = (int)c;
                if (!(i <= 8 || i == 11 || i == 12 || (i >= 14 && i <= 31) || (i >= 127 && i <= 159) || (i >= 55296 && i <= 57343)))
                {
                    sb.Append(c);
                }
            }
            return sb.ToString();
        }

        private bool changed;
        /// <summary>
        /// True if this result is different from the previous result for the domain.
        /// Can be unflagged if the user has seen the change.
        /// </summary>
        public bool Changed
        {
            get
            {
                return this.changed;
            }
            set
            {
                this.changed = value;
            }
        }

     
    }
}