/*
See LICENSE folder for this sample’s licensing information.

Abstract:
A data manager that manages data conforming to `Codable` and stores it in `UserDefaults`.
*/

using System;
using Foundation;
using CoreFoundation;

namespace Other.Siri
{
    public struct UserDefaultsStorageDescriptor
    {
        public string Key { get; set; }
        public UserDefaultsStorageDescriptor(string key)
        {
            Key = key;
        }
    }

    public static class NotificationKeys
    {
        // Clients of `DataManager` that want to know when the data changes can 
        // listen for this notification.
        public const string DataChanged = "DataChangedNotification";
    }

    public class DataManager<ManagedDataType> : NSObject 
        where ManagedDataType : NSObject, INSCoding
    {
        // This sample uses App Groups to share a suite of data between the 
        // main app and the different extensions.
        protected NSUserDefaults UserDefaults = NSUserDefaultsHelper.DataSuite;

        // To prevent data races, all access to `UserDefaults` uses this queue.
        protected DispatchQueue UserDefaultsAccessQueue = new DispatchQueue("User Defaults Access Queue");

        // Storage and observation information.
        protected UserDefaultsStorageDescriptor StorageDescriptor;

        // A flag to avoid receiving notifications about data this instance just 
        // wrote to `UserDefaults`.
        protected bool IgnoreLocalUserDefaultsChanges = false;

        // The observer object handed back after registering to observe a 
        // property.
        IDisposable UserDefaultsObserver;

        // The data managed by this `DataManager`.
        //此“DataManager”管理的数据。
        protected ManagedDataType ManagedDataBackingInstance;

        // Access to `managedDataBackingInstance` needs to occur on a dedicated 
        // queue to avoid data races.
        protected DispatchQueue DataAccessQueue = new DispatchQueue("Data Access Queue");

        // Public access to the managed data for clients of `DataManager`
        public ManagedDataType ManagedData
        {
            get
            {
                ManagedDataType data = null;
                DataAccessQueue.DispatchSync(() => data = ManagedDataBackingInstance);
                return data;
            }
        }

        // See note below about createInitialData and initialData
        public DataManager(UserDefaultsStorageDescriptor storageDescriptor, ManagedDataType initialData)
        {
            StorageDescriptor = storageDescriptor;
            LoadData();
            if (ManagedDataBackingInstance is null)
            {
                ManagedDataBackingInstance = initialData;
                WriteData();
            }
            ObserveChangesInUserDefaults();
        }

        // createInitialData
        //
        // The Swift version of this app has a createInitialData method.
        // Each child class of the DataManager class overrides this method, and
        // then the DataManager base class calls the derived versions to get
        // the initial data. C# gives a compiler warning for this ("Virtual
        // member call in constructor"). Since in C# the base class constructor
        // is run before the child class constructor, having the base clas
        // constructor call out to a method on the derived class is calling
        // a method on an object that has not yet been fully constructed.
        // The C# version of this sample works around this problem by passing 
        // in the initial data to the constructor.

        void ObserveChangesInUserDefaults()
        {
            var weakThis = new WeakReference<DataManager<ManagedDataType>>(this);
            Action<NSObservedChange> changeHandler = (change) =>
            {
                if (weakThis.TryGetTarget(out var dataManager))
                {
                    // Ignore any change notifications coming from data this 
                    // instance just saved to `NSUserDefaults`.
                    if (dataManager is null || dataManager.IgnoreLocalUserDefaultsChanges)
                    {
                        return;
                    }

                    // The underlying data changed in `NSUserDefaults`, so 
                    // update this instance with the change and notify clients 
                    // of the change.
                    dataManager.LoadData();
                    dataManager.NotifyClientsDataChanged();
                }
            };
            UserDefaultsObserver = UserDefaults.AddObserver(
                StorageDescriptor.Key,
                NSKeyValueObservingOptions.Initial | NSKeyValueObservingOptions.New,
                changeHandler
            );
        }

        // Notifies clients the data changed by posting an `NSNotification` with 
        // the key `NotificationKeys.DataChanged`
        void NotifyClientsDataChanged()
        {
            var notification = NSNotification.FromName(NotificationKeys.DataChanged, this);
            NSNotificationCenter.DefaultCenter.PostNotification(notification);
        }

        protected virtual void FinishUnarchiving(NSObject unarchivedData)
        {
            throw new NotImplementedException();
        }

        // Loads the data from `NSUserDefaults`.
        void LoadData()
        {
            UserDefaultsAccessQueue.DispatchSync(() =>
            {
                NSData archivedData = UserDefaults.DataForKey(StorageDescriptor.Key);
                try
                {
                    // Let the derived classes handle the specifics of 
                    // putting the unarchived data in the correct format.
                    // This is necessary because the derived classes
                    // (SoupMenuManager, SoupOrderMenuManager) are using
                    // generic data formats (NSMutableSet<T> or NSMutableArray<T>) 
                    // and these types cannot be casted directly from the 
                    // deserialized data.
                    NSObject unarchivedData = NSKeyedUnarchiver.UnarchiveObject(archivedData);
                    FinishUnarchiving(unarchivedData);
                }
                catch (Exception e)
                {
                    if (!(e is null))
                    {
                        Console.WriteLine($"Error: {e.Message}");
                    }
                }
            });
        }

        // Writes the data to `NSUserDefaults`
        protected void WriteData()
        {
            UserDefaultsAccessQueue.DispatchAsync(() =>
            {
                try
                {
                    NSData encodedData = NSKeyedArchiver.ArchivedDataWithRootObject(ManagedDataBackingInstance);
                    IgnoreLocalUserDefaultsChanges = true;
                    UserDefaults.SetValueForKey(encodedData, (NSString)StorageDescriptor.Key);
                    IgnoreLocalUserDefaultsChanges = false;
                    NotifyClientsDataChanged();
                }
                catch (Exception e)
                {
                    throw new Exception($"Could not save data. Reason: {e.Message}");
                }
            });
        }



    }
}