root/apps/outlook/branches/1.5/DotTelSystem/Lookup/Cache/CacheUpdater.cs @ 577

///<summary>
/// Author: 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 System.Collections.Generic;
using System.Text;
using Outlook = Microsoft.Office.Interop.Outlook;
using org.telnic.outlook.lookup;
using System.Threading;
using org.telnic.outlook.util;
using org.telnic.outlook.friending;
using System.Net;
using org.telnic.outlook.prefs;

namespace org.telnic.outlook.lookup.cache
{
    /// <summary>
    /// Updates the caches for the telnames of the user's contacts.
    /// </summary>
    public class CacheUpdater : LookupTelnameCompleteListener
    {
        private Dictionary<Outlook.ContactItem, string> contactsTelnames;
        private List<LookupTelname> lookups;
        private int successfulUpdates = 0;
        private int updates = 0;
        private Thread cacheThread;

        private bool cancelled = false;
        /// <summary>
        /// True if the update has been cancelled
        /// </summary>
        public bool Cancelled
        {
            get
            {
                return this.cancelled;
            }
        }

        private bool done = false;
        /// <summary>
        /// True if the update is complete
        /// </summary>
        public bool Done
        {
            get
            {
                return this.done;
            }
        }

        private Dictionary<string, bool> triedAndWhetherUpdated;
        private Dictionary<string, List<Outlook.ContactItem>> beingLookedUp;
        private Dictionary<string, string> previouslyUnsuccessful;

        public CacheUpdater(Dictionary<Outlook.ContactItem, string> telnames)
        {
            Logger.Log(Logger.Section.Main_Toolbar, "Update all contacts called with " + telnames.Count + " telnames");
            this.contactsTelnames = telnames;

            //avoids looking up the same telname twice and provides a 
            //quick way to know if the telname should be marked as updated
            this.triedAndWhetherUpdated = new Dictionary<string, bool>();
            this.beingLookedUp = new Dictionary<string, List<Outlook.ContactItem>>();
            this.previouslyUnsuccessful = new Dictionary<string, string>();
        }

        /// <summary>
        /// Mark the given telname's changes as seen
        /// </summary>
        /// <param name="telname">The telname to mark as seen</param>
        public void SetAsSeen(string telname)
        {
            LookupCache.SetAsSeen(telname);
        }

        /// <summary>
        /// Perform a lookup for each telname in a list and cache the results
        /// Optimized for machines that take a while to get back DNS responses.
        /// Typically only one lookup happens at once.
        /// </summary>
        private void UpdateCaches()
        {
            cancelled = false;
            this.lookups = new List<LookupTelname>();
            int count = 0;
            foreach (KeyValuePair<Outlook.ContactItem, string> kvp in contactsTelnames)
            {
                count++;
                string telname = kvp.Value;
                Logger.Log(Logger.Section.Lookups, telname + " is number " + count);
                Outlook.ContactItem contact = kvp.Key;
                try
                {
                    
                    string privateTelname = Publishers.Instance.GetPrivateTelname(telname);

                    

                    lock (this.beingLookedUp)
                    {
                        if (privateTelname == null && triedAndWhetherUpdated.ContainsKey(telname))
                        {
                            Logger.Log(Logger.Section.Lookups, "Already know the answer for " + telname);
                            this.TelnameAlreadySeen(telname, contact, telname);
                        }
                        else if (privateTelname != null && triedAndWhetherUpdated.ContainsKey(privateTelname))
                        {
                            Logger.Log(Logger.Section.Lookups, "Already know the answer for " + privateTelname);
                            this.TelnameAlreadySeen(telname, contact, privateTelname);
                        }
                        else if (privateTelname == null && this.beingLookedUp.ContainsKey(telname))
                        {
                            //no point in looking it up twice
                            Logger.Log(Logger.Section.Lookups, "Adding another lookup for " + telname);
                            this.beingLookedUp[telname].Add(contact);
                        }
                        else if (privateTelname != null && this.beingLookedUp.ContainsKey(privateTelname))
                        {
                            Logger.Log(Logger.Section.Lookups, "Adding another lookup for " + privateTelname);
                            this.beingLookedUp[privateTelname].Add(contact);
                        }
                        else //requires looking up
                        {
                            if (privateTelname != null && this.previouslyUnsuccessful.ContainsKey(privateTelname))
                            {
                                Logger.Log(Logger.Section.Lookups, privateTelname + " was previously unsuccessful.");
                                privateTelname = null;
                            }
                            if (privateTelname == null && this.previouslyUnsuccessful.ContainsKey(telname))
                            {
                                Logger.Log(Logger.Section.Lookups, telname + " was previously unsuccessful.");
                                this.IncrementUpdateAndConsider();
                            }
                            else
                            {
                                List<Outlook.ContactItem> contacts = new List<Outlook.ContactItem>();
                                contacts.Add(contact);
                                if (privateTelname == null)
                                {
                                    privateTelname = telname;
                                }
                                this.beingLookedUp.Add(privateTelname, contacts);

                                Logger.Log(Logger.Section.Main_Toolbar, "Updating cache for " + privateTelname);
                                LookupTelname lt = new LookupTelname(IPAddress.Parse(Preferences.GetPreference("dns")),
                                                                                int.Parse(Preferences.GetPreference("dnsport")));
                                lt.Listener = this;
                                this.lookups.Add(lt);

                                lt.performLookup(privateTelname, telname);
                            }
                        }
                    }
                }
                catch (Exception e)
                {
                    Logger.Log(Logger.Section.Main_Toolbar, "Update all contacts exception, moving onto next contact: "
                                                                                                            + e.Message);
                    this.IncrementUpdateAndConsider();
                }
            }

        }

        private void IncrementUpdateAndConsider()
        {
            this.updates++;
            this.UpdateProgressBar();
            this.ConsiderStopping();
        }

        /// <summary>
        /// Handles the case when a telname has already been seen
        /// </summary>
        /// <param name="telname">The telname as it is displayed to the user</param>
        /// <param name="contact">The contact that has the given telname</param>
        /// <param name="actualTelname">The actual telname that has already been seen</param>
        private void TelnameAlreadySeen(string telname, Outlook.ContactItem contact, string actualTelname)
        {
            if (this.triedAndWhetherUpdated[actualTelname])
            {
                //update table
                this.AddUpdatedContact(contact, telname);
            }
            //update progress
            this.successfulUpdates++;
            this.IncrementUpdateAndConsider();
        }

        /// <summary>
        /// For passing updates of the progress of the update
        /// </summary>
        public class ProgressChangedEventArgs : EventArgs
        {
            private double progress;
            public double Progress
            {
                get
                {
                    return this.progress;
                }
            }

            public ProgressChangedEventArgs(double progress)
            {
                this.progress = progress;
            }
        }

        public delegate void ProgressChangedHandler(object sender, ProgressChangedEventArgs e);

        /// <summary>
        /// Fires whenever the progress of the update changes
        /// </summary>
        public event ProgressChangedHandler ProgressChanged;

        /// <summary>
        /// Fires the ProgressChanged event
        /// </summary>
        private void UpdateProgressBar()
        {
            if (this.ProgressChanged != null)
            {
                this.ProgressChanged(this, 
                        new ProgressChangedEventArgs(((double)this.updates) / ((double)this.contactsTelnames.Count)));
            }
        }

        /// <summary>
        /// For notifying that a contact with a given telname has been updated.
        /// </summary>
        public class UpdatedContactFoundEventArgs : EventArgs
        {
            private Outlook.ContactItem contact;
            public Outlook.ContactItem Contact
            {
                get
                {
                    return this.contact;
                }
            }

            private string telname;
            public string Telname
            {
                get
                {
                    return this.telname;
                }
            }

            public UpdatedContactFoundEventArgs(Outlook.ContactItem contact, string telname)
            {
                this.contact = contact;
                this.telname = telname;
            }
        }

        public delegate void UpdatedContactFoundHandler(object sender, UpdatedContactFoundEventArgs e);

        /// <summary>
        /// Fires everytime a changed telname is noticed
        /// </summary>
        public event UpdatedContactFoundHandler UpdatedContactFound;

        private void AddUpdatedContact(Outlook.ContactItem contact, string telname)
        {
            if (this.UpdatedContactFound != null)
            {
                this.UpdatedContactFound(this, new UpdatedContactFoundEventArgs(contact, telname));
            }
        }

        /// <summary>
        /// Process the result of the lookup
        /// </summary>
        /// <param name="lr">The result to process</param>
        public void LookupTelnameComplete(LookupResult lr)
        {
            if (cancelled)
            {
                return;
            }
            try
            {
                lock (this.beingLookedUp)
                {
                    if (lr.NaptrStatus == LookupWorker.LookupStatus.Nxdomain && lr.Telname != lr.PublicTelname)
                    {
                        if (!this.previouslyUnsuccessful.ContainsKey(lr.Telname))
                        {
                            this.previouslyUnsuccessful.Add(lr.Telname, lr.Telname);
                        }
                        //lookup domain above instead
                        string parentDomain = lr.PublicTelname;

                        //need to spawn multiple look ups
                        foreach (Outlook.ContactItem contact in this.beingLookedUp[lr.Telname])
                        {
                            string tname = this.contactsTelnames[contact];
                            if (this.triedAndWhetherUpdated.ContainsKey(tname))
                            {
                                Logger.Log(Logger.Section.Lookups, "Already know the answer for " + tname + "!");
                                this.TelnameAlreadySeen(tname, contact, tname);
                            }
                            else if (this.beingLookedUp.ContainsKey(tname))
                            {
                                Logger.Log(Logger.Section.Lookups, "Adding another lookup for " + tname + "!");
                                this.beingLookedUp[tname].Add(contact);
                            }
                            else
                            {
                                Logger.Log(Logger.Section.Lookups, "Starting new lookup for " + tname + "!");
                                List<Outlook.ContactItem> cons = new List<Outlook.ContactItem>();
                                cons.Add(contact);
                                this.beingLookedUp.Add(tname, cons);
                                LookupTelname lt = new LookupTelname(IPAddress.Parse(Preferences.GetPreference("dns")),
                                                                        int.Parse(Preferences.GetPreference("dnsport")));
                                lt.Listener = this;
                                lt.performLookup(tname, tname);
                                lookups.Add(lt);
                            }
                        }

                        this.beingLookedUp.Remove(lr.Telname);
                        return;
                    }

                    //remove from being looked up asap
                    List<Outlook.ContactItem> contacts = this.beingLookedUp[lr.Telname];
                    this.beingLookedUp.Remove(lr.Telname);

                    if (lr.Changed)
                    {
                        foreach (Outlook.ContactItem contact in contacts)
                        {
                            this.AddUpdatedContact(contact, lr.PublicTelname);
                        }
                    }

                    if (!this.triedAndWhetherUpdated.ContainsKey(lr.Telname))
                    {
                        this.triedAndWhetherUpdated.Add(lr.Telname, lr.Changed);
                    }

                    if (lr.HasResults())
                    {
                        successfulUpdates += contacts.Count;
                    }
                    else if (!this.previouslyUnsuccessful.ContainsKey(lr.Telname))
                    {
                        this.previouslyUnsuccessful.Add(lr.Telname, lr.Telname);
                    }
                    this.updates += contacts.Count;


                    Logger.Log(Logger.Section.Main_Toolbar, "Lookup complete for " + lr.Telname + ", "
                                                            + (contactsTelnames.Count - updates) + " more results to cache");

                    this.UpdateProgressBar();
                    this.ConsiderStopping();
                }
            }
            catch (Exception e)
            {
                Logger.Log(Logger.Section.Main_Toolbar, e.Message);
            }
        }

        /// <summary>
        /// If all the contacts are processed stop
        /// </summary>
        private void ConsiderStopping()
        {
            if (contactsTelnames.Count == this.updates)
            {
                this.Stop();
            }
        }

        public delegate void StartHandler(object sender, EventArgs e);

        /// <summary>
        /// Fired when the update checking process starts
        /// </summary>
        public event StartHandler Started;

        private void Start()
        {
            if (this.Started != null)
            {
                this.Started(this, EventArgs.Empty);
            }
        }

        public delegate void StopHandler(object sender, EventArgs e);
        /// <summary>
        /// Fired when the update checking process ends
        /// </summary>
        public event StopHandler Stopped;

        private void Stop()
        {
            Logger.Log(Logger.Section.Main_Toolbar, "Operation Completed. Cached " + successfulUpdates + " unique domains, " + this.updates + " attempted");
            if (lookups != null)
            {
                lookups.Clear();
            }

            if (this.Stopped != null)
            {
                this.Stopped(this, EventArgs.Empty);
            }

            this.done = true;
        }

        /// <summary>
        /// Cancel the update checking process.
        /// </summary>
        public void Cancel()
        {
            Logger.Log(Logger.Section.Main_Toolbar, "Operation Cancelled");
            cancelled = true;
            Logger.Log(Logger.Section.Lookups, "" + this.beingLookedUp.Count + " still to finish");
            foreach(KeyValuePair<string, List<Outlook.ContactItem>> kvp in this.beingLookedUp)
            {
                Logger.Log(Logger.Section.Lookups, "Telname: " + kvp.Key + ": " + kvp.Value.Count);
            }
            if (lookups != null)
            {
                foreach (LookupTelname lt in lookups.ToArray())
                {
                    lt.cancel();
                    lookups.Remove(lt);
                }
            }

            try
            {
                cacheThread.Abort();
            }
            catch (Exception)
            {
                cacheThread = null;
            }

            Stop();
        }

        /// <summary>
        /// Starts the process off
        /// </summary>
        public void Ready()
        {
            Start();
            if (this.contactsTelnames.Count == 0)
            {
                Stop();
            }
            else
            {
                cacheThread = new Thread(UpdateCaches);
                cacheThread.Name = "Update all contacts thread";
                cacheThread.Start();
            }
        }
    }
}