using System;
using System.Text;
using System.Collections.Generic;
using System.Data;
using System.Runtime.Serialization;
using System.Linq;
using System.IO;
using System.Runtime.InteropServices; 
using System.Xml.Linq;

namespace IStation.DAL.LocalFile
{
    /// <summary>
    /// 监测月数据集
    /// </summary>	
    public class MonitorDataSet : IDAL.IMonitorDataSet
    {
        #region Info

        #region DateFolderInfo
        /// <summary>
        /// 日期文件夹信息类
        /// </summary>
        private class DateFolderInfo
        {
            public string FullName { get; set; }
            public int Year { get; set; }
            public int Month { get; set; }
        }

        /// <summary>
        /// 获取年月
        /// </summary> 
        private bool GetYearMonth(string folderPath, out int year, out int month)
        {
            year = month = 0;
            if (!Directory.Exists(folderPath))
                return false;

            var name = Path.GetFileName(folderPath);
            var strList = name.Split(MonitorDataSetConfig.Separator);
            if (strList.Length != 2)
                return false;
            if (!int.TryParse(strList[0], out year))
            {
                return false;
            }
            if (!int.TryParse(strList[1], out month))
            {
                return false;
            }
            return true;
        }

        /// <summary>
        /// 获取日期文件夹信息列表
        /// </summary> 
        private List<DateFolderInfo> GetDateFolderInfos(string monitorDataFolderPath)
        {
            if (!Directory.Exists(monitorDataFolderPath))
                return default;
            var directories = Directory.GetDirectories(monitorDataFolderPath);
            if (directories == null || directories.Count() < 1)
                return default;

            var list = new List<DateFolderInfo>(directories.Count());
            foreach (var directory in directories)
            {
                if (!GetYearMonth(directory, out int year, out int month))
                    continue;
                var info = new DateFolderInfo();
                info.FullName = directory;
                info.Year = year;
                info.Month = month;
                list.Add(info);
            }
            if (list.Count > 0)
            {
                list = list.OrderBy(x => x.Year).ThenBy(x => x.Month).ToList();
            }
            return list;
        }

        #endregion

        #region MonitorDataSetFolderInfo
        /// <summary>
        /// 监测月数据集文件夹信息类
        /// </summary>
        private class MonitorDataSetFolderInfo
        {
            public string FullName { get; set; }
            public long MonitorPointId { get; set; }
            public int Year { get; set; }
            public int Month { get; set; }
        }

        /// <summary>
        /// 获取监测记录文件夹信息
        /// </summary> 
        private List<MonitorDataSetFolderInfo> GetMonitorDataSetFolderInfos(string dateFolderPath)
        {
            if (!Directory.Exists(dateFolderPath))
                return default;
            if (!GetYearMonth(dateFolderPath, out int year, out int month))
                return default;
            var directories = Directory.GetDirectories(dateFolderPath);
            if (directories == null || directories.Count() < 1)
                return default;

            var infos = new List<MonitorDataSetFolderInfo>(directories.Count());
            foreach (var directory in directories)
            {
                var name = Path.GetFileName(directory);
                if (long.TryParse(name, out long Id))
                {
                    var info = new MonitorDataSetFolderInfo();
                    info.FullName = directory;
                    info.Year = year;
                    info.Month = month;
                    info.MonitorPointId = Id;
                    infos.Add(info);
                }
            }
            return infos;
        }

        /// <summary>
        /// 获取监测记录文件夹信息
        /// </summary> 
        private List<MonitorDataSetFolderInfo> GetMonitorDataSetFolderInfos(DateFolderInfo dateFolderInfo)
        {
            if (dateFolderInfo == null)
                return default;
            var directories = Directory.GetDirectories(dateFolderInfo.FullName);
            if (directories == null || directories.Count() < 1)
                return default;

            var infos = new List<MonitorDataSetFolderInfo>();
            foreach (var directory in directories)
            {
                var name = Path.GetFileName(directory);
                if (long.TryParse(name, out long Id))
                {
                    var info = new MonitorDataSetFolderInfo();
                    info.FullName = directory;
                    info.Year = dateFolderInfo.Year;
                    info.Month = dateFolderInfo.Month;
                    info.MonitorPointId = Id;
                    infos.Add(info);
                }
            }
            return infos;
        }

        #endregion

        #region SignalRecordPackFileInfo
        /// <summary>
        /// 信号记录包文件信息类
        /// </summary>
        public class SignalRecordPackFileInfo
        {
            public string FullName { get; set; }
            public long MonitorPointId { get; set; }
            public long SignalId { get; set; }
            public int Year { get; set; }
            public int Month { get; set; }
        }

        /// <summary>
        /// 获取信号记录包文件信息
        /// </summary> 
        private List<SignalRecordPackFileInfo> GetSignalRecordPackFileInfos(string montiorDataSetFolder, int year, int month)
        {
            if (!Directory.Exists(montiorDataSetFolder))
                return default;
            var folderName = Path.GetFileName(montiorDataSetFolder);
            if (!long.TryParse(folderName, out long montiorPointId))
                return default;

            var files = Directory.GetFiles(montiorDataSetFolder);
            if (files == null || files.Count() < 1)
                return default;

            var infos = new List<SignalRecordPackFileInfo>(files.Count());
            foreach (var filePath in files)
            {
                var name = Path.GetFileNameWithoutExtension(filePath);
                if (long.TryParse(name, out long Id))
                {
                    var info = new SignalRecordPackFileInfo();
                    info.FullName = filePath;
                    info.MonitorPointId = montiorPointId;
                    info.SignalId = Id;
                    info.Year = year;
                    info.Month = month;
                    infos.Add(info);
                }
            }
            return infos;
        }

        /// <summary>
        /// 获取信号记录包文件信息
        /// </summary> 
        private List<SignalRecordPackFileInfo> GetSignalRecordPackFileInfos(MonitorDataSetFolderInfo montiorDataSetFolderInfo)
        {
            if (montiorDataSetFolderInfo == null)
                return default;
            var files = Directory.GetFiles(montiorDataSetFolderInfo.FullName);
            if (files == null || files.Count() < 1)
                return default;

            var infos = new List<SignalRecordPackFileInfo>(files.Count());
            foreach (var filePath in files)
            {
                var name = Path.GetFileNameWithoutExtension(filePath);
                if (long.TryParse(name, out long Id))
                {
                    var info = new SignalRecordPackFileInfo();
                    info.FullName = filePath;
                    info.MonitorPointId = montiorDataSetFolderInfo.MonitorPointId;
                    info.SignalId = Id;
                    info.Year = montiorDataSetFolderInfo.Year;
                    info.Month = montiorDataSetFolderInfo.Month;
                    infos.Add(info);
                }
            }
            return infos;
        }

        #endregion 

        #endregion

        #region Path

        /// <summary>
        /// 获取文件路径
        /// </summary> 
        private string GetMonitorDataFolder(long projectId, long sceneId)
        {
            return MonitorDataSetConfig.GetMonitorDataFolder(projectId, sceneId);
        }

        /// <summary>
        /// 获取数据集文件夹路径
        /// </summary> 
        private string GetMonitorDataSetFolder(long projectId, long sceneId, long monitorPointId, int year, int month)
        {
            return MonitorDataSetConfig.GetMonitorDataSetFolder(projectId, sceneId, monitorPointId, year, month);
        }
        
        /// <summary>
        /// 获取信号文件路径
        /// </summary> 
        private bool GetSignalRecordPacketFile(long projectId, long sceneId, long monitorPointId, long signaId, int year, int month, out string filePath)
        {
            filePath = MonitorDataSetConfig.GetSignalRecordFile(projectId, sceneId, monitorPointId, signaId, year, month);
            if (!File.Exists(filePath))
                return false;
            return true;
        }

        #endregion

        #region Convert
        //To
        private string ToDsString(Model.SignalRecord record)
        {
            return $"{record.Time:yyyy-MM-dd HH:mm:ss},{record.Value}";
        }

        //from
        public Model.SignalRecord FromDsString(string dsString)
        {
            var strList = dsString.Split(',');
            if (strList.Length < 2)
                return default;
            var model = new Model.SignalRecord();
            model.Time = DateTime.Parse(strList[0]);
            model.Value = double.Parse(strList[1]);
            return model;
        } 
        #endregion
        
        //监测数据集概要
        MonitorDataSetSummary _monitorDataSetSummary = new MonitorDataSetSummary();

        #region Query

        #region MonitorDataSet
        
        /// <summary>
        /// 查询监测数据集
        /// </summary> 
        public List<Model.MonitorDataSet> QueryMonitorDataSet(long projectId, long sceneId)
        {
            var rootFolder = GetMonitorDataFolder(projectId, sceneId);
            var dateFolderInfos = GetDateFolderInfos(rootFolder);
            if (dateFolderInfos == null || dateFolderInfos.Count() < 1)
                return default;

            var MonitorDataSetCount = _monitorDataSetSummary.QueryMonitorDataSetCount(projectId, sceneId);
            var MonitorDataSetList = new List<Model.MonitorDataSet>(MonitorDataSetCount);
            foreach (var dateFolderInfo in dateFolderInfos)
            {
                var montiorDataSetFolderInfos = this.GetMonitorDataSetFolderInfos(dateFolderInfo);
                if (montiorDataSetFolderInfos == null || montiorDataSetFolderInfos.Count < 1)
                    continue;

                foreach (var montiorDataSetFolderInfo in montiorDataSetFolderInfos)
                {
                    var monitorPointId = montiorDataSetFolderInfo.MonitorPointId;
                    var year = montiorDataSetFolderInfo.Year;
                    var month = montiorDataSetFolderInfo.Month;
                    var MonitorDataSet = QueryMonitorDataSet(projectId, sceneId, monitorPointId, year, month);
                    if (MonitorDataSet != null)
                        MonitorDataSetList.Add(MonitorDataSet);
                }
            }
            return MonitorDataSetList;
        }

        /// <summary>
        ///  查询监测数据集
        /// </summary>
        public List<Model.MonitorDataSet> QueryMonitorDataSet(long projectId, long sceneId, long monitorPointId)
        {
            var rootFolder = GetMonitorDataFolder(projectId, sceneId);
            var dateFolderInfos = GetDateFolderInfos(rootFolder);
            if (dateFolderInfos == null || dateFolderInfos.Count() < 1)
                return default;

            var MonitorDataSetList = new List<Model.MonitorDataSet>(dateFolderInfos.Count());
            foreach (var dateFolderInfo in dateFolderInfos)
            {
                var montiorDataSetFolderInfos = this.GetMonitorDataSetFolderInfos(dateFolderInfo);
                if (montiorDataSetFolderInfos == null || montiorDataSetFolderInfos.Count < 1)
                    continue;
                var montiorDataSetFolderInfo = montiorDataSetFolderInfos.Find(x => x.MonitorPointId == monitorPointId);
                if (montiorDataSetFolderInfo == null)
                    continue;
                var year = montiorDataSetFolderInfo.Year;
                var month = montiorDataSetFolderInfo.Month;
                var MonitorDataSet = QueryMonitorDataSet(projectId, sceneId, monitorPointId, year, month);
                if (MonitorDataSet != null)
                    MonitorDataSetList.Add(MonitorDataSet);
            }

            return MonitorDataSetList;
        }

        /// <summary>
        ///  查询监测数据集
        /// </summary>
        public Model.MonitorDataSet QueryMonitorDataSet(long projectId, long sceneId, long monitorPointId, int year, int month)
        {
            var monitorDataSetFolder = GetMonitorDataSetFolder(projectId, sceneId, monitorPointId, year, month);
            var signalRecordPacketFileInfos = this.GetSignalRecordPackFileInfos(monitorDataSetFolder, year, month);
            if (signalRecordPacketFileInfos == null || signalRecordPacketFileInfos.Count < 1)
                return default;

            var signalRecordPacketCount = _monitorDataSetSummary.QuerySignalRecordPacketCount(projectId, sceneId, monitorPointId, year, month);
            if (signalRecordPacketCount < 1)
                return default;

            var MonitorDataSet = new Model.MonitorDataSet();
            MonitorDataSet.MonitorPointId = monitorPointId;
            MonitorDataSet.Year = year;
            MonitorDataSet.Month = month;
            MonitorDataSet.PacketList = new List<Model.SignalRecordPacket>(signalRecordPacketCount);

            foreach (var signalRecordFile in signalRecordPacketFileInfos)
            {
                var signalId = signalRecordFile.SignalId;
                var signalRecordPacket = QuerySignalRecordPacket(projectId, sceneId, monitorPointId, signalId, year, month);
                if (signalRecordPacket != null)
                {
                    MonitorDataSet.PacketList.Add(signalRecordPacket);
                }
            }

            return MonitorDataSet;
        }

        #endregion

        #region SignalRecordPacket

        /// <summary>
        ///  查询信号记录包
        /// </summary>
        public Model.SignalRecordPacket QuerySignalRecordPacket(long projectId, long sceneId, long monitorPointId, long signalId)
        {
            var rootFolder = GetMonitorDataFolder(projectId, sceneId);
            var dateFolderInfos = GetDateFolderInfos(rootFolder);
            if (dateFolderInfos == null || dateFolderInfos.Count() < 1)
                return default;

            var signalRecordCount = _monitorDataSetSummary.QuerySignalRecordCount(projectId, sceneId, monitorPointId, signalId);
            if (signalRecordCount < 1)
                return default;

            var signalRecordPacket = new Model.SignalRecordPacket();
            signalRecordPacket.SignalId = signalId;
            signalRecordPacket.RecordList = new List<Model.SignalRecord>(signalRecordCount);

            foreach (var dateFolderInfo in dateFolderInfos)
            {
                var year = dateFolderInfo.Year;
                var month = dateFolderInfo.Month;
                var valid = GetSignalRecordPacketFile(projectId, sceneId, monitorPointId, signalId, year, month, out string filePath);
                if (!valid)
                    continue;
                using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
                using (var sr = new StreamReader(fs, Encoding.UTF8))
                {
                    var strLine = string.Empty;
                    while (!string.IsNullOrEmpty(strLine = sr.ReadLine()))
                    {
                        var content = FromDsString(strLine);
                        signalRecordPacket.RecordList.Add(content);
                    }
                }
            }
            return signalRecordPacket;
        }

        /// <summary>
        ///  查询信号记录包
        /// </summary>
        public Model.SignalRecordPacket QuerySignalRecordPacket(long projectId, long sceneId, long monitorPointId, long signalId, int year, int month)
        {
            var valid = GetSignalRecordPacketFile(projectId, sceneId, monitorPointId, signalId, year, month, out string filePath);
            if (!valid)
                return default;
            var signalRecordCount = _monitorDataSetSummary.QuerySignalRecordCount(projectId, sceneId, monitorPointId, signalId, year, month);
            if (signalRecordCount < 1)
                return default;

            var signalRecordPacket = new Model.SignalRecordPacket();
            signalRecordPacket.SignalId = signalId;
            signalRecordPacket.RecordList = new List<Model.SignalRecord>(signalRecordCount);

            using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
            using (var sr = new StreamReader(fs, Encoding.UTF8))
            {
                var strLine = string.Empty;
                while (!string.IsNullOrEmpty(strLine = sr.ReadLine()))
                {
                    var content = FromDsString(strLine);
                    signalRecordPacket.RecordList.Add(content);
                }
            }
            return signalRecordPacket;
        }

        #endregion

        #region SignalRecord
        
        /// <summary>
        ///  查询信号记录
        /// </summary>
        public List<Model.SignalRecord> QuerySignalRecord(long projectId, long sceneId, long monitorPointId, long signalId, int year, int month)
        {
            var valid = GetSignalRecordPacketFile(projectId, sceneId, monitorPointId, signalId, year, month, out string filePath);
            if (!valid)
                return default;
            var signalRecordCount = _monitorDataSetSummary.QuerySignalRecordCount(projectId, sceneId, monitorPointId, signalId, year, month);
            if (signalRecordCount < 1)
                return default;

            var signalRecordList = new List<Model.SignalRecord>(signalRecordCount);
            using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read))
            using (var sr = new StreamReader(fs, Encoding.UTF8))
            {
                var strLine = string.Empty;
                while (!string.IsNullOrEmpty(strLine = sr.ReadLine()))
                {
                    var content = FromDsString(strLine);
                    signalRecordList.Add(content);
                }
            }
            return signalRecordList;
        }

        #endregion

        #endregion

        #region Save

        /// <summary>
        /// 保存
        /// </summary>
        public bool Save(long projectId, long sceneId, Model.MonitorDataSet monitorDataSet)
        {
            if (monitorDataSet == null)
                return default;
            if (monitorDataSet.PacketList == null || monitorDataSet.PacketList.Count < 1)
                return default;

            var monitorPointId = monitorDataSet.MonitorPointId;
            var year = monitorDataSet.Year;
            var month = monitorDataSet.Month; 
            foreach (var packet in monitorDataSet.PacketList)
            {
                if (!Save(projectId, sceneId, monitorPointId, packet.SignalId, packet.RecordList, year, month))
                {

                }
            }
            return true;
        }
        
        /// <summary>
        /// 保存
        /// </summary>
        public bool Save(long projectId, long sceneId, long monitorPointId, long signalId, List<Model.SignalRecord> signalRecords, int year, int month)
        {
            var valid = GetSignalRecordPacketFile(projectId, sceneId, monitorPointId, signalId, year, month, out string filePath);
            using (var fs = new FileStream(filePath, System.IO.FileMode.Create, System.IO.FileAccess.Write, FileShare.ReadWrite))
            using (var sw = new StreamWriter(fs, System.Text.Encoding.UTF8))
            {
                foreach (var record in signalRecords)
                {
                    var strLine = ToDsString(record);
                    sw.WriteLine(strLine);
                }
            }

            var model = new Model.MonitorDataSetSummary();
            model.MonitorPointId = monitorPointId;
            model.Year = year;
            model.Month = month;
            model.MinTime = signalRecords.Min(x => x.Time);
            model.MaxTime = signalRecords.Max(x => x.Time);
            model.Count = signalRecords.Count();
            if (_monitorDataSetSummary.Set(projectId, sceneId, model, year, month))
                return false;
            return true;
        }
        #endregion

    }
}