using Apache.IoTDB;
using Apache.IoTDB.DataStructure;
using JiShe.CollectBus.Common.Extensions;
using JiShe.CollectBus.Common.Helpers;
using JiShe.CollectBus.IoTDBProvider.Context;
using JiShe.CollectBus.IoTDBProvider.Interface;
using JiShe.CollectBus.IoTDBProvider.Provider;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace JiShe.CollectBus.IoTDBProvider
{
    /// <summary>
    /// IoTDB数据源
    /// </summary>
    public class IoTDBProvider : IIoTDBProvider
    {
        private IIoTDBSessionPool _currentSession;
        private static readonly ConcurrentDictionary<Type, DeviceMetadata> _metadataCache = new();
        private readonly ILogger<IoTDBProvider> _logger;
        private readonly IIoTDBSessionFactory _sessionFactory;
        private readonly IoTDBRuntimeContext _runtimeContext;

        public IoTDBProvider(
            ILogger<IoTDBProvider> logger, 
            IIoTDBSessionFactory sessionFactory,
            IoTDBRuntimeContext runtimeContext)
        {
            _logger = logger;
            _sessionFactory = sessionFactory;
            _runtimeContext = runtimeContext;

            RefreshSessionPool();
        }

        private void RefreshSessionPool()
        {
            try
            {
                _currentSession?.Dispose();
                _currentSession = _sessionFactory.GetSessionPool(_runtimeContext.UseTableSessionPool);
                _currentSession.OpenAsync().ConfigureAwait(false).GetAwaiter().GetResult();
            }
            catch (Exception ex)
            {
                //自动回退到备用SessionPool
                _logger.LogError($"{nameof(RefreshSessionPool)} 切换SessionPool失败，回退到默认配置：{ex.Serialize()}");
                _runtimeContext.UseTableSessionPool = !_runtimeContext.UseTableSessionPool;
                _currentSession = _sessionFactory.GetSessionPool(_runtimeContext.UseTableSessionPool);
            }
        }

        /// <summary>
        /// 切换 SessionPool
        /// </summary>
        /// <param name="useTableSession"></param>
        public void SwitchSessionPool(bool useTableSession)
        {
            if (_runtimeContext.UseTableSessionPool != useTableSession)
            {
                _runtimeContext.UseTableSessionPool = useTableSession;
                RefreshSessionPool();
            }
        }

        /// <summary>
        /// 插入数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <returns></returns>
        public async Task InsertAsync<T>(T entity) where T : IoTEntity
        {
            var metadata = GetMetadata<T>();

            var tablet = BuildTablet(new[] { entity }, metadata);

            int result = await _currentSession.InsertAsync(tablet);

            if (result <= 0)
            {
                _logger.LogError($"{typeof(T).Name}插入数据没有成功");
            }
        }

        /// <summary>
        /// 批量插入数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public async Task BatchInsertAsync<T>(IEnumerable<T> entities) where T : IoTEntity
        {
            var metadata = GetMetadata<T>();

            var batchSize = 1000;
            var batches = entities.Chunk(batchSize);

            foreach (var batch in batches)
            {
                var tablet = BuildTablet(batch, metadata);
                var result = await _currentSession.InsertAsync(tablet);
                if (result <= 0)
                {
                    _logger.LogWarning($"{typeof(T).Name} 批量插入数据第{batch}批次没有成功，共{batches}批次。");
                }
            }
        }


        /// <summary>
        /// 删除数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="options"></param>
        /// <returns></returns>
        public async Task<object> DeleteAsync<T>(QueryOptions options) where T : IoTEntity
        {
            var query = BuildDeleteSQL<T>(options);
            var sessionDataSet = await _currentSession.ExecuteQueryStatementAsync(query);

            if (!sessionDataSet.HasNext())
            {
                _logger.LogWarning($"{typeof(T).Name} 删除数据时，没有返回受影响记录数量。");
                return 0;
            }

            //获取唯一结果行
            var row = sessionDataSet.Next();
            return row.Values[0];
        }

        /// <summary>
        /// 查询数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="options"></param>
        /// <returns></returns>
        public async Task<PagedResult<T>> QueryAsync<T>(QueryOptions options) where T : IoTEntity, new()
        {
            var query = BuildQuerySQL<T>(options);
            var sessionDataSet = await _currentSession.ExecuteQueryStatementAsync(query);

            var result = new PagedResult<T>
            {
                TotalCount = await GetTotalCount<T>(options),
                Items = ParseResults<T>(sessionDataSet, options.PageSize)
            };

            return result;
        }

        /// <summary>
        /// 构建Tablet
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entities">表实体</param>
        /// <param name="metadata">设备元数据</param></param>
        /// <returns></returns>
        private Tablet BuildTablet<T>(IEnumerable<T> entities, DeviceMetadata metadata) where T : IoTEntity
        {
            var timestamps = new List<long>();
            var values = new List<List<object>>();
            var devicePaths = new HashSet<string>();

            foreach (var entity in entities)
            {
                timestamps.Add(entity.Timestamps);
                var rowValues = new List<object>();
                foreach (var measurement in metadata.ColumnNames)
                {
                    var value = typeof(T).GetProperty(measurement)?.GetValue(entity);
                    rowValues.Add(value ?? new Exception($"{nameof(BuildTablet)} 构建表模型{typeof(T).Name}时，属性{measurement}值为空，不符合IoTDB设计标准，请赋值以后重新处理。"));
                }
                values.Add(rowValues);
                if (!_runtimeContext.UseTableSessionPool)//树模型
                {
                    devicePaths.Add(DevicePathBuilder.GetDevicePath(entity));
                }
                else
                {
                    devicePaths.Add(DevicePathBuilder.GetTableName<T>());
                }
            }

            if (devicePaths.Count > 1)
            {
                throw new Exception($"{nameof(BuildTablet)} 构建Tablet《{typeof(T).Name}》时，批量插入的设备路径不一致。");
            }

            return _runtimeContext.UseTableSessionPool
                ? BuildTableSessionTablet(metadata, devicePaths.First(), values, timestamps)
                : BuildSessionTablet(metadata, devicePaths.First(), values, timestamps);
        }

        /// <summary>
        /// 构建tree模型的Tablet
        /// </summary>
        /// <param name="metadata"></param>
        /// <param name="devicePath"></param>
        /// <param name="values"></param>
        /// <param name="timestamps"></param>
        /// <returns></returns>
        private Tablet BuildSessionTablet(DeviceMetadata metadata, string devicePath,
       List<List<object>> values, List<long> timestamps)
        {
            return new Tablet(
                devicePath,
                metadata.ColumnNames,
                metadata.DataTypes,
                values,
                timestamps
            );
        }

        /// <summary>
        /// 构建表模型的Tablet
        /// </summary>
        /// <param name="metadata"></param>
        /// <param name="devicePath"></param>
        /// <param name="values"></param>
        /// <param name="timestamps"></param>
        /// <returns></returns>
        private Tablet BuildTableSessionTablet(DeviceMetadata metadata, string devicePath,
            List<List<object>> values, List<long> timestamps)
        {
            var tablet = new Tablet(
                devicePath,
                metadata.ColumnNames,
                metadata.ColumnCategories,
                metadata.DataTypes,
                values,
                timestamps
            );

            return tablet;
        }

        /// <summary>
        /// 构建查询语句
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="options"></param>
        /// <returns></returns>
        private string BuildQuerySQL<T>(QueryOptions options) where T : IoTEntity
        {
            var metadata = GetMetadata<T>();
            var sb = new StringBuilder("SELECT ");
            sb.AppendJoin(", ", metadata.ColumnNames);
            sb.Append($" FROM {options.TableNameOrTreePath}");

            if (options.Conditions.Any())
            {
                sb.Append(" WHERE ");
                sb.AppendJoin(" AND ", options.Conditions.Select(TranslateCondition));
            }

            sb.Append($" LIMIT {options.PageSize} OFFSET {options.Page * options.PageSize}");
            return sb.ToString();
        }

        /// <summary>
        /// 构建删除语句
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="options"></param>
        /// <returns></returns>
        private string BuildDeleteSQL<T>(QueryOptions options) where T : IoTEntity
        {
            var metadata = GetMetadata<T>();
            var sb = new StringBuilder();

            if (!_runtimeContext.UseTableSessionPool)
            {
                sb.Append("DELETE ");
            }
            else
            {
                sb.Append("DROP ");
            }

                sb.Append($" FROM {options.TableNameOrTreePath}");

            sb.AppendJoin(", ", metadata.ColumnNames);

            if (options.Conditions.Any())
            {
                sb.Append(" WHERE ");
                sb.AppendJoin(" AND ", options.Conditions.Select(TranslateCondition));
            }

            return sb.ToString();
        }

        /// <summary>
        /// 将查询条件转换为SQL语句
        /// </summary>
        /// <param name="condition"></param>
        /// <returns></returns>
        /// <exception cref="NotSupportedException"></exception>
        private string TranslateCondition(QueryCondition condition)
        {
            return condition.Operator switch
            {
                ">" => $"{condition.Field} > {condition.Value}",
                "<" => $"{condition.Field} < {condition.Value}",
                "=" => $"{condition.Field} = '{condition.Value}'",
                _ => throw new NotSupportedException($"Operator {condition.Operator} not supported")
            };
        }

        /// <summary>
        /// 获取查询条件的总数量
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="options"></param>
        /// <returns></returns>
        private async Task<int> GetTotalCount<T>(QueryOptions options) where T : IoTEntity
        {
            var countQuery = $"SELECT COUNT(*) FROM {options.TableNameOrTreePath}";
            if (options.Conditions.Any())
            {
                countQuery += " WHERE " + string.Join(" AND ", options.Conditions.Select(TranslateCondition));
            }

            var result = await _currentSession.ExecuteQueryStatementAsync(countQuery);
            return result.HasNext() ? Convert.ToInt32(result.Next().Values[0]) : 0;
        }

        /// <summary>
        /// 解析查询结果
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="dataSet"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        private IEnumerable<T> ParseResults<T>(SessionDataSet dataSet, int pageSize) where T : IoTEntity, new()
        {
            var results = new List<T>();
            var metadata = GetMetadata<T>();

            var properties = typeof(T).GetProperties();

            while (dataSet.HasNext() && results.Count < pageSize)
            {
                var record = dataSet.Next();
                var entity = new T
                {
                    Timestamps = record.Timestamps
                };


                foreach (var measurement in metadata.ColumnNames)
                {
                    var value = record.Values;

                    var prop = properties.FirstOrDefault(p =>
                        p.Name.Equals(measurement, StringComparison.OrdinalIgnoreCase));
                    if (prop != null)
                    {
                        typeof(T).GetProperty(measurement)?.SetValue(entity, value);
                    }

                }

                results.Add(entity);
            }
            return results;
        }

        /// <summary>
        /// 获取设备元数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        private DeviceMetadata GetMetadata<T>() where T : IoTEntity
        {
            return _metadataCache.GetOrAdd(typeof(T), type =>
            {
                var columns = CollectColumnMetadata(type);
                var metadata = BuildDeviceMetadata(columns);
                return metadata;
            });
        }

        /// <summary>
        /// 获取设备元数据的列
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        private List<ColumnInfo> CollectColumnMetadata(Type type)
        {
            var columns = new List<ColumnInfo>();

            foreach (var prop in type.GetProperties())
            {
                //按优先级顺序检查属性，避免重复反射
                ColumnInfo? column = prop.GetCustomAttribute<TAGColumnAttribute>() is not null ? new ColumnInfo(
                    name: prop.Name,  //使用属性名
                    category: ColumnCategory.TAG,
                    dataType: GetDataTypeFromTypeName(prop.PropertyType.Name)
                ) : prop.GetCustomAttribute<ATTRIBUTEColumnAttribute>() is not null ? new ColumnInfo(
                    prop.Name,
                    ColumnCategory.ATTRIBUTE,
                    GetDataTypeFromTypeName(prop.PropertyType.Name)
                ) : prop.GetCustomAttribute<FIELDColumnAttribute>() is not null ? new ColumnInfo(
                    prop.Name,
                    ColumnCategory.FIELD,
                    GetDataTypeFromTypeName(prop.PropertyType.Name)
                ) : null;

                if (column.HasValue)
                {
                    columns.Add(column.Value);
                }
            }
            return columns;
        }

        /// <summary>
        /// 构建设备元数据
        /// </summary>
        /// <param name="columns"></param>
        /// <returns></returns>
        private DeviceMetadata BuildDeviceMetadata(List<ColumnInfo> columns)
        {
            var metadata = new DeviceMetadata();

            //按业务逻辑顺序处理（TAG -> FIELD -> ATTRIBUTE）
            var groupedColumns = columns
                .GroupBy(c => c.Category)
                .ToDictionary(g => g.Key, g => g.ToList());

            ProcessCategory(groupedColumns, ColumnCategory.TAG, metadata);
            ProcessCategory(groupedColumns, ColumnCategory.ATTRIBUTE, metadata);
            ProcessCategory(groupedColumns, ColumnCategory.FIELD, metadata);

            return metadata;
        }

        /// <summary>
        /// 处理不同列类型的逻辑
        /// </summary>
        /// <param name="groupedColumns"></param>
        /// <param name="category"></param>
        /// <param name="metadata"></param>
        private void ProcessCategory(IReadOnlyDictionary<ColumnCategory, List<ColumnInfo>> groupedColumns, ColumnCategory category, DeviceMetadata metadata)
        {
            if (groupedColumns.TryGetValue(category, out var cols))
            {
                metadata.ColumnNames.AddRange(cols.Select(c => c.Name));
                metadata.ColumnCategories.AddRange(cols.Select(c => c.Category));
                metadata.DataTypes.AddRange(cols.Select(c => c.DataType));
            }
        }

        /// <summary>
        /// 数据列结构
        /// </summary>
        private readonly struct ColumnInfo
        {
            public string Name { get; }
            public ColumnCategory Category { get; }
            public TSDataType DataType { get; }

            public ColumnInfo(string name, ColumnCategory category, TSDataType dataType)
            {
                Name = name;
                Category = category;
                DataType = dataType;
            }
        }

        /// <summary>
        /// 根据类型名称获取对应的 IoTDB 数据类型
        /// </summary>
        /// <param name="typeName">类型名称（不区分大小写）</param>
        /// <returns>对应的 TSDataType，默认返回 TSDataType.STRING</returns>
        private TSDataType GetDataTypeFromTypeName(string typeName)
        {
            if (string.IsNullOrWhiteSpace(typeName))
                return TSDataType.STRING;

            return DataTypeMap.TryGetValue(typeName.Trim(), out var dataType)
                ? dataType
                : TSDataType.STRING;
        }

        /// <summary>
        /// 根据类型名称获取 IoTDB 数据类型
        /// </summary>
        private readonly IReadOnlyDictionary<string, TSDataType> DataTypeMap =
            new Dictionary<string, TSDataType>(StringComparer.OrdinalIgnoreCase)
            {
                ["BOOLEAN"] = TSDataType.BOOLEAN,
                ["INT32"] = TSDataType.INT32,
                ["INT64"] = TSDataType.INT64,
                ["FLOAT"] = TSDataType.FLOAT,
                ["DOUBLE"] = TSDataType.DOUBLE,
                ["TEXT"] = TSDataType.TEXT,
                ["NULLTYPE"] = TSDataType.NONE,
                ["TIMESTAMP"] = TSDataType.TIMESTAMP,
                ["DATE"] = TSDataType.DATE,
                ["BLOB"] = TSDataType.BLOB,
                ["STRING"] = TSDataType.STRING
            };
    }
}