using System;
using System.Collections.Generic;

namespace Chernobyl.Threading
{
    public class DataSafe<DataType>
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        public DataSafe()
        {
            AttachedDataAccessors = new List<DataAccessor<DataType>>();
            ChangeRecords = new Queue<DataSafe<DataType>.ChangeRecord>();
        }

        /// <summary>
        /// Registers this DataSafe with a synchronous manager so that the DataSafe
        /// can be synchronized on the manager's workday schedule.
        /// </summary>
        /// <param name="company">The manager to register with.</param>
        //public void Register(IManager manager)
        //{
        //    if (IsRegistered == true)
        //    {
        //        Code.WriteErrorMessage("Warning: this IDataSafe has already been registered.");
        //        return;
        //    }

        //    // have the company call this DataSafe's synchronize
        //    // when the workday has ended
        //    manager.OnWorkdayEnd += this.SynchronizeEventHandler;
        //    manager.OnDataSafeRegister(this);

        //    IsRegistered = true;
        //}

        /// <summary>
        /// Attaches a DataAccessor so that accessor can read, write, etc,
        /// to the data within the accessor.
        /// </summary>
        /// <param name="dataAccessor">The <see cref="DataAccessor"/> to attach.</param>
        public void Attach(DataAccessor<DataType> dataAccessor)
        {
            if (AccessRights.CanWrite == (dataAccessor.AccessRights & AccessRights.CanWrite))
            {
                if (WriteAllowedDataAccessor == null)
                    WriteAllowedDataAccessor = dataAccessor;
                else
                    throw new Exception("Only one DataAccessor is allowed to have write access to the data in a DataSafe.");
            }

            if (AttachedDataAccessors.Contains(dataAccessor) == false)
            {
                AttachedDataAccessors.Add(dataAccessor);
                dataAccessor.OnAttach(this);
            }
        }

        /// <summary>
        /// Adds a <see cref="ChangeRecord"/> to the internal list of
        /// changes. Only DataAccessors should call this method. The 
        /// change record passed in must be able to mimic what was done
        /// to the data in the <see cref="DataAccessor"/> so that other 
        /// DataAccessors will end with the same data.
        /// </summary>
        /// <param name="theChange">The ChangeRecord to add.</param>
        public void RecordChange(DataAccessor<DataType> recordingDataAccessor, ChangeRecord theChange)
        {
            if (ReferenceEquals(recordingDataAccessor, WriteAllowedDataAccessor) == true)
                ChangeRecords.Enqueue(theChange);
            else
                throw new Exception("Only DataAccessors which have write permissions can make changes to the DataSafe data.");
        }

        /// <summary>
        /// Can be used to added to an event to synchronize the
        /// data in this DataSafe.
        /// </summary>
        public void SynchronizeEventHandler(object sender, EventArgs e)
        {
            Synchronize();
        }

        /// <summary>
        /// Synchronizes all of the attached DataAccessor's so that
        /// they all hold the newest value.
        /// </summary>
        public void Synchronize()
        {
            // no changes recorded, so we can just return.
            if (ChangeRecords.Count == 0)
                return;

            foreach (DataAccessor<DataType> da in AttachedDataAccessors)
            {
                // don't update the write allowed data accessor
                // since he was the one to make a change if a 
                // change exists.
                if(ReferenceEquals(da, WriteAllowedDataAccessor) == false)
                    da.Synchronize(ChangeRecords);
            }

            ChangeRecords.Clear();
        }

        /// <summary>
        /// Is true if this DataSafe has been registered with an 
        /// <see cref="IManager"/>; false if otherwise.
        /// </summary>
        public bool IsRegistered { get; private set; }

        /// <summary>
        /// A delegate for specifying a ChangeRecord. ChangeRecords
        /// operate on the <paramref name="oldValue"/> passed in so 
        /// that the data held by the DataAccessors is all the same.
        /// </summary>
        /// <param name="oldValue"></param>
        public delegate void ChangeRecord(ref DataType oldValue);

        /// <summary>
        /// The ChangeRecords that will be applied on the next synchronize.
        /// </summary>
        Queue<ChangeRecord> ChangeRecords {get; set;}

        /// <summary>
        /// The one <see cref="DataAccessor"/> that has write capabilities. Only one
        /// <see cref="DataAccessor"/> can have write capabilities.
        /// </summary>
        DataAccessor<DataType> WriteAllowedDataAccessor {get; set;}

        /// <summary>
        /// The DataAccessors that are attached to this DataSafe so that
        /// they can read/write to it.
        /// </summary>
        List<DataAccessor<DataType>> AttachedDataAccessors {get; set;}
    }
}