using System;
using System.Collections.Generic;
using System.Data;
using System.Data.OracleClient;
using HZQR.Common;

namespace DataBaseTransfer.Method
{
    /// <summary>
    /// oracle数据帮助类
    /// </summary>
    public class OracleHelper
    {
        #region 构造函数
        public OracleHelper(string OracleConnStr)
        {
            ConnStr = OracleConnStr;
        }
        public OracleHelper()
        {

        }

        public OracleHelper(string Server, string Name, string UserName, string UserPwd)
        {
            //传入对应的 服务器名称 实例名  用户名 密码
            ConnStr = "Data Source=(DESCRIPTION = (ADDRESS = (PROTOCOL = TCP)(HOST = " + Server +
                ")(PORT = 1521))(CONNECT_DATA =(SERVER = DEDICATED)(SERVICE_NAME = " + Name +
                "))); User ID=" + UserName + "; PassWord=" + UserPwd;
        }

        public OracleHelper(string Server, string Name, string UserName, string UserPwd, string LoginPort)
        {
            //传入对应的 服务器名称 实例名  用户名 密码
            ConnStr = "Data Source=(DESCRIPTION = (ADDRESS = (PROTOCOL = TCP)(HOST = " + Server +
                ")(PORT = " + LoginPort + "))(CONNECT_DATA =(SERVER = DEDICATED)(SERVICE_NAME = " + Name +
                "))); User ID=" + UserName + "; PassWord=" + UserPwd;
        }

        #endregion

        #region 属性信息
        private string ConnStr = null;
        public string ConnString
        {
            set
            {
                ConnStr = value;
            }
            get
            {
                return ConnStr;
            }
        }
        #endregion

        #region 获得表名
        /// <summary>
        /// 获得数据库表名
        /// </summary>
        /// <returns></returns>
        public DataTable GetTableName()
        {
            using (OracleConnection OracleConn = new OracleConnection(ConnStr))
            {
                try
                {
                    OracleConn.Open();
                    DataTable dt = OracleConn.GetSchema("Tables", null);
                    OracleConn.Close();
                    return dt;
                }
                catch (Exception ex)
                {
                    throw new Exception(ex.Message);
                }
            }
        }

        /// <summary>
        /// 获得数据库表名
        /// </summary>
        /// <returns></returns>
        public DataTable GetViewName()
        {
            using (OracleConnection OracleConn = new OracleConnection(ConnStr))
            {
                try
                {
                    OracleConn.Open();
                    DataTable dt = OracleConn.GetSchema("Views", null);
                    OracleConn.Close();
                    return dt;
                }
                catch (Exception ex)
                {
                    throw new Exception(ex.Message);
                }
            }
        }

        /// <summary>
        /// 获得数据库表名
        /// </summary>
        /// <returns></returns>
        public DataTable GetTableName_Old()
        {
            using (OracleConnection oleConn = new OracleConnection(ConnStr))
            {
                DataSet ds = new DataSet();
                string SQLString = "select a.TABLE_NAME,b.COMMENTS from user_tables a,user_tab_comments b WHERE a.TABLE_NAME=b.TABLE_NAME order by TABLE_NAME ";
                try
                {
                    oleConn.Open();
                    OracleDataAdapter oleDa = new OracleDataAdapter(SQLString, oleConn);
                    oleDa.Fill(ds, "temp");
                }
                catch (System.Data.OracleClient.OracleException ex)
                {
                    throw new Exception(ex.Message);
                }
                return ds.Tables[0];
            }
        }
        #endregion

        #region 测试连接
        /// <summary>
        /// 测试连接
        /// </summary>
        public void TestConn()
        {
            //测试连接
            using (OracleConnection OracleConn = new OracleConnection(ConnStr))
            {
                using (OracleCommand cmd = new OracleCommand())
                {
                    try
                    {
                        OracleConn.Open();
                    }
                    catch (System.Data.OracleClient.OracleException ex)
                    {
                        throw new Exception(ex.Message);
                    }
                    finally
                    {
                        OracleConn.Close();
                    }
                }
            }
        }
        #endregion

        #region 执行SQL
        /// <summary>
        /// 执行SQL语句，返回受影响的行数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        public int ExcuteSql(string SQLString)
        {
            using (OracleConnection OracleConn = new OracleConnection(ConnStr))
            {
                using (OracleCommand cmd = new OracleCommand(SQLString, OracleConn))
                {
                    try
                    {
                        OracleConn.Open();
                        int rows = cmd.ExecuteNonQuery();
                        OracleConn.Close();
                        return rows;
                    }
                    catch (System.Data.OracleClient.OracleException ex)
                    {
                        LogUtil.WriteLog(ex, SQLString, DateTime.Now.ToString("yyyyMMdd") + "_ExcuteSql");

                        throw new Exception(ex.Message);
                    }
                }
            }

        }
        #endregion

        #region 执行SQL，返回对应的数据集
        /// <summary>
        /// 执行SQL，返回对应的数据集
        /// </summary>
        /// <param name="SQLString">执行的SQL语句</param>
        /// <param name="TableName">内存中的表名</param>
        /// <returns>返回对应的数据集</returns>
        public DataSet ExcuteSqlGetDataSet(string SQLString, string TableName = "Template")
        {
            using (OracleConnection oleConn = new OracleConnection(ConnStr))
            {
                DataSet ds = new DataSet();
                try
                {
                    oleConn.Open();
                    OracleDataAdapter oleDa = new OracleDataAdapter(SQLString, oleConn);
                    oleDa.Fill(ds, TableName);
                }
                catch (System.Data.OracleClient.OracleException ex)
                {
                    LogUtil.WriteLog(ex, SQLString, DateTime.Now.ToString("yyyyMMdd") + "_ExcuteSqlGetDataSet");

                    throw new Exception(ex.Message);
                }
                return ds;
            }
        }

        /// <summary>
        /// 默认取 ExcuteSqlGetDataSet（） .Tables[0];
        /// </summary>
        /// <param name="SQLString"></param>
        /// <param name="TableName"></param>
        /// <returns></returns>
        public DataTable ExcuteSqlGetDataTable(string SQLString, string TableName = "Template")
        {
            return ExcuteSqlGetDataSet(SQLString, TableName).Tables[0];
        }
        #endregion

        #region 执行SQL事务
        public void ExecuteSqlTran(string[] SQLStringArray)
        {
            int ExecuteSqlCount = 0;
            //执行sql语句
            ExecuteSqlTran(SQLStringArray, ref ExecuteSqlCount);
        }

        /// <summary>
        /// 执行SQL事务
        /// </summary>
        /// <param name="SQLStringArray">SQL数组</param>
        public void ExecuteSqlTran(string[] SQLStringArray, ref int ExecuteSqlCount)
        {
            using (OracleConnection conn = new OracleConnection(ConnStr))
            {
                conn.Open();
                using (OracleTransaction trans = conn.BeginTransaction())
                {
                    OracleCommand cmd = new OracleCommand();
                    cmd.Transaction = trans;
                    cmd.Connection = conn;

                    string SQLString = "";
                    try
                    {
                        //执行SQL
                        for (int i = 0; i < SQLStringArray.Length; i++)
                        {
                            SQLString = SQLStringArray[i];

                            cmd.CommandText = SQLString;
                            cmd.ExecuteNonQuery();
                        }
                        trans.Commit();
                    }
                    catch (Exception ex)
                    {
                        LogUtil.WriteLog(ex, SQLString, DateTime.Now.ToString("yyyyMMdd") + "_ExecuteSqlTran");

                        trans.Rollback();
                        throw new Exception(ex.Message);
                    }
                    finally
                    {
                        cmd.Dispose();
                        trans.Dispose();
                    }
                }
            }
        }

        public void ExecuteSqlTran(List<string> SQLStringArray)
        {
            int ExecuteSqlCount = 0;
            //执行sql语句
            ExecuteSqlTran(SQLStringArray, ref ExecuteSqlCount);
        }

        public void ExecuteSqlTran(List<string> SQLStringArray, ref int ExecuteSqlCount)
        {
            using (OracleConnection conn = new OracleConnection(ConnStr))
            {
                conn.Open();
                using (OracleTransaction trans = conn.BeginTransaction())
                {
                    OracleCommand cmd = new OracleCommand();
                    cmd.Transaction = trans;
                    cmd.Connection = conn;

                    string SQLString = "";
                    try
                    {
                        //执行SQL
                        for (int i = 0; i < SQLStringArray.Count; i++)
                        {
                            SQLString = SQLStringArray[i];

                            cmd.CommandText = SQLString;
                            ExecuteSqlCount += cmd.ExecuteNonQuery();
                        }
                        trans.Commit();
                    }
                    catch (Exception ex)
                    {
                        LogUtil.WriteLog(ex, SQLString, DateTime.Now.ToString("yyyyMMdd") + "_ExecuteSqlTran");

                        trans.Rollback();
                        throw new Exception(ex.Message);
                    }
                    finally
                    {
                        cmd.Dispose();
                        trans.Dispose();
                    }
                }
            }
        }
        #endregion

        #region OracleParameter 字段值集合ORACLE数据库操作
        /// <summary>
        /// Mr.Cai 2018-7-19
        /// 字段值集合ORACLE数据库操作
        /// </summary>
        /// <param name="OracleSQLInfos">SQL及字段集合</param>
        public void ExecuteSqlTran(List<OracleSQLInfo> OracleSQLInfos)
        {
            using (OracleConnection conn = new OracleConnection(ConnStr))
            {
                conn.Open();
                OracleCommand cmd = new OracleCommand();
                cmd.Connection = conn;
                OracleTransaction tx = conn.BeginTransaction();
                cmd.Transaction = tx;
                try
                {
                    foreach (OracleSQLInfo oracleSqlInfo in OracleSQLInfos)
                    {
                        cmd.CommandText = oracleSqlInfo.sqlString;
                        foreach (OracleParameter oracleParameter in oracleSqlInfo.sqlStringArray)
                        {
                            cmd.Parameters.Add(oracleParameter);
                        }
                        cmd.ExecuteNonQuery();
                    }

                    tx.Commit();
                }
                catch (System.Data.OracleClient.OracleException E)
                {
                    tx.Rollback();
                    throw new Exception(E.Message);
                }
                finally
                {
                    if (conn.State != ConnectionState.Closed)
                    {
                        conn.Close();
                    }
                }
            }
        }
        #endregion

        #region 更新数据表
        public void UpdateDataTable(DataTable dt, string SqlStr)
        {
            using (OracleConnection oracleConn = new OracleConnection(ConnStr))
            {
                oracleConn.Open();
                try
                {
                    OracleDataAdapter oleDa = new OracleDataAdapter(SqlStr, oracleConn);
                    OracleCommandBuilder builder = new OracleCommandBuilder();
                    oleDa.Update(dt);
                }
                catch (System.Data.OleDb.OleDbException ex)
                {
                    throw new Exception(ex.Message);
                }
                finally
                {
                    oracleConn.Close();
                }
            }
        }
        public void UpdateDataTable(DataTable ParentTable, DataTable ChildTable, string[] SqlStr, string mainName)
        {
            using (OracleConnection oleConn = new OracleConnection(ConnStr))
            {
                DataSet oDs = new DataSet();
                oleConn.Open();
                try
                {
                    //父表
                    OracleDataAdapter oleDa = new OracleDataAdapter(SqlStr[0], oleConn);
                    OracleCommandBuilder builder = new OracleCommandBuilder(oleDa);
                    //子表

                    OracleDataAdapter oleDa1 = new OracleDataAdapter(SqlStr[1], oleConn);
                    OracleCommandBuilder builder1 = new OracleCommandBuilder(oleDa);
                    oDs.Tables.Add(ParentTable);
                    oDs.Tables.Add(ChildTable);
                    oDs.Relations.Add(new DataRelation("ParentChild", oDs.Tables[0].Columns[mainName], oDs.Tables[1].Columns[mainName]));
                    oleDa.Update(oDs.Tables[0]);
                    oleDa1.Update(oDs.Tables[1]);
                }
                catch (System.Data.OracleClient.OracleException ex)
                {
                    throw new Exception(ex.Message);
                }
                finally
                {
                    oleConn.Close();
                }
            }
        }
        #endregion

        #region 执行SQL,返回第一行第一列
        /// <summary>
        /// 执行SQL语句，返回受影响的行数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        public object ExcuteSqlBackData(string SQLString)
        {
            using (OracleConnection oleConn = new OracleConnection(ConnStr))
            {
                using (OracleCommand cmd = new OracleCommand())
                {
                    try
                    {
                        cmd.Connection = GetConn(oleConn);
                        cmd.CommandText = SQLString;
                        object rows = cmd.ExecuteScalar();
                        CloseConn(oleConn);
                        return rows;
                    }
                    catch (System.Data.OracleClient.OracleException ex)
                    {
                        throw new Exception(ex.Message);
                    }
                }
            }
        }

        #endregion

        #region 打开数据库及关闭数据库
        public OracleConnection GetConn(OracleConnection oleConn)
        {
            if (oleConn.State == ConnectionState.Closed)
            {
                oleConn.Open();
            }
            return oleConn;
        }
        public void CloseConn(OracleConnection oleConn)
        {
            if (oleConn.State == ConnectionState.Open)
            {
                oleConn.Close();
            }
        }
        #endregion

        #region 修正表的类型
        public void DBTable_GetSchemaFixDataType(DataTable dataTable, string tableName)
        {
            DataTable dataTable2 = ExcuteSqlGetDataSet("Select * from " + tableName + " where 1=2", "temp").Tables[0];
            //DataTable dataTable2 =  _DataBaseHelper.ExecuteDataSet("Select * from " + tableName + " where 1=2").Tables[0];
            bool flag = false;
            foreach (DataRow dataRow in dataTable.Rows)
            {
                dataRow["Column_DefaultValue"] = dataRow["Column_DefaultValue"].ToString().Replace(" ", "").Replace("\"", "");
                dataRow["Column_IsNullable"] = dataRow["Column_IsNullable"].ToString().ToLower().Replace("no", "False").Replace("yes", "True").Replace("n", "False").Replace("y", "True").Replace("false", "False").Replace("true", "True");
                dataRow["Column_IsKey"] = dataRow["Column_IsKey"].ToString().ToLower().Replace("no", "False").Replace("yes", "True").Replace("n", "False").Replace("y", "True").Replace("false", "False").Replace("true", "True");
                if (string.IsNullOrEmpty(dataRow["Column_Comment"].ToString()))
                {
                    dataRow["Column_Comment"] = dataRow["Column_Name"];
                }
                foreach (DataColumn dataColumn in dataTable2.Columns)
                {
                    if (dataRow["Column_Name"].ToString().ToLower() == dataColumn.ColumnName.ToLower())
                    {
                        if (dataRow["Column_DataType"].ToString() != "System.Double")
                        {
                            dataRow["Column_DataType"] = dataColumn.DataType.ToString();
                            break;
                        }
                        break;
                    }
                }
                if (dataRow["Column_IsKey"].ToString() == "True")
                {
                    flag = true;
                }
            }
            if (!flag)
            {
                string text = string.Empty;
                if (tableName.IndexOf("_") >= 0)
                {
                    text = tableName.Substring(tableName.IndexOf("_") + 1);
                }
                else
                {
                    text = tableName;
                }
                text += "_ID";
                foreach (DataRow dataRow2 in dataTable.Rows)
                {
                    if (dataRow2["Column_Name"].ToString() == text)
                    {
                        dataRow2["Column_IsKey"] = "True";
                        break;
                    }
                }
            }
            dataTable.AcceptChanges();
        }
        #endregion

        #region OracleSQLInfo对象
        /// <summary>
        /// OracleSQLInfo对象
        /// </summary>
        public class OracleSQLInfo
        {
            /// <summary>
            /// SQL语句
            /// </summary>
            public string sqlString;
            /// <summary>
            /// SQL语句数组
            /// </summary>
            public List<OracleParameter> sqlStringArray;
        }
        #endregion
    }
}