using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Runtime.CompilerServices;
using InABox.Core;

namespace InABox.Core
{
    public class DFLayoutEmbeddedMediaValues : IEnumerable<DFLayoutEmbeddedMediaValue>, INotifyPropertyChanged
    {
        private readonly List<DFLayoutEmbeddedMediaValue> _values = new List<DFLayoutEmbeddedMediaValue>();
        public DFLayoutEmbeddedMediaValue[] Values => _values.ToArray();

        public List<byte[]> AsByteArrays
        {
            get => _values.Select(x => x?.Data).OfType<byte[]>().ToList();
            set
            {
                _values.Clear();
                foreach (var bytes in value)
                    _values.Add(new DFLayoutEmbeddedMediaValue() { ID = Guid.Empty, Data = bytes});
                OnPropertyChanged(nameof(Values));
            }
        }
        
        public DFLayoutEmbeddedMediaValues(String json = "")
        {
            if (String.IsNullOrWhiteSpace(json))
                return;
            _values.Clear();
            List<string> values = Serialization.Deserialize<List<string>>(json) ?? new List<string>();
            foreach (string s in values)
            {
                if (!String.IsNullOrWhiteSpace(s))
                {
                    if (Guid.TryParse(s, out Guid id) && (id != Guid.Empty))
                    {
                        // DigitalFormDocumentHandler.LoadDocument(id, data =>
                        // {
                        //     Add(new DigitalFormEmbeddedMediaValue()
                        //     {
                        //         ID = id,
                        //         Data = data
                        //     });
                        // });
                    }
                    else if (s.IsBase64String())
                    {
                        Add(new DFLayoutEmbeddedMediaValue()
                        {
                            ID = Guid.Empty,
                            Data = Convert.FromBase64String(s)
                        });
                    }
                }
            }
        }

        public override String ToString()
        {
            List<String> results = new List<string>();
            foreach (var value in _values)
                results.Add(value.ToString());
            return Serialization.Serialize(results);
        }
        
        public IEnumerator<DFLayoutEmbeddedMediaValue> GetEnumerator() => _values.GetEnumerator();

        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();

        public void Add(DFLayoutEmbeddedMediaValue value)
        {
            _values.Add(value);
            OnPropertyChanged(nameof(Values));
        }

        public void Remove(DFLayoutEmbeddedMediaValue value)
        {
            if (_values.Contains(value))
            {
                _values.Remove(value);
                OnPropertyChanged(nameof(Values));
            }
        }

        public void Clear()
        {
            _values.Clear();
            OnPropertyChanged(nameof(Values));
        }

        public event PropertyChangedEventHandler? PropertyChanged;

        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = "")
        {
            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }

        protected bool SetField<T>(ref T field, T value, [CallerMemberName] string propertyName = "")
        {
            if (EqualityComparer<T>.Default.Equals(field, value)) return false;
            field = value;
            OnPropertyChanged(propertyName);
            return true;
        }
    }
}