using DbAPI.Connections;
using DbAPI.Errors;
using DbAPI.Logging;
using DTS.Common.Classes.Channels;
using DTS.Common.Interface.Database;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Diagnostics;
using DTS.Common.Interface.Channels;
using DTS.Common.Classes.Groups.ChannelSettings;
using DTS.Common.Enums.Channels;
using DTS.Common.Interface.Channels.ChannelCodes;
using DTS.Common.Classes.ChannelCodes;
using DTS.Common.Classes;
using DTS.Common;
using DTS.Common.Enums.DASFactory;

namespace DbAPI.Channels
{
    /// <summary>
    /// Handles channel functions
    /// </summary>
    internal class Channels : IChannels
    {
        /// <summary>
        /// insert a new channel code, channel code is modified with a new id if successful
        /// </summary>
        /// <param name="user">user submitting request</param>
        /// <param name="connection">connection being submitted on</param>
        /// <param name="channelCode">channel code to insert</param>
        /// <param name="lookup">mapping of code type to code type integer</param>
        /// <param name="id">new id of channel code record  inserted</param>
        /// <returns>0 (ERROR_SUCCESS) on success, all other values are error codes</returns>
        public ulong ChannelCodesInsert(IUserDbRecord user, IConnectionDetails connection,
            IReadOnlyDictionary<ChannelEnumsAndConstants.ChannelCodeType, short> lookup, IChannelCode channelCode,
            out int id)
        {
            id = -1;
            if (null == channelCode) { return ErrorCodes.ERROR_MISSING_PARAMETER; }
            if (string.IsNullOrEmpty(channelCode.Code) || string.IsNullOrEmpty(channelCode.Name))
            {
                return ErrorCodes.ERROR_MISSING_PARAMETER;
            }
            if (!DbAPI.Connections.IsUserLoggedIn(user, connection))
            {
                return ErrorCodes.ERROR_ACCESS_DENIED;
            }
            var ret = ConnectionManager.GetSqlCommand(connection, out var cmd, "sp_ChannelCodesInsert");
            if (ret != ErrorCodes.ERROR_SUCCESS)
            {
                return ret;
            }
            try
            {
                cmd.CommandType = CommandType.StoredProcedure;

                cmd.Parameters.Add(new SqlParameter("@Code", SqlDbType.NVarChar, 255) { Value = channelCode.Code });
                cmd.Parameters.Add(new SqlParameter("@Name", SqlDbType.NVarChar, 255) { Value = channelCode.Name });
                cmd.Parameters.Add(new SqlParameter("@CodeType", SqlDbType.Int) { Value = lookup[channelCode.CodeType] });
                var errorNumber = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
                cmd.Parameters.Add(errorNumber);
                var errorMessage =
                    new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255)
                    {
                        Direction = ParameterDirection.Output
                    };
                cmd.Parameters.Add(errorMessage);
                var newId = new SqlParameter("@new_id", SqlDbType.Int) { Direction = ParameterDirection.Output };
                cmd.Parameters.Add(newId);

                _ = cmd.ExecuteNonQuery();
                if (!DBNull.Value.Equals(errorNumber.Value) && 0 != Convert.ToInt32(errorNumber.Value))
                {
                    LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups,
                        $"ChannelCodesInsert - Error - {errorNumber.Value} - {errorMessage.Value}");
                    return ErrorCodes.ERROR_UNKNOWN;
                }
                if (DBNull.Value.Equals(newId.Value))
                {
                    LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups,
                        $"ChannelCodesInsert - Error, null new id");
                    return ErrorCodes.ERROR_UNKNOWN;
                }
                id = Convert.ToInt32(newId.Value);
                return ErrorCodes.ERROR_SUCCESS;
            }
            catch (Exception ex)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups,
                    $"ChannelCodesInsert - Error - {ex.Message}");
                return ErrorCodes.ERROR_UNKNOWN;
            }
            finally
            {
                cmd.Connection.Dispose();
                cmd.Dispose();
            }
        }
        /// <summary>
        /// Update a channel record in the database
        /// </summary>
        /// <param name="user">user committing change</param>
        /// <param name="connection">connection change is committed on</param>
        /// <param name="channelCode">channel code being record being updated</param>
        /// <param name="lookup">mapping of code type to code type integer</param>
        /// <returns>0 (ERROR_SUCCESS) on success, all other values are error codes</returns>
        public ulong ChannelCodesUpdate(IUserDbRecord user, IConnectionDetails connection,
            IReadOnlyDictionary<ChannelEnumsAndConstants.ChannelCodeType, short> lookup, IChannelCode channelCode)
        {
            if (null == channelCode) { return ErrorCodes.ERROR_MISSING_PARAMETER; }
            if (string.IsNullOrEmpty(channelCode.Code) || string.IsNullOrEmpty(channelCode.Name))
            {
                return ErrorCodes.ERROR_MISSING_PARAMETER;
            }
            if (!DbAPI.Connections.IsUserLoggedIn(user, connection))
            {
                return ErrorCodes.ERROR_ACCESS_DENIED;
            }
            var ret = ConnectionManager.GetSqlCommand(connection, out var cmd, "sp_ChannelCodesUpdate");
            if (ret != ErrorCodes.ERROR_SUCCESS)
            {
                return ret;
            }
            try
            {
                cmd.CommandType = CommandType.StoredProcedure;

                cmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int) { Value = channelCode.Id });
                cmd.Parameters.Add(new SqlParameter("@Code", SqlDbType.NVarChar, 255) { Value = channelCode.Code });
                cmd.Parameters.Add(new SqlParameter("@Name", SqlDbType.NVarChar, 255) { Value = channelCode.Name });
                cmd.Parameters.Add(new SqlParameter("@CodeType", SqlDbType.Int) { Value = lookup[channelCode.CodeType] });
                var errorNumber =
                    new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
                cmd.Parameters.Add(errorNumber);
                var errorMessage =
                    new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255)
                    {
                        Direction = ParameterDirection.Output
                    };
                cmd.Parameters.Add(errorMessage);

                _ = cmd.ExecuteNonQuery();
                if (!DBNull.Value.Equals(errorNumber.Value) && 0 != Convert.ToInt32(errorNumber.Value))
                {
                    LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups,
                        $"ChannelCodesInsert - Error - {errorNumber.Value} - {errorMessage.Value}");
                    return ErrorCodes.ERROR_UNKNOWN;
                }
                return ErrorCodes.ERROR_SUCCESS;
            }
            catch (Exception ex)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups,
                    $"ChannelCodesInsert - Error - {ex.Message}");
                return ErrorCodes.ERROR_UNKNOWN;
            }
            finally
            {
                cmd.Connection.Dispose();
                cmd.Dispose();
            }
        }

        /// <summary>
        /// deletes matching channel codes
        /// </summary>
        /// <param name="user">user making deletes</param>
        /// <param name="connection">connection to delete on</param>
        /// <param name="id">id of channel code</param>
        /// <param name="code">code of matching channel codes (can be null)</param>
        /// <param name="name">name of matching channel codes (can be null)</param>
        /// <param name="codeType">code type of matching channel codes (can be null)</param>
        /// <returns>0 (ERROR_SUCCESS) on success, all other values are error codes</returns>
        public ulong ChannelCodesDelete(IUserDbRecord user,
            IConnectionDetails connection,
            int? id,
            string code,
            string name,
            int? codeType)
        {
            var ret = ConnectionManager.GetSqlCommand(connection, out var cmd, "sp_ChannelCodesDelete");
            if (!DbAPI.Connections.IsUserLoggedIn(user, connection))
            {
                return ErrorCodes.ERROR_ACCESS_DENIED;
            }
            if (ret != ErrorCodes.ERROR_SUCCESS)
            {
                return ret;
            }
            try
            {
                cmd.CommandType = CommandType.StoredProcedure;
                if (null != id)
                {
                    cmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int) { Value = (int)id });
                }
                else { cmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int) { Value = null }); }

                cmd.Parameters.Add(new SqlParameter("@Code", SqlDbType.NVarChar, 255) { Value = code });
                cmd.Parameters.Add(new SqlParameter("@Name", SqlDbType.NVarChar, 255) { Value = name });
                if (null == codeType)
                {
                    cmd.Parameters.Add(new SqlParameter("@CodeType", SqlDbType.Int) { Value = null });
                }
                else { cmd.Parameters.Add(new SqlParameter("@CodeType", SqlDbType.Int) { Value = (int)codeType }); }

                var errorNumber =
                    new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
                cmd.Parameters.Add(errorNumber);
                var errorMessage =
                    new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255)
                    {
                        Direction = ParameterDirection.Output
                    };
                cmd.Parameters.Add(errorMessage);

                _ = cmd.ExecuteNonQuery();
                if (!DBNull.Value.Equals(errorNumber.Value) && 0 != Convert.ToInt32(errorNumber.Value))
                {
                    LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups,
                        $"ChannelCodesDelete - Error - {errorNumber.Value} - {errorMessage.Value}");
                    return ErrorCodes.ERROR_UNKNOWN;
                }
                return ErrorCodes.ERROR_SUCCESS;
            }
            catch (Exception ex)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups,
                    $"ChannelCodesDelete error - {ex.Message}");
                return ErrorCodes.ERROR_UNKNOWN;
            }
            finally
            {
                cmd.Connection.Dispose();
                cmd.Dispose();
            }
        }
        /// <summary>
        /// retrieves all matching channel code types (int identifier and string identifier)
        /// </summary>
        /// <param name="user">user making request</param>
        /// <param name="connection">connection request is being made on</param>
        /// <param name="codeType">code type (use null for all)</param>
        /// <param name="id">id (use null for all)</param>
        /// <param name="records">all matching records</param>
        /// <returns>0 (ERROR_SUCCESS) on success, all other values are error codes</returns>
        public ulong ChannelCodeTypesGet(IUserDbRecord user,
            IConnectionDetails connection,
            short? id,
            string codeType,
            out Tuple<short, string>[] records)
        {
            records = null;
            if (!DbAPI.Connections.IsUserLoggedIn(user, connection))
            {
                return ErrorCodes.ERROR_ACCESS_DENIED;
            }
            var ret = ConnectionManager.GetSqlCommand(connection, out var cmd, "sp_ChannelCodeTypeGet");
            if (ret != ErrorCodes.ERROR_SUCCESS)
            {
                return ret;
            }
            try
            {
                cmd.CommandType = CommandType.StoredProcedure;
                if (null == id)
                {
                    cmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.TinyInt) { Value = null });
                }
                else
                {
                    cmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.TinyInt) { Value = (short)id });
                }
                cmd.Parameters.Add(new SqlParameter("@CodeType", SqlDbType.NVarChar, 50) { Value = codeType });

                var reader = cmd.ExecuteReader();
                var list = new List<Tuple<short, string>>();
                while (reader.Read())
                {
                    var itemId = Utility.GetShort(reader, "Id");
                    var cType = Utility.GetString(reader, "CodeType");
                    list.Add(new Tuple<short, string>(itemId, cType));
                }
                records = list.ToArray();
                return ErrorCodes.ERROR_SUCCESS;
            }
            catch (Exception ex)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelCodeTypesGet failed: {ex.Message}");
                return ErrorCodes.ERROR_UNKNOWN;
            }
            finally
            {
                cmd.Connection.Dispose();
                cmd.Dispose();
            }
        }
        /// <summary>
        /// retrieves all matching channel codes
        /// </summary>
        /// <param name="user">user making request</param>
        /// <param name="connection">connection query is being made on</param>
        /// <param name="Id">id of channel code (use null for all)</param>
        /// <param name="code">code of channel code (use null for all)</param>
        /// <param name="name">name of channel code (use null for all)</param>
        /// <param name="codeType">code type of channel code (use null for all)</param>
        /// <param name="channelTypeLookup">lookup of a short to a string for a channel code type</param>
        /// <param name="records">matching records</param>
        /// <returns>0 (ERROR SUCCESS) on success, all other values are error codes</returns>
        public ulong ChannelCodesGet(IUserDbRecord user,
            IConnectionDetails connection,
            int? Id,
            string code,
            string name,
            ChannelEnumsAndConstants.ChannelCodeType? codeType,
            IReadOnlyDictionary<short, string> channelTypeLookup,
            out IChannelCode[] records
            )
        {
            records = null;
            if (!DbAPI.Connections.IsUserLoggedIn(user, connection))
            {
                return ErrorCodes.ERROR_ACCESS_DENIED;
            }
            if (null == channelTypeLookup)
            {
                return ErrorCodes.ERROR_MISSING_PARAMETER;
            }
            var ret = ConnectionManager.GetSqlCommand(connection, out var cmd, "sp_ChannelCodesGet");
            if (ret != ErrorCodes.ERROR_SUCCESS)
            {
                return ret;
            }
            try
            {
                cmd.CommandType = CommandType.StoredProcedure;

                if (null == Id)
                {
                    cmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int) { Value = null });
                }
                else { cmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int) { Value = (int)Id }); }

                cmd.Parameters.Add(new SqlParameter("@Code", SqlDbType.NVarChar, 255) { Value = code });
                cmd.Parameters.Add(new SqlParameter("@Name", SqlDbType.NVarChar, 255) { Value = name });
                if (null == codeType)
                {
                    cmd.Parameters.Add(new SqlParameter("@CodeType", SqlDbType.SmallInt) { Value = null });
                }
                else { cmd.Parameters.Add(new SqlParameter("@CodeType", SqlDbType.SmallInt) { Value = (short)codeType }); }

                var reader = cmd.ExecuteReader();
                var list = new List<IChannelCode>();
                while (reader.Read())
                {
                    list.Add(new ChannelCode(reader, channelTypeLookup));
                }
                records = list.ToArray();
                return ErrorCodes.ERROR_SUCCESS;
            }
            catch (Exception ex)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelCodesGet failed: {ex.Message}");
                return ErrorCodes.ERROR_UNKNOWN;
            }
            finally
            {
                cmd.Connection.Dispose();
                cmd.Dispose();
            }
        }
        /// <summary>
        /// updates the default value for a channel setting
        /// </summary>
        /// <param name="user">user making update</param>
        /// <param name="connection">connection update is being made on</param>
        /// <param name="settingId">setting id to update</param>
        /// <param name="defaultValue">new value for setting</param>
        /// <returns>0 (ERROR_SUCCESS) on success, all other values are error codes</returns>
        public ulong ChannelSettingsUpdate(IUserDbRecord user,
            IConnectionDetails connection,
            int settingId,
            string defaultValue)
        {
            if (!DbAPI.Connections.IsUserLoggedIn(user, connection))
            {
                return ErrorCodes.ERROR_ACCESS_DENIED;
            }
            var ret = ConnectionManager.GetSqlCommand(connection, out var cmd, "sp_ChannelSettingsUpdate");
            if (ret != ErrorCodes.ERROR_SUCCESS)
            {
                return ret;
            }
            try
            {
                cmd.CommandType = CommandType.StoredProcedure;

                cmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int) { Value = settingId });
                cmd.Parameters.Add(new SqlParameter("@DefaultValue", SqlDbType.NVarChar, 255) { Value = defaultValue });

                var errorNumber = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
                cmd.Parameters.Add(errorNumber);

                var errorMessage = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255) { Direction = ParameterDirection.Output };
                cmd.Parameters.Add(errorMessage);

                var reader = cmd.ExecuteReader();
                var o = errorNumber.Value;
                if (!DBNull.Value.Equals(o) && 0 != Convert.ToInt32(o))
                {
                    LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups,
                        $"ChannelSettingsUpdate failed: {errorNumber.Value} - {errorMessage.Value}");
                    return ErrorCodes.ERROR_UNKNOWN;
                }
                return ErrorCodes.ERROR_SUCCESS;
            }
            catch (Exception ex)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelSettingsUpdate failed: {ex.Message}");
                return ErrorCodes.ERROR_UNKNOWN;
            }
            finally
            {
                cmd.Connection.Dispose();
                cmd.Dispose();
            }
        }
        /// <summary>
        /// retrieves all channel settings from the db for a given channel
        /// </summary>
        /// <param name="user">user making request</param>
        /// <param name="connection">connection request is being made on</param>
        /// <param name="settingId">channel id to match (allows null)</param>
        /// <param name="settingName">setting name to match (allows null/empty)</param>
        /// <param name="records">matching records</param>
        /// <returns>0 (ERROR_SUCCESS) on success, all other values are error codes</returns>
        public ulong ChannelSettingsGet(IUserDbRecord user,
            IConnectionDetails connection,
            int? settingId,
            string settingName,
            out IChannelSettingRecord[] records)
        {
            records = null;
            if (!DbAPI.Connections.IsUserLoggedIn(user, connection))
            {
                return ErrorCodes.ERROR_ACCESS_DENIED;
            }
            var ret = ConnectionManager.GetSqlCommand(connection, out var cmd, Database.Database.GetStoredProcedureVersionCached(connection, "sp_ChannelSettingsGet"));
            if (ret != ErrorCodes.ERROR_SUCCESS)
            {
                return ret;
            }
            try
            {
                cmd.CommandType = CommandType.StoredProcedure;
                if (null == settingId)
                {
                    cmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int) { Value = null });
                }
                else
                {
                    cmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int) { Value = (int)settingId });
                }
                cmd.Parameters.Add(new SqlParameter("@SettingName", SqlDbType.NVarChar, 255) { Value = settingName });

                var reader = cmd.ExecuteReader();
                var list = new List<IChannelSettingRecord>();
                while (reader.Read())
                {
                    list.Add(new ChannelSettingRecord(reader));
                }
                records = list.ToArray();
                return ErrorCodes.ERROR_SUCCESS;
            }
            catch (Exception ex)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelSettingsGet failed: {ex.Message}");
                return ErrorCodes.ERROR_UNKNOWN;
            }
            finally
            {
                cmd.Connection.Dispose();
                cmd.Dispose();
            }
        }
        /// <summary>
        /// removes group channel settings from the db for a given channel
        /// </summary>
        /// <param name="user">user requesting changes</param>
        /// <param name="connection">connection changes are being made on</param>
        /// <param name="channelId">channel settings belong to</param>
        /// <param name="settingId">setting which to delete (use null to delete all settings)</param>
        /// <returns>0 (ERROR_SUCCESS) on success, all other values are error codes</returns>
        public ulong GroupChannelSettingsDelete(IUserDbRecord user,
            IConnectionDetails connection,
            long channelId,
            int? settingId)
        {
            if (!DbAPI.Connections.IsUserLoggedIn(user, connection))
            {
                return ErrorCodes.ERROR_ACCESS_DENIED;
            }
            var ret = ConnectionManager.GetSqlCommand(connection, out var cmd, "sp_GroupChannelSettingsDelete");
            if (ret != ErrorCodes.ERROR_SUCCESS)
            {
                return ret;
            }
            try
            {
                cmd.CommandType = CommandType.StoredProcedure;

                cmd.Parameters.Add(new SqlParameter("@ChannelId", SqlDbType.BigInt) { Value = channelId });
                if (null != settingId)
                {
                    cmd.Parameters.Add(new SqlParameter("@SettingId", SqlDbType.Int) { Value = (int)settingId });
                }
                else
                {
                    cmd.Parameters.Add(new SqlParameter("@SettingId", SqlDbType.Int) { Value = null });
                }

                var errorNumber = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
                cmd.Parameters.Add(errorNumber);

                var errorMessage = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 250) { Direction = ParameterDirection.Output };
                cmd.Parameters.Add(errorMessage);

                var reader = cmd.ExecuteReader();

                var o = errorNumber.Value;
                if (!DBNull.Value.Equals(o) && 0 != Convert.ToInt32(errorNumber.Value))
                {
                    LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelSettingsDelete failed: {errorNumber.Value} : {errorMessage.Value}");
                    return ErrorCodes.ERROR_UNKNOWN;
                }

                return ErrorCodes.ERROR_SUCCESS;
            }
            catch (Exception ex)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelSettingsDelete failed: {ex.Message}");
                return ErrorCodes.ERROR_UNKNOWN;
            }
            finally
            {
                cmd.Connection.Dispose();
                cmd.Dispose();
            }
        }
        /// <summary>
        /// Inserts a new channel setting record into db
        /// </summary>
        /// <param name="user">user inserting record</param>
        /// <param name="connection">connection record is being inserted on</param>
        /// <param name="clientDbVersion">connection client db version</param>
        /// <param name="channelId">channel setting belongs to</param>
        /// <param name="record">record being inserted</param>
        /// <returns>0 (ERROR_SUCCESS) on success, all other values are error codes</returns>
        public ulong GroupChannelSettingsInsert(IUserDbRecord user,
            IConnectionDetails connection,
            int clientDbVersion,
            long channelId,
            IGroupChannelSettingRecord record)
        {
            SqlCommand cmd;
            var storedProcedureVersionToUse = 0;
            var ret = Database.Database.PrepareForDbAccess(user, connection, clientDbVersion,
                "sp_GroupChannelSettingsInsert", out storedProcedureVersionToUse, out cmd);
            if (ret != ErrorCodes.ERROR_SUCCESS) { return ret; }

            try
            {
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.Parameters.Add(new SqlParameter("@ChannelId", SqlDbType.BigInt) { Value = channelId });
                cmd.Parameters.Add(new SqlParameter("@SettingId", SqlDbType.Int) { Value = record.SettingId });
                cmd.Parameters.Add(new SqlParameter("@SettingValue", SqlDbType.NVarChar, 255) { Value = record.SettingValue });

                var errorNumber = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
                cmd.Parameters.Add(errorNumber);

                var errorMessage = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255) { Direction = ParameterDirection.Output };
                cmd.Parameters.Add(errorMessage);

                var reader = cmd.ExecuteReader();

                var o = errorNumber.Value;
                if (!DBNull.Value.Equals(o) && 0 != Convert.ToInt32(errorNumber.Value))
                {
                    LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelSettingsInsert failed: {errorNumber.Value} : {errorMessage.Value}");
                    return ErrorCodes.ERROR_UNKNOWN;
                }

                return ErrorCodes.ERROR_SUCCESS;
            }
            catch (Exception ex)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelSettingsInsert failed: {ex.Message}");
                return ErrorCodes.ERROR_UNKNOWN;
            }
            finally
            {
                cmd.Connection.Dispose();
                cmd.Dispose();
            }
        }
        /// <summary>
        /// returns all channel settings for a given channel
        /// </summary>
        /// <param name="user">user making request</param>
        /// <param name="clientDbVersion">calling client's database version</param>
        /// <param name="connection">connection request is being made on</param>
        /// <param name="channelIdList">list of channels for the request</param>
        /// <param name="records">all matching channel settings</param>
        /// <param name="errors">any errors encountered while retrieving group channel settings</param>
        /// <returns>0 (ERROR_SUCCESS) on success, all other values are error codes</returns>
        public ulong GroupChannelSettingsGet(IUserDbRecord user,
            IConnectionDetails connection,
            int clientDbVersion,
            List<long> channelIdList,
            out IGroupChannelSettingRecord[] records,
            out string[] errors)
        {
            errors = new string[0];
            records = new IGroupChannelSettingRecord[0];
            var storedProcedureVersionToUse = 0;
            SqlCommand cmd;

            var ret = Database.Database.PrepareForDbAccess(user, connection, clientDbVersion,
                "sp_GroupChannelSettingsGet", out storedProcedureVersionToUse, out cmd);
            if (ret != ErrorCodes.ERROR_SUCCESS) { return ret; }

            cmd.CommandType = CommandType.StoredProcedure;
            try
            {
                var list = new List<IGroupChannelSettingRecord>();
                if (storedProcedureVersionToUse < Constants.BULK_GROUPCHANNELSETTINGS_GET_DB_VERSION)
                {
                    //Call the old procedure that takes only one channel ID
                    foreach (var channelId in channelIdList)
                    {
                        if (ErrorCodes.ERROR_SUCCESS != ret) { return ret; }
                        //we can re-enter here, so clear the parameters just for simplicity
                        cmd.Parameters.Clear();
                        cmd.Parameters.Add(new SqlParameter("@ChannelId", SqlDbType.Int) { Value = channelId });

                        var reader = cmd.ExecuteReader();
                        while (reader.Read())
                        {
                            list.Add(new GroupChannelSettingRecord(reader, storedProcedureVersionToUse) { ChannelId = channelId });
                        }
                        //http://manuscript.dts.local/f/cases/35503/Unable-to-add-a-test-setup-with-attached-database
                        //close the reader
                        reader.Close();
                    }
                }
                else
                {
                    //Call the new procedure that takes a table of channel IDs
                    using (var table = new DataTable())
                    {
                        table.Columns.Add("Item", typeof(string));

                        foreach (var channelId in channelIdList)
                        {
                            table.Rows.Add(channelId.ToString());
                        }

                        var pList = new SqlParameter("@ChannelIdList", SqlDbType.Structured);
                        pList.TypeName = "dbo.StringList";
                        pList.Value = table;

                        cmd.Parameters.Add(pList);

                        var reader = cmd.ExecuteReader();
                        while (reader.Read())
                        {
                            list.Add(new GroupChannelSettingRecord(reader, storedProcedureVersionToUse));
                        }
                    }
                }
                records = list.ToArray();
                return ErrorCodes.ERROR_SUCCESS;
            }
            catch (Exception ex)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelSettingsGet failed: {ex.Message}");
                return ErrorCodes.ERROR_UNKNOWN;
            }
            finally
            {
                cmd.Connection.Dispose();
                cmd.Dispose();
            }
        }
        public ulong ChannelsInsert(IUserDbRecord user,
            IConnectionDetails connection,
            ref IChannelDbRecord channel)
        {
            if (!DbAPI.Connections.IsUserLoggedIn(user, connection))
            {
                return ErrorCodes.ERROR_ACCESS_DENIED;
            }
            var ret = ConnectionManager.GetSqlCommand(connection, out var cmd, "sp_ChannelsInsert");
            if (ret != ErrorCodes.ERROR_SUCCESS)
            {
                return ret;
            }
            try
            {
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.Parameters.Add(new SqlParameter("@GroupId", SqlDbType.Int) { Value = channel.GroupId });
                cmd.Parameters.Add(new SqlParameter("@IsoCode", SqlDbType.NVarChar, 50) { Value = channel.IsoCode ?? "" });
                cmd.Parameters.Add(new SqlParameter("@IsoChannelName", SqlDbType.NVarChar, 255) { Value = channel.IsoChannelName ?? "" });
                cmd.Parameters.Add(new SqlParameter("@UserCode", SqlDbType.NVarChar, 50) { Value = channel.UserCode ?? "" });
                cmd.Parameters.Add(new SqlParameter("@UserChannelName", SqlDbType.NVarChar, 255) { Value = channel.UserChannelName ?? "" });
                object dasId = null;
                if (channel.DASId > 0 && channel.DASChannelIndex >= 0)
                {
                    dasId = channel.DASId;
                }
                cmd.Parameters.Add(new SqlParameter("@DASId", SqlDbType.Int) { Value = dasId });
                cmd.Parameters.Add(new SqlParameter("@DASChannelIndex", SqlDbType.Int) { Value = channel.DASChannelIndex });
                cmd.Parameters.Add(new SqlParameter("@GroupChannelOrder", SqlDbType.Int) { Value = channel.GroupChannelOrder });
                cmd.Parameters.Add(new SqlParameter("@TestSetupOrder", SqlDbType.Int) { Value = channel.TestSetupOrder });
                object sensorId = null;
                if (channel.SensorId > 0)
                {
                    sensorId = channel.SensorId;
                }
                cmd.Parameters.Add(new SqlParameter("@SensorId", SqlDbType.Int) { Value = sensorId });
                cmd.Parameters.Add(new SqlParameter("@Disabled", SqlDbType.Bit) { Value = channel.Disabled });
                cmd.Parameters.Add(new SqlParameter("@LastModified", SqlDbType.DateTime) { Value = channel.LastModified });
                cmd.Parameters.Add(new SqlParameter("@LastModifiedBy", SqlDbType.NVarChar, 255) { Value = channel.LastModifiedBy });

                var errorNumber = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
                cmd.Parameters.Add(errorNumber);

                var errorMessage = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255) { Direction = ParameterDirection.Output };
                cmd.Parameters.Add(errorMessage);

                var newId = new SqlParameter("@new_id", SqlDbType.Int) { Direction = ParameterDirection.Output };
                cmd.Parameters.Add(newId);

                cmd.ExecuteNonQuery();
                if (!DBNull.Value.Equals(errorNumber.Value) && 0 != Convert.ToInt32(errorNumber.Value))
                {
                    LogManager.Log(TraceEventType.Error,
                        LogManager.LogEvents.TestSetups, $"ChannelsInsert error - {errorNumber.Value} - {errorMessage.Value}");
                    return ErrorCodes.ERROR_UNKNOWN;
                }
                channel.Id = Convert.ToInt64(newId.Value);
                return ErrorCodes.ERROR_SUCCESS;
            }
            catch (Exception ex)
            {

                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelsInsert error: {ex.Message}");
                return ErrorCodes.ERROR_UNKNOWN;
            }
            finally
            {
                cmd.Connection.Dispose();
                cmd.Dispose();
            }
        }
        public ulong ChannelsUpdate(IUserDbRecord user,
            IConnectionDetails connection,
            IChannelDbRecord channel)
        {
            if (!DbAPI.Connections.IsUserLoggedIn(user, connection))
            {
                return ErrorCodes.ERROR_ACCESS_DENIED;
            }
            var ret = ConnectionManager.GetSqlCommand(connection, out var cmd, "sp_ChannelsUpdate");
            if (ret != ErrorCodes.ERROR_SUCCESS)
            {
                return ret;
            }
            try
            {
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.BigInt) { Value = channel.Id });
                cmd.Parameters.Add(new SqlParameter("@GroupId", SqlDbType.Int) { Value = channel.GroupId });
                cmd.Parameters.Add(new SqlParameter("@IsoCode", SqlDbType.NVarChar, 50) { Value = channel.IsoCode });
                cmd.Parameters.Add(new SqlParameter("@IsoChannelName", SqlDbType.NVarChar, 255) { Value = channel.IsoChannelName });
                cmd.Parameters.Add(new SqlParameter("@UserCode", SqlDbType.NVarChar, 50) { Value = channel.UserCode });
                cmd.Parameters.Add(new SqlParameter("@UserChannelName", SqlDbType.NVarChar, 255) { Value = channel.UserChannelName });

                object dasId = null;
                if (channel.DASId > 0)
                {
                    dasId = channel.DASId;
                }
                cmd.Parameters.Add(new SqlParameter("@DASId", SqlDbType.Int) { Value = dasId });

                cmd.Parameters.Add(new SqlParameter("@DASChannelIndex", SqlDbType.Int) { Value = channel.DASChannelIndex });
                cmd.Parameters.Add(new SqlParameter("@GroupChannelOrder", SqlDbType.Int) { Value = channel.GroupChannelOrder });
                cmd.Parameters.Add(new SqlParameter("@TestSetupOrder", SqlDbType.Int) { Value = channel.TestSetupOrder });

                object sensorId = null;
                if (channel.SensorId > 0)
                {
                    sensorId = channel.SensorId;
                }
                cmd.Parameters.Add(new SqlParameter("@SensorId", SqlDbType.Int) { Value = sensorId });

                cmd.Parameters.Add(new SqlParameter("@Disabled", SqlDbType.Bit) { Value = channel.Disabled });
                cmd.Parameters.Add(new SqlParameter("@LastModified", SqlDbType.DateTime) { Value = channel.LastModified });
                cmd.Parameters.Add(new SqlParameter("@LastModifiedBy", SqlDbType.NVarChar, 255) { Value = channel.LastModifiedBy });

                var errorNumber = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
                cmd.Parameters.Add(errorNumber);

                var errorMessage = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255) { Direction = ParameterDirection.Output };
                cmd.Parameters.Add(errorMessage);

                if (!DBNull.Value.Equals(errorNumber.Value) && 0 != Convert.ToInt32(errorNumber.Value))
                {
                    LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups,
                        $"ChannelsUpdate {errorNumber.Value} - {errorMessage.Value}");
                    return ErrorCodes.ERROR_UNKNOWN;
                }
                cmd.ExecuteNonQuery();

                return ErrorCodes.ERROR_SUCCESS;
            }
            catch (Exception ex)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.TestSetups, $"ChannelsUpdate {ex.Message}");
                return ErrorCodes.ERROR_UNKNOWN;
            }
            finally
            {
                cmd.Connection.Dispose();
            }
        }
        public ulong ChannelsGet(IUserDbRecord user,
            IConnectionDetails connection,
            int clientDbVersion,
            long? channelId,
            int? groupId,
            int? dasId,
            int? sensorId,
            int? testSetupId,
            string testSetupName,
            out IChannelDbRecord[] channels)
        {
            channels = null;
            if (!DbAPI.Connections.IsUserLoggedIn(user, connection))
            {
                return ErrorCodes.ERROR_ACCESS_DENIED;
            }
            var storedProcedureVersionToUse = 0;
            SqlCommand cmd;

            var ret = Database.Database.PrepareForDbAccess(user, connection, clientDbVersion, "sp_ChannelsGet", out storedProcedureVersionToUse, out cmd);
            if (ret != ErrorCodes.ERROR_SUCCESS) { return ret; }

            var list = new List<IChannelDbRecord>();
            try
            {
                cmd.CommandType = CommandType.StoredProcedure;

                cmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.Int) { Value = channelId });
                cmd.Parameters.Add(new SqlParameter("@GroupId", SqlDbType.Int) { Value = groupId });
                cmd.Parameters.Add(new SqlParameter("@DASId", SqlDbType.Int) { Value = dasId });
                cmd.Parameters.Add(new SqlParameter("@SensorId", SqlDbType.Int) { Value = sensorId });
                cmd.Parameters.Add(new SqlParameter("@TestSetupId", SqlDbType.Int) { Value = testSetupId });
                cmd.Parameters.Add(new SqlParameter("@TestSetupName", SqlDbType.NVarChar, 255) { Value = testSetupName });

                var reader = cmd.ExecuteReader();
                while (reader.Read())
                {
                    //33192 Hide the TSR AIR Humidity channel
                    var newDbRecord = new ChannelDbRecord(reader);
                    if (newDbRecord.UserChannelName.EndsWith(DFConstantsAndEnums.USER_CHANNEL_NAME_HUMIDITY)) { continue; }
                    list.Add(newDbRecord);
                }
                channels = list.ToArray();
                return ErrorCodes.ERROR_SUCCESS;
            }
            catch (Exception ex)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.DataRecorders, ex.Message);
                return ErrorCodes.ERROR_UNKNOWN;
            }
            finally
            {
                cmd.Connection.Dispose();
            }
        }
        public ulong ChannelsDelete(IUserDbRecord user,
            IConnectionDetails connection,
            long id,
            out string errorString)
        {
            errorString = string.Empty;
            if (!DbAPI.Connections.IsUserLoggedIn(user, connection))
            {
                return ErrorCodes.ERROR_ACCESS_DENIED;
            }
            var ret = ConnectionManager.GetSqlCommand(connection, out var cmd, "sp_ChannelsDelete");
            if (ret != ErrorCodes.ERROR_SUCCESS)
            {
                return ret;
            }
            var errorNumberULong = ErrorCodes.ERROR_SUCCESS;
            try
            {
                cmd.CommandType = CommandType.StoredProcedure;

                cmd.Parameters.Add(new SqlParameter("@Id", SqlDbType.BigInt) { Value = id });
                cmd.Parameters.Add(new SqlParameter("@GroupId", SqlDbType.Int) { Value = null });
                cmd.Parameters.Add(new SqlParameter("@DASId", SqlDbType.Int) { Value = null });
                cmd.Parameters.Add(new SqlParameter("@SensorId", SqlDbType.Int) { Value = null });
                cmd.Parameters.Add(new SqlParameter("@TestSetupId", SqlDbType.Int) { Value = null });
                cmd.Parameters.Add(new SqlParameter("@TestSetupName", SqlDbType.NVarChar, 255) { Value = null });
                var errorNumber = new SqlParameter("@errorNumber", SqlDbType.Int) { Direction = ParameterDirection.Output };
                cmd.Parameters.Add(errorNumber);
                var errorMessage = new SqlParameter("@errorMessage", SqlDbType.NVarChar, 255) { Direction = ParameterDirection.Output };
                cmd.Parameters.Add(errorMessage);

                cmd.ExecuteNonQuery();
                if (null != errorNumber.Value)
                {
                    if (Convert.ToInt32(errorNumber.Value) != 0)
                    {
                        errorNumberULong = Convert.ToUInt64(errorNumber.Value);
                        errorString = (string)errorMessage.Value;
                    }
                }
            }
            catch (Exception ex)
            {
                //Concatenate any error string returned from the stored procedure call
                errorString = $"{ex.Message}; {errorString}";
                return errorNumberULong;
            }
            finally
            {
                cmd.Connection.Dispose();
            }

            return errorNumberULong;
        }
    }
}