using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Wrapper_Api_SequentMicrosystems.Main;

namespace Wrapper_Api_SequentMicrosystems.RTD8TM
{
    public class RTD8TM
    {

        private ApiClient _client;


        public RTD8TM()
        {
            _client = new ApiClient();
        }

        #region Communication

            #pragma warning disable CS8603 // Může jít o vrácený odkaz null.

        //RTD

        /// <summary>
        /// Get data from configured cards
        /// </summary>
        /// <param name="address">Base device address (http://1.2.3.4)</param>
        /// <returns>Deserialized data from API</returns>
        public async Task<SortedList<byte, float[]>> Get(string address)
        {
                return await _client.GetData<SortedList<byte, float[]>>($"{address}api/RTDDA");
        }

        /// <summary>
        /// Get data from all cards
        /// </summary>
        /// <param name="address">Base device address (http://1.2.3.4)</param>
        /// <returns>Deserialized data from API</returns>
        public async Task<SortedList<byte, float[]>> GetAll(string address)
        {
            try
            {
                return await _client.GetData<SortedList<byte, float[]>>($"{address}api/RTDDA/All");
            }
            catch //(Exception ex)
            {
                return new();
            }
        }

        /// <summary>
        /// Get data from Selected card
        /// </summary>
        /// <param name="address">Base device address (http://1.2.3.4)</param>
        /// <param name="stack">Stack ID</param>
        /// <returns>Deserialized data from API</returns>
        public async Task<float[]> GetStack(string address, byte stack)
        {
            if (stack > 7)
                return new float[0];
            if (stack < 0)
                return new float[0];

            try
            {
                return await _client.GetData<float[]>($"{address}api/RTDDA/{stack}");
            }
            catch //(Exception ex)
            {
                return new float[0];
            }
        }

        //Names

        /// <summary>
        /// Get configured chanels names
        /// </summary>
        /// <param name="address">Base device address (http://1.2.3.4)</param>
        /// <returns>Deserialized data from API</returns>
        public async Task<SortedList<byte, string[]>> GetNames(string address)
        {
            try
            {
                return await _client.GetData<SortedList<byte, string[]>>($"{address}api/RTDDA/Names");
            }
            catch
            {
                return new();
            }
        }

        /// <summary>
        /// Post chanels names configuration
        /// </summary>
        /// <param name="address">Base device address (http://1.2.3.4)</param>
        /// <param name="data">Data object with data for Post to API</param>
        public void PostNames(string address, SortedList<byte, string[]> data)
        {
            _client.PostData<SortedList<byte, string[]>>($"{address}api/RTDDA/Names", data);
        }

        //Preconfigured Names

        /// <summary>
        /// Get prepared chanels names list
        /// </summary>
        /// <param name="address">Base device address (http://1.2.3.4)</param>
        /// <returns>Deserialized object from API</returns>
        public async Task<List<string>> GetPreconfNames(string address)
        {
            try
            {
                return await _client.GetData<List<string>>($"{address}api/RTDDA/Names/Preconfigured");
            }
            catch
            {
                return new();
            }
        }

        /// <summary>
        /// Post preconfigured chanels names to API
        /// </summary>
        /// <param name="address">Base device address (http://1.2.3.4)</param>
        /// <param name="data">Data object to Post to API</param>
        public async void PostPreconfNames(string address,  List<string> data)
        {
            await Task.Run(() => _client.PostData<List<string>>($"{address}api/RTDDA/Names/Preconfigured", data));
        }

        // Calibration

        /// <summary>
        /// Get Calibration settings
        /// </summary>
        /// <param name="address">Base device address (http://1.2.3.4)</param>
        /// <returns>Deserialized Calibration data from API</returns>
        public async Task<SortedList<byte, float[]>> GetCalibration(string address)
        {
            try
            {
                return await _client.GetData<SortedList<byte, float[]>>($"{address}api/RTDDA/Calibration");
            }
            catch
            {
                return new();
            }
        }

        /// <summary>
        /// Post calibration data to API
        /// </summary>
        /// <param name="address">Base device address (http://1.2.3.4)</param>
        /// <param name="data">Data object for Post to API</param>
        public async void PostCalibration(string address, SortedList<byte, float[]> data)
        {
            await Task.Run(() => _client.PostData<SortedList<byte, float[]>>($"{address}api/RTDDA/Calibration", data));
        }

        //Value Types

        /// <summary>
        /// Get Value Types settings
        /// </summary>
        /// <param name="address">Base device address (http://1.2.3.4)</param>
        /// <returns>Deserialized Value Types from API</returns>
        public async Task<SortedList<byte, byte[]>> GetValueTypes(string address)
        {
            try
            {
                return await _client.GetData<SortedList<byte, byte[]>>($"{address}api/RTDDA/ValueTypes");
            }
            catch
            {
                return new();
            }
        }

        /// <summary>
        /// Post Value Types data to API
        /// </summary>
        /// <param name="address">Base device address (http://1.2.3.4)</param>
        /// <param name="data">Data object for Post to API</param>
        public async void PostValueTypes(string address, SortedList<byte, byte[]> data)
        {
            await Task.Run(() => _client.PostData<SortedList<byte, byte[]>>($"{address}api/RTDDA/ValueTypes", data));
        }

#pragma warning restore CS8603 // Může jít o vrácený odkaz null.

        #endregion

        /// <summary>
        /// Create data objects list from sortedlists with datas and names
        /// </summary>
        /// <param name="data">Data</param>
        /// <param name="names">Names</param>
        /// <param name="address">Device address</param>
        /// <returns>List with data objects</returns>
        public List<RTD8TMDataModel> GetDataList(SortedList<byte, float[]> data, SortedList<byte, string[]> names, string address)
        {
            List<RTD8TMDataModel> objects = new List<RTD8TMDataModel>();

            foreach (byte stack in data.Keys)
            {
                for (byte rtd = 0; rtd < 8; rtd++)
                {
                    if (!names.ContainsKey(stack) || names[stack].Length < rtd)
                    {
                        RTD8TMDataModel model = new(data[stack][rtd], "", (byte)(rtd + 1), stack, address);
                        objects.Add(model);
                    }
                    else
                    {
                        RTD8TMDataModel model = new(data[stack][rtd], names[stack][rtd], (byte)(rtd + 1), stack, address);
                        objects.Add(model);
                    }
                }
            }

            return objects;
        }

        /// <summary>
        /// Get data objects list by device address
        /// </summary>
        /// <param name="address">Base device address (http://1.2.3.4)</param>
        /// <param name="all">true -> read from all cards | false -> read from configured cards</param>
        /// <returns>List with data objects</returns>
        public async Task<List<RTD8TMDataModel>> GetDataList(string address, bool all)
        {
            if (all)
            {
                return GetDataList(await GetAll(address), await GetNames(address), address);
            }
            else
            {
                return GetDataList(await Get(address), await GetNames(address), address);
            }
        }



























    }
}