using System;
using System.Collections.Generic;

namespace Chernobyl.Threading
{
    public abstract class DataAccessor<DataType>
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="attachTo">The <see cref="DataSafe"/> to attach to.</param>
        /// <param name="accessRights">The rights granted to this accessor.</param>
        public DataAccessor(DataSafe<DataType> attachTo, AccessRights accessRights)
        {
            AccessRights = accessRights;
            attachTo.Attach(this);
            IsAttached = true;
        }

        /// <summary>
        /// When this DataAccess is attached to a <see cref="DataSafe"/> 
        /// (using <see cref="DataSafe.Attach(DataAccessor<DataType>)"/>). 
        /// This method is called after the attaching has been done. If this
        /// method is overwritten then the implementor must remember to set
        /// the <see cref="IsAttached"/> property to true on a successful attach
        /// and set <see cref="AttachedToDataSafe"/> to the passed in 
        /// <see cref="DataSafe<DataType>"/>.
        /// </summary>
        /// <param name="attachTo">The <see cref="DataSafe"/> that this accessor 
        /// is attaching to</param>
        public virtual void OnAttach(DataSafe<DataType> attachTo)
        {
            MyDataSafe = attachTo;
            IsAttached = true;
        }

        /// <summary>
        /// This method is called when the DataSafe is synchronized.
        /// The passed in changeRecords are to be run on the accessors
        /// data so that it can have it's data synchronized with the other
        /// accessors.
        /// </summary>
        /// <param name="changeRecords">The change records to run on the internal
        /// data.</param>
        public abstract void Synchronize(Queue<DataSafe<DataType>.ChangeRecord> changeRecords);

        /// <summary>
        /// Gets/sets the AccessPermissions of this class..
        /// </summary>
        public AccessRights AccessRights {get; internal set;}

        /// <summary>
        /// True if this DataAccessor has been attached to a DataSafe.
        /// </summary>
        public bool IsAttached {get; private set;}

        /// <summary>
        /// The <see cref="DataSafe"/> that this accessor is attached to.
        /// </summary>
        protected DataSafe<DataType> MyDataSafe {get; set;}
    }

    /// <summary>
    /// Used to specify what rights are granted to the 
    /// <see cref="DataAccessor"/> when accessing the
    /// synchronized data in the <see cref="DataSafe"/>.
    /// </summary>
    [Flags]
    public enum AccessRights
    {
        None = 0,
        CanRead = 1,
        CanWrite = 2,
    }
}