using Library.Eaf.Core;
using Library.Eaf.EquipmentCore.Control;
using Library.Eaf.EquipmentCore.DataCollection.Reporting;
using Library.Eaf.EquipmentCore.SelfDescription.ElementDescription;
using Library.Eaf.EquipmentCore.SelfDescription.ParameterTypes;
using Library.Ifx.Eaf.EquipmentConnector.File.SelfDescription;
using Shared.Metrology;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;

namespace Shared
{

    public class Description
    {

        public enum RowColumn
        {
            Test = 1000,
            Count,
            Index
        }

        public enum LogisticsColumn
        {
            EventName = 2000,
            NullData,
            JobID,
            Sequence,
            MesEntity,
            ReportFullPath,
            ProcessJobID,
            MID
        }

        public enum Param
        {
            String = 0,
            Integer = 2,
            Double = 3,
            Boolean = 4,
            StructuredType = 5
        }

        internal const string FileFound = "FileFound";


        public List<EquipmentParameter> EquipmentParameters { get; private set; }
        public List<ParameterTypeDefinition> ParameterTypeDefinitions { get; private set; }

        private readonly bool _UseCyclical;
        private readonly List<string> _HeaderNames;
        private readonly Dictionary<string, int> _KeyIndexPairs;
        private readonly ParameterTypeDefinition _StructuredType;
        private readonly FileConnectorParameterTypeDefinitionProvider _FileConnectorParameterTypeDefinitionProvider;

        public Description(ILogic logic, ConfigDataBase configDataBase, IEquipmentControl equipmentControl)
        {
            _KeyIndexPairs = new Dictionary<string, int>();
            _HeaderNames = configDataBase.GetHeaderNames(logic);
            _UseCyclical = configDataBase.UseCyclicalForDescription;
            _StructuredType = new StructuredType(nameof(StructuredType), string.Empty, new List<Field>());
            _FileConnectorParameterTypeDefinitionProvider = new FileConnectorParameterTypeDefinitionProvider();
            EquipmentParameters = new List<EquipmentParameter>();
            ParameterTypeDefinitions = new List<ParameterTypeDefinition> { _StructuredType };
            Dictionary<string, List<Tuple<Enum, string, string, object>>> keyValuePairsCollection = configDataBase.GetParameterInfo(logic, allowNull: false);
            List<ParameterValue> results = GetParameterValues(equipmentControl, keyValuePairsCollection);
        }

        private List<ParameterValue> GetParameterValues(IEquipmentControl equipmentControl, Dictionary<string, List<Tuple<Enum, string, string, object>>> keyValuePairsCollection)
        {
            List<ParameterValue> results = new List<ParameterValue>();
            Enum param;
            object value;
            Enum[] @params;
            string description;
            List<object[]> list;
            EquipmentParameter equipmentParameter;
            ParameterTypeDefinition parameterTypeDefinition;
            bool addToEquipmentParameters = !EquipmentParameters.Any();
            foreach (KeyValuePair<string, List<Tuple<Enum, string, string, object>>> keyValuePair in keyValuePairsCollection)
            {
                if (!addToEquipmentParameters && !_KeyIndexPairs.ContainsKey(keyValuePair.Key))
                    continue;
                @params = (from l in keyValuePair.Value select l.Item1).Distinct().ToArray();
                if (@params.Length != 1)
                    throw new Exception();
                if (keyValuePair.Value[0].Item2 != keyValuePair.Key)
                    throw new Exception();
                param = @params[0];
                if (!addToEquipmentParameters)
                    equipmentParameter = EquipmentParameters[_KeyIndexPairs[keyValuePair.Key]];
                else
                {
                    description = keyValuePair.Value[0].Item3;
                    _KeyIndexPairs.Add(keyValuePair.Key, EquipmentParameters.Count());
                    if (param is Param.StructuredType || (_UseCyclical && !_HeaderNames.Contains(keyValuePair.Key)))
                        parameterTypeDefinition = _StructuredType;
                    else
                        parameterTypeDefinition = _FileConnectorParameterTypeDefinitionProvider.GetParameterTypeDefinition(param.ToString());
                    equipmentParameter = new EquipmentParameter(keyValuePair.Key, parameterTypeDefinition, description);
                    EquipmentParameters.Add(equipmentParameter);
                }
                if (!_UseCyclical || _HeaderNames.Contains(keyValuePair.Key))
                    value = keyValuePair.Value[0].Item4;
                else
                {
                    list = new List<object[]>();
                    for (int i = 0; i < keyValuePair.Value.Count; i++)
                        list.Add(new object[] { i, keyValuePair.Value[i].Item4 });
                    value = list;
                }
                if (equipmentControl is null || !(param is Param.StructuredType))
                    results.Add(new ParameterValue(equipmentParameter, value, DateTime.Now));
                else
                    results.Add(equipmentControl.DataCollection.CreateParameterValue(equipmentParameter, value));
            }
            return results;
        }

        public List<ParameterValue> GetParameterValues(ILogic logic, IEquipmentControl equipmentControl, JsonElement jsonElement, int? i = null, Dictionary<string, object> keyValuePairs = null)
        {
            List<ParameterValue> results = new List<ParameterValue>();
            if (_UseCyclical && (i is null || i.Value > 0))
                throw new Exception();
            if (jsonElement.ValueKind != JsonValueKind.Array)
                throw new Exception();
            Enum param;
            Tuple<Enum, string, string, object> tuple;
            JsonElement[] jsonElements = jsonElement.EnumerateArray().ToArray();
            Dictionary<string, List<Tuple<Enum, string, string, object>>> keyValuePairsCollection = new Dictionary<string, List<Tuple<Enum, string, string, object>>>();
            for (int r = i.Value; r < jsonElements.Length; r++)
            {
                foreach (JsonProperty jsonProperty in jsonElement[r].EnumerateObject())
                {
                    if (jsonProperty.Value.ValueKind == JsonValueKind.Object || jsonProperty.Value.ValueKind == JsonValueKind.Array)
                    {
                        param = Param.StructuredType;
                        //jValue = jObject.Value<JValue>("Item1");
                        throw new NotImplementedException("Item1");
                    }
                    else
                    {
                        switch (jsonProperty.Value.ValueKind)
                        {
                            case JsonValueKind.String:
                                param = Param.String;
                                break;
                            case JsonValueKind.Number:
                                param = Param.Double;
                                break;
                            case JsonValueKind.True:
                            case JsonValueKind.False:
                                param = Param.Boolean;
                                break;
                            case JsonValueKind.Null:
                                param = Param.String;
                                break;
                            default:
                                param = Param.StructuredType;
                                break;
                        }
                    }
                    tuple = new Tuple<Enum, string, string, object>(param, jsonProperty.Name, string.Empty, jsonProperty.Value.ToString());
                    if (!keyValuePairsCollection.ContainsKey(jsonProperty.Name))
                        keyValuePairsCollection.Add(jsonProperty.Name, new List<Tuple<Enum, string, string, object>>());
                    keyValuePairsCollection[jsonProperty.Name].Add(tuple);
                }
                if (!_UseCyclical)
                    break;
            }
            results = GetParameterValues(equipmentControl, keyValuePairsCollection);
            return results;
        }

        public static string GetCellName()
        {
            string result;
            if (Backbone.Instance?.CellName is null)
                result = string.Empty;
            else
                result = Backbone.Instance.CellName;
            if (result.Contains("-IO"))
                result = result.Replace("-IO", string.Empty);
            return result;
        }

    }

}