using DbAPI.Connections;
using DbAPI.Errors;
using DbAPI.Logging;
using DTS.Common.Classes;
using DTS.Common.Classes.TestSetups;
using DTS.Common.Interface.Database;
using DTS.Common.Interface.TestSetups;
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Diagnostics;
using System.Globalization;

namespace DbAPI.TestSetups
{
    /// <summary>
    /// Handles calculated channel functions
    /// <inheritdoc cref="ICalculatedChannels"/>
    /// </summary>
    internal class CalculatedChannels : ICalculatedChannels
    {
        /// <summary>
        /// removes calculated channel from database
        /// </summary>
        /// <param name="user">user committing delete</param>
        /// <param name="connection">connection over which to delete</param>
        /// <param name="calculatedChannelId">database id of calculated channel to delete</param>
        /// <returns></returns>
        public ulong CalculatedChannelsDelete(IUserDbRecord user,
            IConnectionDetails connection,
            int calculatedChannelId)
        {
            if (!DbAPI.Connections.IsUserLoggedIn(user, connection))
            {
                return ErrorCodes.ERROR_ACCESS_DENIED;
            }
            var ret = ConnectionManager.GetSqlCommand(connection, out var cmd, "sp_CalculatedChannelsDelete");
            if (ret != ErrorCodes.ERROR_SUCCESS) { return ret; }
            try
            {
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.Parameters.Add(new SqlParameter("@CalculatedChannelsId", SqlDbType.Int) { Value = calculatedChannelId });
                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);

                cmd.ExecuteNonQuery();
                if (!DBNull.Value.Equals(errorNumber.Value) && 0 != Convert.ToInt32(errorNumber.Value))
                {
                    LogManager.Log(TraceEventType.Error, LogManager.LogEvents.CalculatedChannels, $"sp_CalculatedChannelsDelete failed: {errorNumber.Value} : {errorMessage.Value}");
                    return ErrorCodes.ERROR_UNKNOWN;
                }
                return ErrorCodes.ERROR_SUCCESS;
            }
            catch (Exception ex)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.CalculatedChannels, $"sp_CalculatedChannelsDelete failed: {ex.Message}");
                return ErrorCodes.ERROR_UNKNOWN;
            }
            finally
            {
                cmd.Connection.Dispose();
                cmd.Dispose();
            }
        }
        /// <summary>
        /// inserts a new calculated channel into the database
        /// original record is modified with database id after insert is complete
        /// </summary>
        /// <param name="user">user adding record</param>
        /// <param name="connection">connection record is being added on</param>
        /// <param name="record">record being added</param>
        /// <returns>0 (ERROR_SUCCESS) on success, all other values are error codes</returns>
        public ulong CalculatedChannelsInsert(IUserDbRecord user,
            IConnectionDetails connection,
            ref ICalculatedChannelRecord record)
        {
            if (!DbAPI.Connections.IsUserLoggedIn(user, connection))
            {
                return ErrorCodes.ERROR_ACCESS_DENIED;
            }
            if (null == record)
            {
                return ErrorCodes.ERROR_MISSING_PARAMETER;
            }
            var ret = ConnectionManager.GetSqlCommand(connection, out var cmd, "sp_CalculatedChannelsInsert");
            if (ret != ErrorCodes.ERROR_SUCCESS) { return ret; }
            try
            {
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.Parameters.Add(new SqlParameter("@Operation", SqlDbType.Int) { Value = (int)record.Operation });
                cmd.Parameters.Add(new SqlParameter("@CalculatedChannelValueCode", SqlDbType.NVarChar, 255)
                { Value = record.CalculatedValueCode });

                cmd.Parameters.Add(new SqlParameter("@InputChannelIds", SqlDbType.VarBinary)
                {
                    Value = Utility.GetBytesFromStringArray(record.InputChannelIds,
                    CultureInfo.InvariantCulture.TextInfo.ListSeparator)
                });

                cmd.Parameters.Add(new SqlParameter("@CFCForInputChannels", SqlDbType.NVarChar, 255) { Value = record.CFCForInputChannels });

                cmd.Parameters.Add(new SqlParameter("@CFCForOutput", SqlDbType.NVarChar, 255)
                { Value = record.ChannelFilterClassForOutput });

                cmd.Parameters.Add(new SqlParameter("TestSetupName", SqlDbType.NVarChar, 255)
                { Value = record.TestSetupName });

                cmd.Parameters.Add(new SqlParameter("@CCName", SqlDbType.NVarChar, 255) { Value = record.Name });

                cmd.Parameters.Add(new SqlParameter("@ViewInRealtime", SqlDbType.Bit) { Value = record.ViewInRealtime });

                cmd.Parameters.Add(new SqlParameter("@ClipLength", SqlDbType.Int) { Value = record.ClipLength });

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

                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);

                cmd.ExecuteNonQuery();
                if (null != errorNumber.Value && 0 != Convert.ToInt32(errorNumber.Value))
                {
                    LogManager.Log(TraceEventType.Error, LogManager.LogEvents.CalculatedChannels, $"sp_CalculatedChannelsInsert failed: {errorNumber.Value} : {errorMessage.Value}");
                    return ErrorCodes.ERROR_UNKNOWN;
                }

                record.Id = Convert.ToInt32(newId.Value);
            }
            catch (Exception ex)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.CalculatedChannels, $"sp_CalculatedChannelsInsert failed: {ex.Message}");
                return ErrorCodes.ERROR_UNKNOWN;
            }
            finally
            {
                cmd.Connection.Dispose();
                cmd.Dispose();
            }

            return ErrorCodes.ERROR_SUCCESS;
        }
        /// <summary>
        /// updates calculated channel in the database
        /// </summary>
        /// <param name="user">user updating record</param>
        /// <param name="connection">connection record is being updated on</param>
        /// <param name="record">record to be updated</param>
        /// <returns>0 (ERROR_SUCCESS) on success, all other values are error codes</returns>
        public ulong CalculatedChannelsUpdate(IUserDbRecord user,
            IConnectionDetails connection,
            ICalculatedChannelRecord record)
        {
            if (!DbAPI.Connections.IsUserLoggedIn(user, connection))
            {
                return ErrorCodes.ERROR_ACCESS_DENIED;
            }
            if (null == record)
            {
                return ErrorCodes.ERROR_MISSING_PARAMETER;
            }
            var ret = ConnectionManager.GetSqlCommand(connection, out var cmd, "sp_CalculatedChannelsUpdate");
            if (ret != ErrorCodes.ERROR_SUCCESS) { return ret; }
            try
            {
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.Parameters.Add(new SqlParameter("@id", SqlDbType.Int) { Value = record.Id });
                cmd.Parameters.Add(new SqlParameter("@Operation", SqlDbType.Int) { Value = (int)record.Operation });
                cmd.Parameters.Add(new SqlParameter("@CalculatedChannelValueCode", SqlDbType.NVarChar, 255)
                { Value = record.CalculatedValueCode });
                cmd.Parameters.Add(new SqlParameter("@InputChannelIds", SqlDbType.VarBinary)
                { Value = Utility.GetBytesFromStringArray(record.InputChannelIds, CultureInfo.InvariantCulture.TextInfo.ListSeparator) });
                cmd.Parameters.Add(new SqlParameter("@CFCForInputChannels", SqlDbType.NVarChar) { Value = record.CFCForInputChannels });
                cmd.Parameters.Add(new SqlParameter("@CFCForOutput", SqlDbType.NVarChar, 255)
                { Value = record.ChannelFilterClassForOutput });
                cmd.Parameters.Add(new SqlParameter("@TestSetupName", SqlDbType.NVarChar, 255)
                { Value = record.TestSetupName });
                cmd.Parameters.Add(new SqlParameter("@CCName", SqlDbType.NVarChar, 255) { Value = record.Name });
                cmd.Parameters.Add(new SqlParameter("@ViewInRealtime", SqlDbType.Bit) { Value = record.ViewInRealtime });
                cmd.Parameters.Add(new SqlParameter("@ClipLength", SqlDbType.Int) { Value = record.ClipLength });
                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);
                cmd.ExecuteNonQuery();
                if (null != errorNumber.Value && 0 != Convert.ToInt32(errorNumber.Value))
                {
                    LogManager.Log(TraceEventType.Error, LogManager.LogEvents.CalculatedChannels, $"sp_CalculatedChannelsUpdate failed: {errorNumber.Value} : {errorMessage.Value}");
                    return ErrorCodes.ERROR_UNKNOWN;
                }
            }
            catch (Exception ex)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.CalculatedChannels, $"sp_CalculatedChannelsUpdate failed: {ex.Message}");
                return ErrorCodes.ERROR_UNKNOWN;
            }
            finally
            {
                cmd.Connection.Dispose();
                cmd.Dispose();
            }

            return ErrorCodes.ERROR_SUCCESS;
        }
        /// <summary>
        /// retrieves all CalculatedChannel records matching search criteria
        /// </summary>
        /// <param name="user">user making query</param>
        /// <param name="connection">connection query is being made on</param>
        /// <param name="calculatedChannelId">database id of calculated channel (can be null)</param>
        /// <param name="testSetupName">test setup calculated channel(s) belong to (can be empty)</param>
        /// <param name="records">all matching records found</param>
        /// <returns>0 (ERROR_SUCCESS) on success, all other values are error codes</returns>
        public ulong CalculatedChannelsGet(IUserDbRecord user,
            IConnectionDetails connection,
            int? calculatedChannelId,
            string testSetupName,
            out ICalculatedChannelRecord[] records)
        {
            records = new ICalculatedChannelRecord[0];
            if (!DbAPI.Connections.IsUserLoggedIn(user, connection))
            {
                return ErrorCodes.ERROR_ACCESS_DENIED;
            }
            var ret = ConnectionManager.GetSqlCommand(connection, out var cmd, "sp_CalculatedChannelsGet");
            if (ret != ErrorCodes.ERROR_SUCCESS) { return ret; }
            try
            {
                cmd.CommandType = CommandType.StoredProcedure;
                if (null == calculatedChannelId)
                {
                    cmd.Parameters.Add(new SqlParameter("@CalculatedChannelsId", SqlDbType.Int) { Value = null });
                }
                else
                {
                    cmd.Parameters.Add(new SqlParameter("@CalculatedChannelsId", SqlDbType.Int) { Value = (int)calculatedChannelId });
                }
                cmd.Parameters.Add(new SqlParameter("@TestSetupName", SqlDbType.NVarChar, 50) { Value = testSetupName });

                var reader = cmd.ExecuteReader();
                var list = new List<ICalculatedChannelRecord>();
                while (reader.Read())
                {
                    list.Add(new CalculatedChannelRecord(reader));
                }
                records = list.ToArray();

                return ErrorCodes.ERROR_SUCCESS;
            }
            catch (Exception ex)
            {
                LogManager.Log(TraceEventType.Error, LogManager.LogEvents.Graphs, $"sp_CalculatedChannelsGet failed: {ex.Message}");
                return ErrorCodes.ERROR_UNKNOWN;
            }
            finally
            {
                cmd.Connection.Dispose();
                cmd.Dispose();
            }
        }
    }
}