using Microsoft.Extensions.Configuration;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Data.SqlClient;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace CoreWebAPI1.Models
{
    public class dbhelper
    {
        //SqlConnection con;
        string connectionstring;
        public DataSet dsdaten = new DataSet();
        private SqlDataAdapter dadaten;
        public dbhelper()
        {
            var configuation = GetConfiguration();
            connectionstring = configuation.GetSection("ConnectionStrings").GetSection("DBConnection").Value;
        }

       

        public static DataTable ObjectToDataTable(object o)
        {
            DataTable dt = new DataTable();
            List<PropertyInfo> properties = o.GetType().GetProperties().ToList();

            foreach (PropertyInfo prop in properties)

                dt.Columns.Add(prop.Name, prop.PropertyType);

            dt.TableName = o.GetType().Name;

            return dt;
        }
        public IConfigurationRoot GetConfiguration()
        {
            var builder = new ConfigurationBuilder().SetBasePath(Directory.GetCurrentDirectory()).AddJsonFile("appsettings.json", optional: true, reloadOnChange: true);
            return builder.Build();
        }

        public DataTable Get_Tabledata(string Tablename, bool StoredProc = false, bool is_SQL_String = false)
        {
            SqlConnection sqlconnect = new SqlConnection();
            DataSet ds = new DataSet();
            ds.Tables.Clear();
            sqlconnect.ConnectionString = this.connectionstring;
            sqlconnect.Open();
            SqlDataAdapter da = new SqlDataAdapter("", sqlconnect);
            SqlCommand sqlcmd = new SqlCommand();
            sqlcmd.Connection = sqlconnect;
            if (StoredProc == true)
            {
                sqlcmd.CommandType = CommandType.StoredProcedure;
                if (Tablename.IndexOf("@@Mandantnr@@") > 0)
                    Tablename = Tablename.Replace("@@Mandantnr@@", "");
                sqlcmd.CommandText = Tablename;
            }
            else
            {
                sqlcmd.CommandType = CommandType.Text;
                sqlcmd.CommandText = "Select * from " + Tablename;
            }
            if (is_SQL_String == true)
                sqlcmd.CommandText = Tablename;
            da.SelectCommand = sqlcmd;
            da.Fill(dsdaten, "Daten");
            sqlconnect.Close();
            return dsdaten.Tables[0];
        }

        public void Get_Tabeldata_for_Update(string Tablename, bool StoredProc = false, bool is_SQL_String = false)
        {
            dsdaten.Clear();
            dsdaten.Tables.Clear();
            dadaten = new SqlDataAdapter(Tablename, this.connectionstring);
            dadaten.Fill(dsdaten, Tablename);
        }
        public void Update_Tabeldata()
        {
            SqlCommandBuilder cb = new SqlCommandBuilder(dadaten);
            dadaten.Update(dsdaten, dsdaten.Tables[0].TableName);
        }

        public Dictionary<string, List<object>> DatatableToDictionary(DataTable dataTable)
        {
            var dict = new Dictionary<string, List<object>>();
            foreach (DataColumn dataColumn in dataTable.Columns)
            {
                var columnValueList = new List<object>();

                foreach (DataRow dataRow in dataTable.Rows)
                {
                    columnValueList.Add(dataRow[dataColumn.ColumnName]);
                }

                dict.Add(dataColumn.ColumnName, columnValueList);
            }
            return dict;
        }
        #region "Converters"

        public List<T> ConvertDataTable<T>(DataTable dt)
        {
            List<T> data = new List<T>();

            foreach (DataRow row in dt.Rows)
            {
                T item = GetItem<T>(row);
                data.Add(item);
            }

            return data;
        }

        private T GetItem<T>(DataRow dr)
        {
            Type temp = typeof(T);
            T obj = Activator.CreateInstance<T>();

            foreach (DataColumn column in dr.Table.Columns)
            {
                foreach (PropertyInfo pro in temp.GetProperties())
                {
                    if (pro.Name == column.ColumnName)
                        pro.SetValue(obj, dr[column.ColumnName], null/* TODO Change to default(_) if this is not a reference type */);
                    else
                        continue;
                }
            }

            return obj;
        }

        public IEnumerable<T> GetEntities<T>(DataTable dt)
        {
            if (dt == null)
            {
                return null;
            }

            List<T> returnValue = new List<T>();
            List<string> typeProperties = new List<string>();

            T typeInstance = Activator.CreateInstance<T>();

            foreach (DataColumn column in dt.Columns)
            {
                var prop = typeInstance.GetType().GetProperty(column.ColumnName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public);
                if (prop != null)
                {
                    typeProperties.Add(column.ColumnName);
                }
            }

            foreach (DataRow row in dt.Rows)
            {
                T entity = Activator.CreateInstance<T>();

                foreach (var propertyName in typeProperties)
                {

                    if (row[propertyName] != DBNull.Value)
                    {
                        string str = row[propertyName].GetType().FullName;

                        if (entity.GetType().GetProperty(propertyName).PropertyType == typeof(System.String))
                        {
                            object Val = row[propertyName].ToString();
                            entity.GetType().GetProperty(propertyName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public).SetValue(entity, Val, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public, null, null, null);
                        }
                        else if (entity.GetType().GetProperty(propertyName).PropertyType == typeof(System.Guid))
                        {
                            object Val = Guid.Parse(row[propertyName].ToString());
                            entity.GetType().GetProperty(propertyName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public).SetValue(entity, Val, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public, null, null, null);
                        }
                        else
                        {
                            entity.GetType().GetProperty(propertyName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public).SetValue(entity, row[propertyName], BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public, null, null, null);
                        }
                    }
                    else
                    {
                        entity.GetType().GetProperty(propertyName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public).SetValue(entity, null, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Public, null, null, null);
                    }
                }

                returnValue.Add(entity);
            }

            return returnValue.AsEnumerable();
        }
        public string DataTableToJSONWithStringBuilder(DataTable table)
        {
            var JSONString = new StringBuilder();
            if (table.Rows.Count > 0)
            {
                JSONString.Append("[");
                for (int i = 0; i < table.Rows.Count; i++)
                {
                    JSONString.Append("{");
                    for (int j = 0; j < table.Columns.Count; j++)
                    {
                        if (j < table.Columns.Count - 1)
                        {
                            JSONString.Append("\"" + table.Columns[j].ColumnName.ToString() + "\":" + "\"" + table.Rows[i][j].ToString() + "\",");
                        }
                        else if (j == table.Columns.Count - 1)
                        {
                            JSONString.Append("\"" + table.Columns[j].ColumnName.ToString() + "\":" + "\"" + table.Rows[i][j].ToString() + "\"");
                        }
                    }
                    if (i == table.Rows.Count - 1)
                    {
                        JSONString.Append("}");
                    }
                    else
                    {
                        JSONString.Append("},");
                    }
                }
                JSONString.Append("]");
            }
            return JSONString.ToString();
        }
        public string ConvertDataTableToString(DataTable table)
        {
            int iColumnCount = table.Columns.Count;
            int iRowCount = table.Rows.Count;
            int iTempRowCount = 0;
            string strColumName = table.Columns[0].ColumnName;
            string strOut = "{";
            foreach (DataRow row in table.Rows)
            {
                strOut = strOut + "{";
                foreach (DataColumn col in table.Columns)
                {
                    string val = row.Field<string>(col.ColumnName);
                    strOut = strOut + col.ColumnName + ":" + val;

                    if (col.Ordinal != iColumnCount - 1)
                    {
                        strOut = strOut + ",";
                    }
                }
                strOut = strOut + "}";
                iTempRowCount++;

                if (iTempRowCount != iRowCount)
                {
                    strOut = strOut + ",";
                }
            }
            strOut = strOut + "}";
            return strOut;
        }
        #endregion

    }
}