#region
/* -----------------------------------------------------------------------
 * <copyright file="SnapshotDifferencer.cs" company="GRNet">
 * 
 * Copyright 2011-2012 GRNET S.A. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *
 *   1. Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following
 *      disclaimer.
 *
 *   2. 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.
 *
 *
 * THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``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 GRNET S.A 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.
 *
 * The views and conclusions contained in the software and
 * documentation are those of the authors and should not be
 * interpreted as representing official policies, either expressed
 * or implied, of GRNET S.A.
 * </copyright>
 * -----------------------------------------------------------------------
 */
#endregion

using System;
using System.Collections.Concurrent;
using System.Diagnostics.Contracts;
using Pithos.Interfaces;
using Pithos.Network;
using System.Collections.Generic;
using System.Linq;

namespace Pithos.Core.Agents
{

    /// <summary>
    /// Calculates the differences between two ObjectInfo snapshots.
    /// </summary>
    public class SnapshotDifferencer
    {
        /// <summary>
        /// Contains the previous and current listings.
        /// Using a separate class for the state simplifies the Post method
        /// which has to modify the listings
        /// </summary>
        private class State
        {
            /// <summary>
            /// The previous snapshot listing
            /// </summary>
            public readonly ObjectInfo[] Previous;

            /// <summary>
            /// The current snapshot listing
            /// </summary>
            public readonly ObjectInfo[] Current;

            public readonly Dictionary<string, ObjectInfo> CurrentDict;

            public readonly Dictionary<string, ObjectInfo> PreviousDict;


            /// <summary>
            /// Common objects, lazily evalueated. 
            /// The common objects are used to calculate both the Changed and Unchanged objects
            /// </summary>
            public readonly IEnumerable<ObjectInfo> Common;

            private readonly static ObjectInfo[] Empty = new ObjectInfo[0];

            [ContractInvariantMethod]
            private void StatInvariant()
            {
// ReSharper disable InvocationIsSkipped
                Contract.Invariant(Current!=null);
                Contract.Invariant(Previous!=null);
                Contract.Invariant(CurrentDict!=null);
                Contract.Invariant(PreviousDict!=null);
                Contract.Invariant(Common!=null);
// ReSharper restore InvocationIsSkipped
            }

            public State(ObjectInfo[] previous, ObjectInfo[] current)
            {
                Previous = previous ?? Empty;
                Current = current ?? Empty;
                CurrentDict = Current.ToDictionary(info => info.UUID);
                PreviousDict = Previous.ToDictionary(info => info.UUID);

                //Attach the previous version to the current listings
                foreach (var info in Current)
                {
                    ObjectInfo prev;
                    if (PreviousDict.TryGetValue(info.UUID, out prev))
                        info.SetPrevious(prev);
                }

                Common=Current.Where(c=>c.Previous !=null);
            }
        }


        private State _state;

        /// <summary>
        /// Default constructor. Initializes the Current and Previous listings to empty lists
        /// </summary>
        public SnapshotDifferencer()
        {                        
            _state = new State(null, null);
        }

        /// <summary>
        /// Posts a new listing
        /// </summary>
        /// <param name="list"></param>
        /// <returns></returns>
        public SnapshotDifferencer Post(IEnumerable<ObjectInfo> list)
        {
            ObjectInfo[] newCurrent=null;
            if (list != null)
            {
                //The state field holds the old state
                var oldState = _state;
                //Replace any NoModification entries with previous values that have
                //the same account, container and possibly, folder
                newCurrent = list.Replace(
                    info => info is NoModificationInfo,
                    noMod => oldState.Current.Where(noMod.CorrespondsTo))
                    .ToArray();
            }
            //Set the new state
            _state = new State(_state.Current, newCurrent);

            return this;
        }
        
        /// <summary>
        /// Deleted objects are those that existed in the Previous listing
        /// but are not found in the Current listing
        /// </summary>
        public IEnumerable<ObjectInfo> Deleted
        {
            get { return _state.Previous
                .Where(info=>!_state.CurrentDict.ContainsKey(info.UUID)); }
        }

        /// <summary>
        /// Created objects are those that exist in the Current listing
        /// but are not found in the Previous listing 
        /// </summary>
        public IEnumerable<ObjectInfo> Created
        {
            get { return _state.Current
                .Where(info=>!_state.PreviousDict.ContainsKey(info.UUID)); }
        }
                
        public IEnumerable<ObjectInfo> Common
        {
            get { return _state.Common; }
        }

        public IEnumerable<ObjectInfo> Changed
        {
            get
            {
                return Common.Where(info => 
                    //The hash is different
                    info.PreviousHash != info.Hash 
                    //And the Uri is unchanged or there is no previous version
                    && (info.Previous == null ||  info.Uri == info.Previous.Uri));
            }
        }

        /// <summary>
        /// Unchanged objects have the same current and previous hash
        /// </summary>
        public IEnumerable<ObjectInfo> Unchanged
        {
            get{ return Common.Where(i => i.PreviousHash == i.Hash);}
        }

        /// <summary>
        /// Moved objects have a previous version with a different name
        /// </summary>
        public IEnumerable<ObjectInfo>  Moved
        {
            get
            {                                
                return Common.Where(info=>
                    //A previous version exists
                    info.Previous!= null 
                    //and the Uri is different
                    && info.Uri!=info.Previous.Uri);                    
            }
        }
    }

    public class AccountsDifferencer
    {
        readonly ConcurrentDictionary<Uri, SnapshotDifferencer> _differencers = new ConcurrentDictionary<Uri, SnapshotDifferencer>();

        public ConcurrentDictionary<Uri, SnapshotDifferencer> Differencers { get { return _differencers; } }

        public SnapshotDifferencer PostSnapshot(AccountInfo accountInfo, List<ObjectInfo> cleanRemotes)
        {
            SnapshotDifferencer differencer;
            if (!_differencers.TryGetValue(accountInfo.AccountKey, out differencer))
            {
                differencer = new SnapshotDifferencer();
                _differencers[accountInfo.AccountKey] = differencer;
            }
            differencer.Post(cleanRemotes);
            return differencer;
        }

    }
}