using Aitex.Core.RT.Log;
using Npgsql;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data.Common;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Aitex.Core.RT.DBCore
{
    public class PostgreSQLHelper : IDataBase
    {
        /// <summary>
        /// 数据库名称
        /// </summary>
        public string DBName;

        /// <summary>
        /// 连接字符串
        /// </summary>
        private string _connString = ConfigurationManager.ConnectionStrings["PostgreSQL"].ConnectionString;

        public PostgreSQLHelper(string dBName)
        {
            DBName = dBName;
        }

        /// <summary>
        /// 准备Command
        /// </summary>
        /// <param name="cmd"></param>
        /// <param name="conn"></param>
        /// <param name="sql"></param>
        /// <param name="cmdParams"></param>
        /// <param name="trans"></param>
        private void PrepareCommand(NpgsqlCommand cmd, NpgsqlConnection conn, string sql,
            NpgsqlTransaction trans = null, NpgsqlParameter[] cmdParams = null, bool isChangeDB = true)
        {
            if (conn.State != ConnectionState.Open)
            {
                conn.Open();
            }

            //切换数据库
            if (isChangeDB)
            {
                conn.ChangeDatabase(DBName);
            }

            cmd.Connection = conn;
            cmd.CommandText = sql;
            cmd.CommandType = CommandType.Text;

            //事务
            if (trans != null)
            {
                cmd.Transaction = trans;
            }

            //参数
            if (cmdParams != null)
            {
                foreach (NpgsqlParameter param in cmdParams)
                {
                    if (param.Value == null)
                    {
                        param.Value = DBNull.Value;
                    }
                }

                cmd.Parameters.AddRange(cmdParams);
            }
        }

        /// <summary>
        /// 执行SQL语句
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public int ExecuteNonQuery(string sql, bool isChangeDB = true)
        {
            using (NpgsqlConnection conn = new NpgsqlConnection(_connString))
            {
                using (NpgsqlCommand cmd = new NpgsqlCommand())
                {
                    int count = 0;

                    try
                    {
                        PrepareCommand(cmd, conn, sql, null, null, isChangeDB);
                        count = cmd.ExecuteNonQuery();
                    }
                    catch (Exception ex)
                    {
                        LOG.Error("执行SQL语句出错," + sql, ex);
                    }
                    finally
                    {
                        cmd.Parameters.Clear();
                        conn.Close();
                    }

                    return count;
                }
            }
        }

        /// <summary>
        /// 返回查询结果的首行首列数据
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public object ExecuteScalar(string sql)
        {
            using (NpgsqlConnection conn = new NpgsqlConnection(_connString))
            {
                using (NpgsqlCommand cmd = new NpgsqlCommand())
                {
                    object obj = null;

                    try
                    {
                        PrepareCommand(cmd, conn, sql);
                        obj = cmd.ExecuteScalar();
                    }
                    catch (Exception ex)
                    {
                        LOG.Error("执行查询出错," + sql, ex);
                    }
                    finally
                    {
                        cmd.Parameters.Clear();
                        conn.Close();
                    }

                    return obj;
                }
            }
        }

        /// <summary>
        /// 查询结果返回NpgsqlDataReader
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="args"></param>
        /// <returns></returns>
        public DbDataReader ExecuteReader(string sql)
        {
            using (NpgsqlConnection conn = new NpgsqlConnection(_connString))
            {
                using (NpgsqlCommand cmd = new NpgsqlCommand())
                {
                    DbDataReader reader = null;

                    try
                    {
                        PrepareCommand(cmd, conn, sql);
                        reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                    }
                    catch (Exception ex)
                    {
                        LOG.Error("执行查询出错," + sql, ex);
                    }

                    return reader;
                }
            }
        }

        /// <summary>
        /// 查询结果返回DataSet
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public DataSet ExecuteDataSet(string sql)
        {
            using (NpgsqlConnection conn = new NpgsqlConnection(_connString))
            {
                using (NpgsqlCommand cmd = new NpgsqlCommand())
                {
                    DataSet ds = new DataSet();
                    try
                    {
                        PrepareCommand(cmd, conn, sql);
                        NpgsqlDataAdapter adapter = new NpgsqlDataAdapter(cmd);
                        adapter.Fill(ds);
                    }
                    catch (Exception ex)
                    {
                        LOG.Error("执行查询出错," + sql, ex);
                    }
                    finally
                    {
                        cmd.Parameters.Clear();
                        conn.Close();
                    }

                    return ds;
                }
            }
        }

        /// <summary>
        /// 查询结果返回DataTable
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public DataTable ExecuteDataTable(string sql)
        {
            using (NpgsqlConnection conn = new NpgsqlConnection(_connString))
            {
                using (NpgsqlCommand cmd = new NpgsqlCommand())
                {
                    DataSet ds = new DataSet();
                    try
                    {
                        PrepareCommand(cmd, conn, sql);
                        NpgsqlDataAdapter adapter = new NpgsqlDataAdapter(cmd);
                        adapter.Fill(ds);
                    }
                    catch (Exception ex)
                    {
                        LOG.Error("执行查询出错," + sql, ex);
                    }
                    finally
                    {
                        cmd.Parameters.Clear();
                        conn.Close();
                    }

                    return ds.Tables.Count > 0 ? ds.Tables[0] : null;
                }
            }
        }

        /// <summary>
        /// 执行事务
        /// </summary>
        /// <param name="sqlList"></param>
        /// <returns></returns>
        public bool ExcuteTransAction(List<string> sqlList)
        {
            bool result = false;

            using (NpgsqlConnection conn = new NpgsqlConnection(_connString))
            {
                using (NpgsqlTransaction trans = conn.BeginTransaction())
                {
                    NpgsqlCommand cmd = new NpgsqlCommand();
                    try
                    {
                        //循环
                        foreach (string sql in sqlList)
                        {
                            PrepareCommand(cmd, conn, sql);
                            int val = cmd.ExecuteNonQuery();
                            cmd.Parameters.Clear();
                        }
                        trans.Commit();
                        result = true;
                    }
                    catch (Exception ex)
                    {
                        trans.Rollback();
                        LOG.Error("执行事务出错," + sqlList, ex);

                        result = false;
                    }
                    finally
                    {
                        conn.Close();
                    }

                    return result;
                }
            }
        }

    }
}