using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace WeldingCommon.Utils
{
    public class CSV_Manager
    {
        private static CSV_Manager _instance = null;
        //public static SystemSetting _Setting = null;

        public static CSV_Manager GetInstance()
        {
            if (_instance == null) {
                _instance = new CSV_Manager();
            }
            return _instance;
        }

        public CSV_Manager()
        {
            InitStringBuilder();
            //_Setting = Application.Current.AuroraEnv().SettingEntry[SettingIds.System] as SystemSetting;
            //Application.Current.AuroraEnv().EventObservable.AsObservable(Aurora.Api.AuroraSysEvent.SYS_SETTING_CHANGED).Subscribe(UpdateSystemSetting);
        }

        private void InitStringBuilder()
        {
            _sbListToCsvHeader = new StringBuilder();
            _sbListToCsvRow = new StringBuilder();
            _sbObjToCsvHeader = new StringBuilder();
            _sbObjToCsvRow = new StringBuilder();
            _sbDataColumnsToCsvHeader = new StringBuilder();
            _sbDataColumnsToCsvRow = new StringBuilder();
        }

        //private static void UpdateSystemSetting(EventMessage obj)
        //{
        //    _Setting = Application.Current.AuroraEnv().SettingEntry[SettingIds.System] as SystemSetting;
        //}

        public bool Save_ListToCsv<T>(string fullPath, List<T> dataList, bool useHeader = true)
        {
            //if (!_Setting.EnableSaveCSVFile) {
            //    return true;
            //}
            var dir = Path.GetDirectoryName(fullPath);
            var file = Path.GetFileName(fullPath);
            return Save_ListToCsv<T>(dir, file, dataList, useHeader);

        }

        private StringBuilder _sbListToCsvHeader;
        private StringBuilder _sbListToCsvRow;
        public bool Save_ListToCsv<T>(string dirPath, string fileName, List<T> dataList, bool useHeader = true)
        {
            try {
                //if (!_Setting.EnableSaveCSVFile) {
                //    return true;
                //}
                if (dataList == null || dataList.Count == 0) {
                    return false;
                }

                string filePath;
                if (string.IsNullOrEmpty(dirPath)) {
                    filePath = fileName + ".csv";
                } else {
                    filePath = dirPath + "\\" + fileName + ".csv";
                }

                FileStream fileStream;
                StreamWriter streamWriter;
                bool isHeadWrited;

                if (!File.Exists(filePath)) {
                    if (!Directory.Exists(dirPath)) {
                        Directory.CreateDirectory(dirPath);
                    }
                    fileStream = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite);
                    streamWriter = new StreamWriter(fileStream);
                    streamWriter.AutoFlush = true;
                    isHeadWrited = false;
                } else {
                    fileStream = new FileStream(filePath, FileMode.Append, FileAccess.Write, FileShare.ReadWrite);
                    streamWriter = new StreamWriter(fileStream);
                    streamWriter.AutoFlush = true;
                    isHeadWrited = true;
                }

                var piList = dataList[0].GetType().GetProperties();
                if (!isHeadWrited) {
                    if (useHeader == true) {
                        _sbListToCsvHeader.Clear();
                        //string header = string.Empty;
                        foreach (var propertyInfo in piList) {
                            _sbListToCsvHeader.Append(propertyInfo.Name);
                            _sbListToCsvHeader.Append(",");
                            //header += propertyInfo.Name + ",";
                        }
                        //header.TrimEnd(',');
                        streamWriter.WriteLine(_sbListToCsvHeader.ToString().TrimEnd(','));
                    }
                }

                foreach (var item in dataList) {
                    _sbListToCsvRow.Clear();
                    //string itemLine = string.Empty;
                    foreach (var propertyInfo in piList) {
                        _sbListToCsvRow.Append(propertyInfo.GetValue(item).ToString());
                        _sbListToCsvRow.Append(",");
                        //itemLine += propertyInfo.GetValue(item).ToString() + ",";
                    }
                    //itemLine.TrimEnd(',');
                    streamWriter.WriteLine(_sbListToCsvRow.ToString().TrimEnd(','));
                }

                streamWriter.Close();
                fileStream.Close();

                return true;
            } catch {
                return false;
            }
        }

        private StringBuilder _sbObjToCsvHeader;
        private StringBuilder _sbObjToCsvRow;
        public bool Save_ObjToCsv<T>(string dirPath, string filePath, T data, bool useHeader = true)
        {
            try {
                //if (!_Setting.EnableSaveCSVFile) {
                //    return true;
                //}
                if (data == null) {
                    return false;
                }

                FileStream fileStream;
                StreamWriter streamWriter;
                bool isHeadWrited;

                if (!File.Exists(filePath)) {
                    if (!Directory.Exists(dirPath)) {
                        Directory.CreateDirectory(dirPath);
                    }
                    fileStream = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite);
                    isHeadWrited = false;
                } else {
                    fileStream = new FileStream(filePath, FileMode.Append, FileAccess.Write, FileShare.ReadWrite);
                    isHeadWrited = true;
                }

                streamWriter = new StreamWriter(fileStream);
                streamWriter.AutoFlush = true;

                var piList = data.GetType().GetProperties();
                if (!isHeadWrited) {
                    if (useHeader == true) {
                        _sbObjToCsvHeader.Clear();
                        //string header = string.Empty;
                        foreach (var propertyInfo in piList) {
                            _sbObjToCsvHeader.Append(propertyInfo.Name);
                            _sbObjToCsvHeader.Append(",");
                            //header += propertyInfo.Name + ",";
                        }
                        //header.TrimEnd(',');
                        streamWriter.WriteLine(_sbObjToCsvHeader.ToString().TrimEnd(','));
                    }
                }

                _sbObjToCsvRow.Clear();
                //string itemLine = string.Empty;
                foreach (var propertyInfo in piList) {
                    _sbObjToCsvRow.Append(propertyInfo.GetValue(data).ToString());
                    _sbObjToCsvRow.Append(",");
                    //itemLine += propertyInfo.GetValue(item).ToString() + ",";
                }
                //itemLine.TrimEnd(',');
                streamWriter.WriteLine(_sbObjToCsvRow.ToString().TrimEnd(','));

                streamWriter.Close();
                fileStream.Close();

                return true;
            } catch {
                return false;
            } finally {

            }
        }

        public List<T> Load_ListFromCsv<T>(string filePath) where T : class
        {
            //if (!_Setting.EnableSaveCSVFile) {
            //    return null;
            //}

            if (!File.Exists(filePath)) {
                return null;
            }

            try {
                string[] lines = File.ReadAllLines(filePath);
                if (lines.Length < 2) {
                    return null;
                }

                List<T> resultList = new List<T>();
                string[] headerItems = lines[0].Split(',');

                int headerItemsLength = headerItems.Length;
                if (headerItems[headerItemsLength - 1] == string.Empty) {
                    headerItemsLength = headerItemsLength - 1;
                }

                for (int i = 1; i < lines.Length; i++) {
                    string[] dataList = lines[i].Split(',');
                    object item = Activator.CreateInstance(typeof(T));
                    for (int j = 0; j < headerItemsLength; j++) {
                        System.Reflection.PropertyInfo property = item.GetType().GetProperty(headerItems[j]);
                        if (property.CanWrite) {
                            property.SetValue(item, Convert.ChangeType(dataList[j], property.PropertyType));
                        }
                    }

                    resultList.Add((T)item);
                }
                return resultList;
            } catch (Exception e) {
                return null;
            }
        }


        private StringBuilder _sbDataColumnsToCsvHeader;
        private StringBuilder _sbDataColumnsToCsvRow;
        public bool Save_DataColumnsToCsv(string dirPath, string fileName, DataColumnCollection dataCols)
        {
            try {
                //if (!_Setting.EnableSaveCSVFile) {
                //    return true;
                //}
                if (dataCols == null || dataCols.Count == 0) {
                    return false;
                }

                string filePath;
                if (string.IsNullOrEmpty(dirPath)) {
                    filePath = $"{fileName}.csv";
                } else {
                    filePath = $"{dirPath}\\{fileName}.csv";
                }

                FileStream fileStream;
                StreamWriter streamWriter;
                bool isHeadWrited;

                if (!File.Exists(filePath)) {
                    if (!Directory.Exists(dirPath)) {
                        Directory.CreateDirectory(dirPath);
                    }
                    fileStream = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite);
                    isHeadWrited = false;
                } else {
                    fileStream = new FileStream(filePath, FileMode.Append, FileAccess.Write, FileShare.ReadWrite);
                    isHeadWrited = true;
                }
                streamWriter = new StreamWriter(fileStream);
                streamWriter.AutoFlush = true;

                if (!isHeadWrited) {
                    _sbDataColumnsToCsvRow.Clear();
                    //string header = string.Empty;
                    foreach (DataColumn col in dataCols) {
                        _sbDataColumnsToCsvRow.Append(col.ColumnName);
                        _sbDataColumnsToCsvRow.Append(",");
                        //header += col.ColumnName + ",";
                    }
                    //header.TrimEnd(',');
                    streamWriter.WriteLine(_sbDataColumnsToCsvRow.ToString().TrimEnd(','));
                }

                streamWriter.Close();
                fileStream.Close();

                return true;
            } catch {
                return false;
            }
        }

        public bool Save_DataRowToCsv(string dirPath, string fileName, DataRow dataRow)
        {
            try {
                //if (!_Setting.EnableSaveCSVFile) {
                //    return true;
                //}
                if (dataRow == null) {
                    return false;
                }

                string filePath;
                if (string.IsNullOrEmpty(dirPath)) {
                    filePath = fileName + ".csv";
                } else {
                    filePath = dirPath + "\\" + fileName + ".csv";
                }

                if (!File.Exists(filePath)) {
                    return false;
                }

                FileStream fileStream;
                StreamWriter streamWriter;

                fileStream = new FileStream(filePath, FileMode.Append, FileAccess.Write, FileShare.ReadWrite);
                streamWriter = new StreamWriter(fileStream);
                streamWriter.AutoFlush = true;

                string itemLine = string.Join(",", dataRow.ItemArray);
                streamWriter.WriteLine(itemLine);

                streamWriter.Close();
                fileStream.Close();

                return true;
            } catch {
                return false;
            }
        }

        public bool Save_DataTableToCsv(string fullPath, DataTable dataTable)
        {
            //if (!_Setting.EnableSaveCSVFile) {
            //    return true;
            //}
            var dir = Path.GetDirectoryName(fullPath);
            var file = Path.GetFileName(fullPath);
            return Save_DataTableToCsv(dir, file, dataTable);
        }

        public bool Save_DataTableToCsv(string dirPath, string fileName, DataTable dataTable)
        {
            try {
                //if (!_Setting.EnableSaveCSVFile) {
                //    return true;
                //}
                if (dataTable == null || dataTable.Columns.Count == 0 || dataTable.Rows.Count == 0) {
                    return false;
                }

                string filePath;
                if (string.IsNullOrEmpty(dirPath)) {
                    filePath = fileName + ".csv";
                } else {
                    filePath = dirPath + "\\" + fileName + ".csv";
                }

                FileStream fileStream;
                StreamWriter streamWriter;
                bool isHeadWrited;

                if (!File.Exists(filePath)) {
                    if (!Directory.Exists(dirPath)) {
                        Directory.CreateDirectory(dirPath);
                    }
                    fileStream = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite);
                    streamWriter = new StreamWriter(fileStream);
                    streamWriter.AutoFlush = true;
                    isHeadWrited = false;
                } else {
                    fileStream = new FileStream(filePath, FileMode.Append, FileAccess.Write, FileShare.ReadWrite);
                    streamWriter = new StreamWriter(fileStream);
                    streamWriter.AutoFlush = true;
                    isHeadWrited = true;
                }

                if (!isHeadWrited) {
                    string header = string.Empty;
                    foreach (DataColumn col in dataTable.Columns) {
                        header += col.ColumnName + ",";
                    }
                    header.TrimEnd(',');
                    streamWriter.WriteLine(header);
                }

                foreach (DataRow row in dataTable.Rows) {
                    string itemLine = string.Join(",", row.ItemArray);
                    streamWriter.WriteLine(itemLine);
                }

                streamWriter.Close();
                fileStream.Close();

                return true;
            } catch {
                return false;
            }
        }

        private string[] WriteSafeReadAllLines(String path)
        {
            //if (!_Setting.EnableSaveCSVFile) {
            //    return null;
            //}
            using (var csv = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
            using (var sr = new StreamReader(csv)) {
                List<string> file = new List<string>();
                while (!sr.EndOfStream) {
                    file.Add(sr.ReadLine());
                    System.Threading.Thread.Sleep(5);
                }
                return file.ToArray();
            }
        }

        internal DataTable Load_DataTableFromCsv(string filePath)
        {
            //if (!_Setting.EnableSaveCSVFile) {
            //    return null;
            //}
            if (!File.Exists(filePath)) {
                return null;
            }

            try {
                string[] lines = WriteSafeReadAllLines(filePath);
                if (lines.Length < 2) {
                    return null;
                }

                DataTable dataTable = new DataTable();
                string[] headerItems = lines[0].Split(',');
                foreach (var col in headerItems) {
                    if (col == "Time") {
                        dataTable.Columns.Add(col, typeof(DateTime));
                    } else {
                        dataTable.Columns.Add(col, typeof(double));
                    }
                }

                for (int i = 1; i < lines.Length; i++) {
                    string[] dataList = lines[i].Split(',');
                    var row = dataTable.NewRow();
                    for (int j = 0; j < headerItems.Length - 1; j++) {
                        if (!string.IsNullOrEmpty(dataList[j])) {
                            row[dataTable.Columns[j]] = dataList[j];
                        }
                    }
                    dataTable.Rows.Add(row);
                }
                return dataTable;
            } catch {
                return null;
            }
        }
    }
}