using System.Timers;
using UI_SequentMicrosystems.Models;
using Wrapper_Api_SequentMicrosystems.RTD8TM;

namespace UI_SequentMicrosystems.Services
{
    public class RTD8TMService
    {
        private SortedList<byte, string[]> ChanelNames = new SortedList<byte, string[]>();
        private SortedList<byte, float[]> ActualValues = new SortedList<byte, float[]>();
        private SortedList<byte, byte[]> ValuesType = new SortedList<byte, byte[]>();
        private List<RTD8TMGraphModel> GraphData = new();
        private byte GraphDataCounterCount = 10;
        private byte GraphDataCounter = 0;

        private string? Address {  get; set; }

        private RTD8TM _RTD8TM = new RTD8TM();
        private System.Timers.Timer _timer = new(1000);

        public delegate Task AsyncEventHandler<TEventArgs>(object? sender, TEventArgs? e);
        public event AsyncEventHandler<bool>? EventUpdateValues;

        public RTD8TMService()
        {
            _timer.AutoReset = true;
            _timer.Elapsed += TimerElapsed;
            _timer.Start();

        }

        //Main Parameters Work

        /// <summary>
        /// Set Device Address
        /// </summary>
        /// <param name="address">Address [Base url] (http://1.2.3.4)</param>
        public void SetAddress(string address)
        {
            Address = address;
            GetChanelsNames();
            GetValueTypes();
        }

        /// <summary>
        /// Get used device Address
        /// </summary>
        /// <returns>Address or empty string</returns>
        public string GetAddress()
        {
            if (Address == null)
            {
                return "";
            }
            else 
            { 
                return Address; 
            }
        }

        //Actual Data

        /// <summary>
        /// Read Actual values from Device
        /// </summary>
        private async void GetActualValues()
        {
            if (Address == null) { return; }
            
            ActualValues = await _RTD8TM.Get(Address);

            if (GraphDataCounter >= GraphDataCounterCount)
            {
                GraphDataCounter = 0;
                GraphData.Add(new() { Data = ActualValues, Time = DateTime.Now });
            }
            else
            {
                GraphDataCounter++;
            }
        }

        /// <summary>
        /// Request for actual data
        /// </summary>
        /// <returns></returns>
        public SortedList<byte, float[]> GetActualData()
        {
            return ActualValues;
        }

        /// <summary>
        /// Get actual data Value
        /// </summary>
        /// <param name="stack">Stack ID</param>
        /// <param name="chanel">Chanel ID</param>
        /// <returns>Measure Resistance</returns>
        public float GetActualData(byte stack, byte chanel)
        {
            if (ActualValues.ContainsKey(stack))
            {
                return ActualValues[stack][chanel];
            }
            else
            {
                return 0;
            }
        }

        //ChanelsNames

        /// <summary>
        /// Read configured chanels Names from Device
        /// </summary>
        public async void GetChanelsNames()
        {
            if (Address == null) return;

            ChanelNames = await _RTD8TM.GetNames(Address);

            AutoUpdateChanelsName();
        }

        /// <summary>
        /// Set new Chanels Names
        /// </summary>
        /// <param name="names">chanels names sorted list</param>
            #pragma warning disable CS1998 // V této asynchronní metodě chybí operátory await a spustí se synchronně.
        public async Task SetChanelsNames()
            #pragma warning restore CS1998 // V této asynchronní metodě chybí operátory await a spustí se synchronně.
        {
            if (Address == null)
                return;

            _RTD8TM.PostNames(Address, ChanelNames);
        }

        /// <summary>
        /// Update Chanels Names for not null loading names
        /// </summary>
        private void AutoUpdateChanelsName()
        {
            if (ActualValues.Count <= 0)
                return;

            foreach (byte key in ActualValues.Keys)
            {
                if (!ChanelNames.ContainsKey(key))
                {
                    ChanelNames.Add(key, new string[8]);
                }

                for (int i = 0; i < 8; i++)
                {
                    if (ChanelNames[key][i] == null)
                    {
                        ChanelNames[key][i] = "----------";
                    }
                }
            }
        }

        /// <summary>
        /// Get chanel names
        /// </summary>
        /// <returns>Chanels names object</returns>
        public SortedList<byte, string[]> GetChanelNames()
        {
            return ChanelNames;
        }

        /// <summary>
        /// Set chanel Name
        /// </summary>
        /// <param name="stack">Stack ID</param>
        /// <param name="chanel">Chanel ID</param>
        /// <param name="name">New Name</param>
        public void SetChanelNames(byte stack, byte chanel, string name)
        {
            if (!ChanelNames.ContainsKey(stack))
            {
                ChanelNames.Add(stack, new string[8]);
            }

            ChanelNames[stack][chanel] = name;
        }

        /// <summary>
        /// Read chanel name
        /// </summary>
        /// <param name="stack">Stack ID</param>
        /// <param name="chanel">Chanel ID</param>
        /// <returns>Chanel name</returns>
        public string GetChanelName(byte stack, byte chanel)
        {
            if (ChanelNames.ContainsKey(stack))
            {
                return ChanelNames[stack][chanel];
            }
            else
            {
                return "----------";
            }
        }

        /// <summary>
        /// Clear chanels Names to default
        /// </summary>
        public void ClearChanelNames()
        {
            ChanelNames.Clear();
            AutoUpdateChanelsName();
        }

        //Timer

        private async void TimerElapsed(object? o, ElapsedEventArgs? e)
        {
            GetActualValues();
            AutoUpdateChanelsName();

            if (EventUpdateValues != null)
            {
                await EventUpdateValues.Invoke(this, true);
            }
        }

        //Graph Data

        /// <summary>
        /// Get data for graph visualize
        /// </summary>
        /// <returns>saved Graphn Data</returns>
        public List<RTD8TMGraphModel> GetGraphData()
        {
            return GraphData;
        }

        /// <summary>
        /// Clear data from Graph
        /// </summary>
        public void ClearGraph()
        {
            GraphData.Clear();
        }



        //Values Types

        /// <summary>
        /// Set Value Type identifier
        /// </summary>
        /// <param name="StackID">Stack ID</param>
        /// <param name="ChanelID">Chanel ID</param>
        /// <param name="Type">Value Type</param>
        public void SetValueType(byte StackID, byte ChanelID, byte Type)
        {
            if (!ValuesType.ContainsKey(StackID))
            {
                ValuesType.Add(StackID, new byte[8]);
            }

            ValuesType[StackID][ChanelID] = Type;
        }

        /// <summary>
        /// Get Value Type
        /// </summary>
        /// <param name="StackID">Stack ID</param>
        /// <param name="ChanelID">Chanel ID</param>
        /// <returns>Value Type</returns>
        public byte GetValueType(byte StackID, byte ChanelID)
        {
            if (ValuesType.ContainsKey(StackID))
            {
                return ValuesType[StackID][ChanelID];
            }
            else
            { 
                return 0; 
            }
        }

        /// <summary>
        /// Get ValueTypes From API
        /// </summary>
        public async void GetValueTypes()
        {
            if (Address == null) { return; }

            ValuesType = await _RTD8TM.GetValueTypes(Address);
        }

        /// <summary>
        /// Post ValueTypes to API
        /// </summary>
        public void PostValueTypes()
        {
            if (Address == null) { return; }

            _RTD8TM.PostValueTypes(Address, ValuesType);
        }

        public void ClearValueTypes()
        {
            ValuesType.Clear();
        }


    }
}