using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.Core.Commands;
using Tango.Core.DI;
using Tango.Core.ExtensionMethods;
using Tango.Core.Helpers;
using Tango.DataStore;
using Tango.DataStore.Editing;
using Tango.FSE.Common;
using Tango.FSE.Common.Storage;
using Tango.PMR;
using Tango.PMR.Common;
using Tango.PMR.DataStore;
using DataType = Tango.DataStore.DataType;

namespace Tango.FSE.MachineConfiguration.Dialogs
{
    public class DataStoreItemEditDialogViewVM : FSEDialogViewVM
    {
        private const int MAX_FILE_SIZE_KB = 100;

        [TangoInject]
        private IStorageProvider StorageProvider { get; set; }

        [TangoInject]
        private Common.Notifications.INotificationProvider NotificationProvider { get; set; }

        private DataStoreItemModel _item;
        public DataStoreItemModel Item
        {
            get { return _item; }
            set
            {
                _item = value;
                RaisePropertyChangedAuto();

                if (_item.IsGlobal)
                {
                    Value = _item.GlobalItem.Value;
                }
                else
                {
                    Value = _item.Value;
                }

                Type = _item.Type;

                if (Type == DataType.Proto)
                {
                    ProtoMessageType = (Value as DataStoreProtoObject).MessageType;
                }

                if (_item.IsGlobal)
                {
                    EditingValue = _item.GlobalItem.ToString();
                }
                else
                {
                    EditingValue = _item.ToString();
                }
            }
        }

        public bool EnableTypeChange { get; set; }

        private Object _value;
        public Object Value
        {
            get { return _value; }
            set { _value = value; RaisePropertyChangedAuto(); }
        }

        private DataType _type;
        public DataType Type
        {
            get { return _type; }
            set { _type = value; RaisePropertyChangedAuto(); OnEditingValueChanged(); }
        }

        private DataStoreMessageType _protoMessageType;
        public DataStoreMessageType ProtoMessageType
        {
            get { return _protoMessageType; }
            set { _protoMessageType = value; RaisePropertyChangedAuto(); OnEditingValueChanged(); }
        }

        private String _editingValue;
        public String EditingValue
        {
            get { return _editingValue; }
            set { _editingValue = value; RaisePropertyChangedAuto(); OnEditingValueChanged(); }
        }

        private String _error;
        public String Error
        {
            get { return _error; }
            set { _error = value; RaisePropertyChangedAuto(); RaisePropertyChanged(nameof(HasError)); InvalidateRelayCommands(); }
        }

        public bool HasError
        {
            get { return Error != null; }
        }

        public RelayCommand LoadFileCommand { get; set; }

        public RelayCommand InitProtoCommand { get; set; }

        public DataStoreItemEditDialogViewVM()
        {
            EnableTypeChange = true;
            LoadFileCommand = new RelayCommand(LoadFile);
            InitProtoCommand = new RelayCommand(InitProto);
            TangoIOC.Default.Inject(this);
        }

        private void InitProto()
        {
            if (Type == DataType.Proto)
            {
                var type = MessageFactory.GetDataStorePMRTypeFromDataStoreMessageType(ProtoMessageType);
                var instance = Activator.CreateInstance(type);
                EditingValue = instance.ToJsonString();
            }
        }

        private async void LoadFile()
        {
            if (Type == DataType.Bytes)
            {
                var result = await StorageProvider.OpenFile("Load a file");
                if (result)
                {
                    if ((new FileInfo(result.SelectedItem).Length / 1024) > MAX_FILE_SIZE_KB)
                    {
                        await NotificationProvider.ShowError($"The selected file size exceeds the maximum {MAX_FILE_SIZE_KB}kb allowed.");
                        return;
                    }

                    var bytes = File.ReadAllBytes(result.SelectedItem);
                    Value = bytes;
                    _editingValue = Convert.ToBase64String(bytes);
                    RaisePropertyChanged(nameof(EditingValue));
                }
            }
        }

        private void OnEditingValueChanged()
        {
            if (EditingValue != null)
            {
                try
                {
                    Value = DataStoreHelper.ParseDataStoreValue(Type, EditingValue, ProtoMessageType);
                    Error = null;
                }
                catch (Exception ex)
                {
                    Error = ex.Message;
                }
            }
        }

        protected override bool CanOK()
        {
            return base.CanOK() && !HasError;
        }
    }
}