using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data;
using InfluxData.Net.Common;
using InfluxData.Net.InfluxDb;

namespace Mesnac.Basic
{
    /// <summary>
    /// 时序数据库InfluxDb辅助类
    /// </summary>
    public class InfluxDbHelper
    {
        #region 字段定义

        private int _errCount = 0;          //失败异常的次数

        private string influxDbPath = @"D:\influxdb-1.4.3-1";       //时序数据库InfluxDb的根目录
        private string endpointUri = "http://localhost:8086";       //时序数据库服务器的访问Uri
        private string username = "root";                           //时序数据库服务器用户名
        private string password = "root";                           //时序数据服务器密码
        private bool _isStart = false;                              //时序数据库服务器是否启动
        private InfluxDbClient _client = null;                      //时序数据库客户端对象

        private readonly string backViewDbName = "MesnacBackView";  //回放数据库的名称
        private readonly string backViewTableName = "Monitor";      //回放数据表名称
        private readonly string curveDbName = "MesnacCurve";        //曲线数据库的名称
        private readonly string mixCurveTableName = "MixCurveData";       //密炼曲线数据表名称
        private readonly string millCurveTableName = "MillCurveData";       //开炼曲线数据表名称

        private readonly string backViewRetentionPolicyName = "BackViewDataSaveDays";   //回放数据库保留策略名称
        private int backViewDataSaveDays = 30;                      //回放数据保留的天数

        #endregion

        #region 单例实现

        private static InfluxDbHelper _instance = null;

        private InfluxDbHelper()
        {
            this.influxDbPath = AppConfigHelper.GetAppSettingValue("InfluxDb_Path", @"D:\influxdb-1.4.3-1");
            this.endpointUri = AppConfigHelper.GetAppSettingValue("InfluxDb_EndPointUri", "http://localhost:8086");
            this.username = AppConfigHelper.GetAppSettingValue("InfluxDb_UserName", "root");
            this.password = AppConfigHelper.GetAppSettingValue("InfluxDb_Password", "root");
            this.backViewDataSaveDays = AppConfigHelper.GetAppSettingValue("BackViewDataSaveDays", 30);

            //this.StopDbServer();
            //System.Threading.Thread.Sleep(10);
            //this.StartDbServer();
            //System.Threading.Thread.Sleep(50);
            if (!this.IsStartDbServer)
            {
                this.StartDbServer();
            }
        }

        public static InfluxDbHelper Instance
        {
            get
            {
                lock (String.Empty)
                {
                    if (_instance == null)
                    {
                        _instance = new InfluxDbHelper();
                    }
                    return _instance;
                }
            }
        }

        #endregion

        #region 属性定义

        /// <summary>
        /// 回放数据库名称
        /// </summary>
        public string BackViewDbName
        {
            get
            {
                return this.backViewDbName;
            }
        }

        /// <summary>
        /// 返回数据保存策略名称
        /// </summary>
        public string BackViewRetentionPolicyName
        {
            get
            {
                return this.backViewRetentionPolicyName;
            }
        }

        /// <summary>
        /// 回放数据表名称
        /// </summary>
        public string BackViewTableName
        {
            get
            {
                return this.backViewTableName;
            }
        }

        /// <summary>
        /// 密炼曲线数据表名称
        /// </summary>
        public string MixCurveTableName
        {
            get
            {
                return this.mixCurveTableName;
            }
        }
        /// <summary>
        /// 开炼曲线数据表名称
        /// </summary>
        public string MillCurveTableName
        {
            get
            {
                return this.millCurveTableName;
            }
        }
        /// <summary>
        /// 服务是否启动
        /// </summary>
        public bool StartState
        {
            get
            {
                return this._isStart;
            }
        }

        /// <summary>
        /// InfluxDb客户端对象，用于执行查询
        /// </summary>
        public InfluxDbClient Client
        {
            get
            {
                if (_client == null)
                {
                    if (!this.StartState)
                    {
                        this.StartDbServer();
                    }
                    if (this.StartState)
                    {
                        _client = new InfluxDbClient(this.endpointUri, this.username, this.password, InfluxData.Net.Common.Enums.InfluxDbVersion.Latest);
                    }
                }
                return _client;
            }
        }

        #endregion

        #region 方法定义

        #region 判断InfluxDbServer是否已启动

        /// <summary>
        /// 判断InfluxDbServer是否已启动
        /// </summary>
        public bool IsStartDbServer
        {
            get
            {
                this._isStart = WinCmdHelper.CheckProcessExists("influxd", String.Empty);
                if (this._isStart)
                {
                    this.CreateBackViewDb();                //创建回放数据库
                    this.CreateBackViewRetentionPolicy();   //创建回放数据保留策略
                    this.CreateCurveDb();
                }
                return this._isStart;
            }
        }

        #endregion

        #region 启动InfluxDbServer

        /// <summary>
        /// 启动InfluxDbServer
        /// </summary>
        public void StartDbServer()
        {
            System.Threading.Thread t = new System.Threading.Thread(new System.Threading.ThreadStart(this.DoStartDbServerTask));
            t.Start();
            this._isStart = true;
            this.CreateBackViewDb();                //创建回放数据库
            this.CreateBackViewRetentionPolicy();   //创建回放数据保留策略
            this.CreateCurveDb();                   //创建曲线数据库
        }

        private void DoStartDbServerTask()
        {
            string cmd = String.Format("{0} -config {1}", System.IO.Path.Combine(this.influxDbPath, "influxd.exe"), System.IO.Path.Combine(this.influxDbPath, "influxdb.conf"));
            bool result = Mesnac.Basic.WinCmdHelper.ExcuteDosCommand(cmd, false, false);
            if (result)
            {
                this._isStart = true;
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Info("The InfluxDb Server start success!");
            }
            else
            {
                this._isStart = false;
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Error("The InfluxDb Server Start failure!");
            }
        }

        #endregion

        #region 停止InfluxDbServer

        /// <summary>
        /// 停止InfluxDbServer
        /// </summary>
        public void StopDbServer()
        {
            bool result = WinCmdHelper.KillProcessExists("influxd", String.Empty);
            if (result)
            {
                this._isStart = false;
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Info("The InfluxDb Server Stop success!");
            }
            else
            {
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Error("The InfluxDb Server Stop failure!");
            }
        }

        #endregion

        #region 创建回放数据库

        /// <summary>
        /// 创建回放数据库
        /// </summary>
        public void CreateBackViewDb()
        {
            try
            {
                if (!this.StartState)
                {
                    return;
                }
                Task<InfluxData.Net.Common.Infrastructure.IInfluxDataApiResponse> task = this.Client.Database.CreateDatabaseAsync(this.backViewDbName);
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Info("Create BackView Db Result success = " + task.Result.Success);
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Info("Create BackView Db Result Body = " + task.Result.Body);
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Info("Create BackView Db Result StatusCode =" + task.Result.StatusCode);
            }
            catch (Exception ex)
            {
                this._errCount++;
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Error("创建回放数据库异常:" + ex.Message, ex);
            }
        }

        #endregion

        #region 创建曲线数据库

        /// <summary>
        /// 创建曲线数据库
        /// </summary>
        public void CreateCurveDb()
        {
            try
            {
                if (!this.StartState)
                {
                    return;
                }
                Task<InfluxData.Net.Common.Infrastructure.IInfluxDataApiResponse> task = this.Client.Database.CreateDatabaseAsync(this.curveDbName);
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Info("Create Curve Db Result success = " + task.Result.Success);
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Info("Create Curve Db Result Body = " + task.Result.Body);
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Info("Create Curve Db Result StatusCode =" + task.Result.StatusCode);
            }
            catch (Exception ex)
            {
                this._errCount++;
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Error("创建曲线数据库异常:" + ex.Message, ex);
            }
        }

        #endregion

        #region 创建回放数据库的保留策略

        /// <summary>
        /// 创建回放数据库的保留策略
        /// </summary>
        public void CreateBackViewRetentionPolicy()
        {
            try
            {
                if (!this.StartState)
                {
                    return;
                }
                string duration = String.Format("{0}d", this.backViewDataSaveDays);
                Task<InfluxData.Net.Common.Infrastructure.IInfluxDataApiResponse> task = this.Client.Retention.CreateRetentionPolicyAsync(this.backViewDbName, this.backViewRetentionPolicyName, duration, 1);
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Info("Create BackView Retention Policy Result success = " + task.Result.Success);
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Info("Create BackView Retention Policy Result Body = " + task.Result.Body);
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Info("Create BackView Retention Policy Result StatusCode =" + task.Result.StatusCode);
            }
            catch (Exception ex)
            {
                this._errCount++;
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Error("创建回放数据库的保留策略异常:" + ex.Message, ex);
            }

        }

        #endregion

        #region 写数据至回放数据库

        /// <summary>
        /// 写数据至回放数据库
        /// </summary>
        /// <param name="data">要写入的数据</param>
        public void WriteDataToBackViewDb(Dictionary<string, object> data)
        {
            try
            {
                if (!this.StartState)
                {
                    return;
                }
                //ICSharpCode.Core.LoggingService<InfluxDbHelper>.Info("field count = " + data.Count);
                InfluxData.Net.InfluxDb.Models.Point point = new InfluxData.Net.InfluxDb.Models.Point();
                point.Name = this.backViewTableName;     //表名
                //point.Tags = new Dictionary<string, object>() { { "EquipCode", "01001" } };
                point.Fields = data;
                point.Timestamp = DateTime.Now;
                Task<InfluxData.Net.Common.Infrastructure.IInfluxDataApiResponse> task = this.Client.Client.WriteAsync(point, this.backViewDbName, this.backViewRetentionPolicyName, InfluxData.Net.Common.Constants.TimeUnit.Seconds);
                if (task != null && task.Result != null && !task.Result.Success)
                {
                    ICSharpCode.Core.LoggingService<InfluxDbHelper>.Warn("Write Data to backView db result success =" + task.Result.Success);
                    ICSharpCode.Core.LoggingService<InfluxDbHelper>.Warn("Write Data to backView db result Body =" + task.Result.Body);
                    ICSharpCode.Core.LoggingService<InfluxDbHelper>.Warn("Write Data to backView db result StatusCode =" + task.Result.StatusCode);
                }
            }
            catch (Exception ex)
            {
                this._errCount++;
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Error("保存回放数据异常:" + ex.Message, ex);
            }
        }

        #endregion

        #region 写数据至曲线数据库

        /// <summary>
        /// 写数据至曲线数据库
        /// </summary>
        /// <param name="equipCode">机台编号</param>
        /// <param name="data">曲线数据</param>
        public void WriteDataToCurveDb(string equipCode, Dictionary<string, object> data)
        {
            try
            {
                if (!this.StartState)
                {
                    return;
                }
                InfluxData.Net.InfluxDb.Models.Point point = new InfluxData.Net.InfluxDb.Models.Point();
                point.Name = this.mixCurveTableName;       //表名
                point.Tags = new Dictionary<string, object>() { { "EquipCode", equipCode } };
                point.Fields = data;
                point.Timestamp = DateTime.Now;
                Task<InfluxData.Net.Common.Infrastructure.IInfluxDataApiResponse> task = this.Client.Client.WriteAsync(point, this.curveDbName, null, InfluxData.Net.Common.Constants.TimeUnit.Seconds);
                if (task != null && task.Result != null && !task.Result.Success)
                {
                    ICSharpCode.Core.LoggingService<InfluxDbHelper>.Warn("Write Data to curve db result success =" + task.Result.Success);
                    ICSharpCode.Core.LoggingService<InfluxDbHelper>.Warn("Write Data to curve db result Body =" + task.Result.Body);
                    ICSharpCode.Core.LoggingService<InfluxDbHelper>.Warn("Write Data to curve db result StatusCode =" + task.Result.StatusCode);
                }
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Error("保存曲线数据异常:" + ex.Message, ex);
            }
        }

        /// <summary>
        /// 写曲线数据至曲线数据库表
        /// </summary>
        /// <param name="tableName">要写入的表名</param>
        /// <param name="equipCode">机台编号</param>
        /// <param name="unitNum">设备编号</param>
        /// <param name="data">曲线数据</param>
        public void WriteDataToCurveDb(string tableName, string equipCode, string unitNum, Dictionary<string, object> data, DateTime? time)
        {
            try
            {
                if (!this.StartState)
                {
                    return;
                }
                InfluxData.Net.InfluxDb.Models.Point point = new InfluxData.Net.InfluxDb.Models.Point();
                point.Name = tableName;       //表名
                point.Tags = new Dictionary<string, object>() { { "EquipCode", equipCode }, { "UnitNum", unitNum } };
                point.Fields = data;
                if (time == null)
                {
                    point.Timestamp = DateTime.Now;
                }
                else
                {
                    point.Timestamp = time;
                }
                Task<InfluxData.Net.Common.Infrastructure.IInfluxDataApiResponse> task = this.Client.Client.WriteAsync(point, this.curveDbName, null, InfluxData.Net.Common.Constants.TimeUnit.Seconds);
                if (task != null && task.Result != null && !task.Result.Success)
                {
                    ICSharpCode.Core.LoggingService<InfluxDbHelper>.Warn("Write Data to curve db result success =" + task.Result.Success);
                    ICSharpCode.Core.LoggingService<InfluxDbHelper>.Warn("Write Data to curve db result Body =" + task.Result.Body);
                    ICSharpCode.Core.LoggingService<InfluxDbHelper>.Warn("Write Data to curve db result StatusCode =" + task.Result.StatusCode);
                }
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Error("保存曲线数据异常:" + ex.Message, ex);
            }
        }

        #endregion

        #region 从曲线数据库获取数据

        /// <summary>
        /// 从曲线数据库获取数据
        /// </summary>
        /// <param name="equipCode">机台号</param>
        /// <param name="columnList">字段列表</param>
        /// <param name="begin">开始时间</param>
        /// <param name="end">结束时间</param>
        /// <returns>返回对应的曲线数据</returns>
        public Dictionary<string, IList<object>> GetDataFromCurveDb(string equipCode, List<string> columnList, DateTime begin, DateTime end)
        {
            try
            {
                if (!this.StartState)
                {
                    return null;
                }
                Dictionary<string, IList<object>> result = new Dictionary<string, IList<object>>();
                string query = "select {0} from {1} where EquipCode = '{2}' and time >= '{3:yyyy-MM-dd HH:mm:ss}' and time <= '{4:yyyy-MM-dd HH:mm:ss}'";
                query = String.Format(query, String.Join(",", columnList.ToArray()), this.mixCurveTableName, equipCode, begin, end);
                Task<IEnumerable<InfluxData.Net.InfluxDb.Models.Responses.Serie>> task = this.Client.Client.QueryAsync(query, this.curveDbName, null, null);
                if (task != null && task.Result != null)
                {
                    InfluxData.Net.InfluxDb.Models.Responses.Serie serie = task.Result.FirstOrDefault<InfluxData.Net.InfluxDb.Models.Responses.Serie>();
                    if (serie != null)
                    {
                        for (int i = 0; i < serie.Columns.Count; i++)
                        {
                            result.Add(serie.Columns[i], serie.Values[i]);
                        }
                    }
                }
                return result;
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Error("从曲线数据库获取数据异常:" + ex.Message, ex);
            }
            return null;
        }

        /// <summary>
        /// 从曲线数据库获取数据
        /// </summary>
        /// <param name="tableName">要读取的表名</param>
        /// <param name="equipCode">机台编号</param>
        /// <param name="unitNum">设备编号</param>
        /// <param name="columnList">要查询的字段列表</param>
        /// <param name="begin">开始时间</param>
        /// <param name="end">结束时间</param>
        /// <returns>返回对应的曲线数据</returns>
        public Dictionary<string, IList<object>> GetDataFromCurveDb(string tableName, string equipCode, string unitNum, List<string> columnList, DateTime begin, DateTime end)
        {
            try
            {
                if (!this.StartState)
                {
                    return null;
                }
                Dictionary<string, IList<object>> result = new Dictionary<string, IList<object>>();
                string query = "select {0} from {1} where EquipCode = '{2}' and UnitNum = '{3}' and time >= '{4:yyyy-MM-dd HH:mm:ss}' and time <= '{5:yyyy-MM-dd HH:mm:ss}'";
                string fields = "*";
                if (columnList != null && columnList.Count > 0)
                {
                    fields = String.Join(",", columnList.ToArray());
                }
                query = String.Format(query, fields, tableName, equipCode, unitNum, begin, end);
                Task<IEnumerable<InfluxData.Net.InfluxDb.Models.Responses.Serie>> task = this.Client.Client.QueryAsync(query, this.curveDbName, null, null);
                if (task != null && task.Result != null)
                {
                    InfluxData.Net.InfluxDb.Models.Responses.Serie serie = task.Result.FirstOrDefault<InfluxData.Net.InfluxDb.Models.Responses.Serie>();
                    if (serie != null)
                    {
                        for (int i = 0; i < serie.Columns.Count; i++)
                        {
                            result.Add(serie.Columns[i], serie.Values[i]);
                        }
                    }
                }
                return result;
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Error("从曲线数据库获取数据异常:" + ex.Message, ex);
            }
            return null;
        }

        /// <summary>
        /// 从曲线数据库获取数据
        /// </summary>
        /// <param name="columnList">字段列表</param>
        /// <param name="begin">开始时间</param>
        /// <param name="end">结束时间</param>
        /// <returns>返回对应的曲线数据</returns>
        public Dictionary<string, IList<object>> GetDataFromCurveDb(List<string> columnList, DateTime begin, DateTime end)
        {
            try
            {
                if (!this.StartState)
                {
                    return null;
                }
                Dictionary<string, IList<object>> result = new Dictionary<string, IList<object>>();
                string query = "select {0} from {1} where time >= '{2:yyyy-MM-dd HH:mm:ss}' and time <= '{3:yyyy-MM-dd HH:mm:ss}'";
                string fields = "*";
                if (columnList != null && columnList.Count > 0)
                {
                    fields = String.Join(",", columnList.ToArray());
                }
                query = String.Format(query, fields, this.mixCurveTableName, begin, end);
                Task<IEnumerable<InfluxData.Net.InfluxDb.Models.Responses.Serie>> task = this.Client.Client.QueryAsync(query, this.curveDbName, null, null);
                if (task != null && task.Result != null)
                {
                    InfluxData.Net.InfluxDb.Models.Responses.Serie serie = task.Result.FirstOrDefault<InfluxData.Net.InfluxDb.Models.Responses.Serie>();
                    if (serie != null)
                    {
                        for (int i = 0; i < serie.Columns.Count; i++)
                        {
                            result.Add(serie.Columns[i], serie.Values[i]);
                        }
                    }
                }
                return result;
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Error("从曲线数据库获取数据异常:" + ex.Message, ex);
            }
            return null;
        }

        /// <summary>
        /// 从曲线数据库获取数据
        /// </summary>
        /// <param name="tableName">要读取的表名</param>
        /// <param name="unitNum">设备编号</param>
        /// <param name="columnList">字段列表</param>
        /// <param name="begin">开始时间</param>
        /// <param name="end">结束时间</param>
        /// <returns>返回对应的曲线数据</returns>
        public Dictionary<string, IList<object>> GetDataFromCurveDb(string tableName, string unitNum, List<string> columnList, DateTime begin, DateTime end)
        {
            try
            {
                if (!this.StartState)
                {
                    return null;
                }
                Dictionary<string, IList<object>> result = new Dictionary<string, IList<object>>();
                string query = "select {0} from {1} where UnitNum = '{2}' and time >= '{3:yyyy-MM-dd HH:mm:ss}' and time <= '{4:yyyy-MM-dd HH:mm:ss}'";
                string fields = "*";
                if (columnList != null && columnList.Count > 0)
                {
                    fields = String.Join(",", columnList.ToArray());
                }
                query = String.Format(query, fields, tableName, unitNum, begin, end);
                Task<IEnumerable<InfluxData.Net.InfluxDb.Models.Responses.Serie>> task = this.Client.Client.QueryAsync(query, this.curveDbName, null, null);
                if (task != null && task.Result != null)
                {
                    InfluxData.Net.InfluxDb.Models.Responses.Serie serie = task.Result.FirstOrDefault<InfluxData.Net.InfluxDb.Models.Responses.Serie>();
                    if (serie != null)
                    {
                        for (int i = 0; i < serie.Columns.Count; i++)
                        {
                            result.Add(serie.Columns[i], serie.Values[i]);
                        }
                    }
                }
                return result;
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Error("从曲线数据库获取数据异常:" + ex.Message, ex);
            }
            return null;
        }

        #endregion

        #region 把数据集合转化为DataTable

        /// <summary>
        /// 把数据集合转化为DataTable
        /// </summary>
        /// <param name="data">要转化的数据集合</param>
        /// <returns>返回转化后的DataTable对象</returns>
        public static DataTable ConvertDicToDataTable(Dictionary<string, IList<object>> data)
        {
            DataTable dt = new DataTable();
            if (data != null && data.Count > 0)
            {
                string lastKey = String.Empty;
                foreach(string key in data.Keys)
                {
                    lastKey = key;
                    dt.Columns.Add(key, typeof(object));
                }
                for (int i = 0; i < data[lastKey].Count; i++)
                {
                    DataRow row = dt.NewRow();
                    foreach(string key in data.Keys)
                    {
                        if (i < data[key].Count)
                        {
                            row[key] = data[key][i];
                        }
                        else
                        {
                            row[key] = 0;
                        }
                    }
                    dt.Rows.Add(row);
                }
            }
            return dt;
        }

        #endregion

        #region 从回放数据库获取数据

        /// <summary>
        /// 从回放数据库获取数据
        /// </summary>
        /// <param name="tableName">回放数据表名称</param>
        /// <param name="columnList">字段列表</param>
        /// <param name="time">回放时间点</param>
        /// <returns>返回对应时间点的回放数据</returns>
        public Dictionary<string, IList<object>> GetDataFromBackViewDb(string tableName, List<string> columnList, DateTime time)
        {
            try
            {
                if (!this.StartState)
                {
                    return null;
                }
                Dictionary<string, IList<object>> result = new Dictionary<string, IList<object>>();
                string query = "select {0} from {1}.{2} where time = '{3:yyyy-MM-dd HH:mm:ss}'";
                string fields = "*";
                if (columnList != null && columnList.Count > 0)
                {
                    fields = String.Join(",", columnList.ToArray());
                }
                query = String.Format(query, fields, this.backViewRetentionPolicyName, tableName, time);
                Task<IEnumerable<InfluxData.Net.InfluxDb.Models.Responses.Serie>> task = this.Client.Client.QueryAsync(query, this.BackViewDbName, null, null);
                if (task != null && task.Result != null)
                {
                    InfluxData.Net.InfluxDb.Models.Responses.Serie serie = task.Result.FirstOrDefault<InfluxData.Net.InfluxDb.Models.Responses.Serie>();
                    if (serie != null)
                    {
                        for (int i = 0; i < serie.Columns.Count; i++)
                        {
                            result.Add(serie.Columns[i], serie.Values[i]);
                        }
                    }
                }
                return result;
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Error("从回放数据库获取数据异常:" + ex.Message, ex);
            }
            return null;
        }

        /// <summary>
        /// 从回放数据库获取数据
        /// </summary>
        /// <param name="time">回放时间点</param>
        /// <returns>返回对应回放时间点的回放数据</returns>
        public Dictionary<string, IList<object>> GetDataFromBackViewDb(DateTime time)
        {
            try
            {
                if (!this.StartState)
                {
                    return null;
                }
                Dictionary<string, IList<object>> result = new Dictionary<string, IList<object>>();
                string query = "select {0} from {1}.{2} where time = '{3:yyyy-MM-dd HH:mm:ss}'";
                string fields = "*";
                query = String.Format(query, fields, this.backViewRetentionPolicyName, this.backViewTableName, time);
                Task<IEnumerable<InfluxData.Net.InfluxDb.Models.Responses.Serie>> task = this.Client.Client.QueryAsync(query, this.BackViewDbName, null, null);
                if (task != null && task.Result != null)
                {
                    InfluxData.Net.InfluxDb.Models.Responses.Serie serie = task.Result.FirstOrDefault<InfluxData.Net.InfluxDb.Models.Responses.Serie>();
                    if (serie != null)
                    {
                        for (int i = 0; i < serie.Columns.Count; i++)
                        {
                            result.Add(serie.Columns[i], serie.Values[i]);
                        }
                    }
                }
                return result;
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Error("从回放数据库获取数据异常:" + ex.Message, ex);
            }
            return null;
        }

        #endregion

        #region 从InfluxDb数据库获取数据

        /// <summary>
        /// 从InfluxDb数据库获取数据
        /// </summary>
        /// <param name="dbName">数据库名称</param>
        /// <param name="tableName">表名称</param>
        /// <param name="columnList">字段列表</param>
        /// <param name="time">时间条件yyyy-MM-dd HH:mm:ss</param>
        /// <param name="limit">限制返回结果的最大条数</param>
        /// <returns>返回符合条件的n条数据</returns>
        public List<Dictionary<string, object>> GetData(string dbName, string tableName, List<string> columnList, DateTime time, int limit)
        {
            try
            {
                if (!this.StartState)
                {
                    return null;
                }
                List<Dictionary<string, object>> result = new List<Dictionary<string, object>>();
                string query = "select {0} from {1} where time > '{2:yyyy-MM-dd HH:mm:ss}' limit {3}";
                string fields = "*";
                if (columnList != null && columnList.Count > 0)
                {
                    fields = String.Join(",", columnList.ToArray());
                }
                query = String.Format(query, fields, tableName, time, limit);
                Task<IEnumerable<InfluxData.Net.InfluxDb.Models.Responses.Serie>> task = this.Client.Client.QueryAsync(query, dbName, null, null);
                if (task != null && task.Result != null)
                {
                    InfluxData.Net.InfluxDb.Models.Responses.Serie serie = task.Result.FirstOrDefault<InfluxData.Net.InfluxDb.Models.Responses.Serie>();
                    if (serie != null)
                    {
                        Dictionary<string, object> data = null;
                        for (int i = 0; i < limit; i++)
                        {
                            data = new Dictionary<string, object>();
                            for (int colIndex = 0; colIndex < serie.Columns.Count; colIndex++)
                            {
                                data.Add(serie.Columns[colIndex], serie.Values[i][colIndex]);
                            }
                            result.Add(data);
                        }
                    }
                }
                return result;
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Error("从InfluxDb数据库获取数据异常:" + ex.Message, ex);
            }
            return null;
        }

        /// <summary>
        /// 从InfluxDb数据库获取数据
        /// </summary>
        /// <param name="dbName">数据库名称</param>
        /// <param name="retentionPolicyName">数据保存策略</param>
        /// <param name="tableName">数据表</param>
        /// <param name="columnList">字段列表</param>
        /// <param name="time">时间条件yyyy-MM-dd HH:mm:ss</param>
        /// <param name="limit">限制返回结果的最大条数</param>
        /// <returns>返回符合条件的n条数据</returns>
        public List<Dictionary<string, object>> GetData(string dbName, string retentionPolicyName, string tableName, List<string> columnList, DateTime time, int limit)
        {
            try
            {
                if (!this.StartState)
                {
                    return null;
                }
                List<Dictionary<string, object>> result = new List<Dictionary<string, object>>();
                string query = "select {0} from {1}.{2} where time > '{3:yyyy-MM-dd HH:mm:ss}' limit {4}";
                string fields = "*";
                if (columnList != null && columnList.Count > 0)
                {
                    fields = String.Join(",", columnList.ToArray());
                }
                query = String.Format(query, fields, retentionPolicyName, tableName, time, limit);
                Task<IEnumerable<InfluxData.Net.InfluxDb.Models.Responses.Serie>> task = this.Client.Client.QueryAsync(query, dbName, null, null);
                if (task != null && task.Result != null)
                {
                    InfluxData.Net.InfluxDb.Models.Responses.Serie serie = task.Result.FirstOrDefault<InfluxData.Net.InfluxDb.Models.Responses.Serie>();
                    if (serie != null)
                    {
                        Dictionary<string, object> data = null;
                        for (int i = 0; i < limit; i++)
                        {
                            data = new Dictionary<string, object>();
                            for (int colIndex = 0; colIndex < serie.Columns.Count; colIndex++)
                            {
                                data.Add(serie.Columns[colIndex], serie.Values[i][colIndex]);
                            }
                            result.Add(data);
                        }
                    }
                }
                return result;
            }
            catch (Exception ex)
            {
                ICSharpCode.Core.LoggingService<InfluxDbHelper>.Error(String.Format("从InfluxDb数据库{0}.{1}.{2}中获取数据异常: {3}", dbName, retentionPolicyName, tableName, ex.Message), ex);
            }
            return null;
        }

        #endregion

        #endregion
    }
}