using DataEntity.Device;
using DataEntity.Share;
using HxEnum;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net.Sockets;
using System.Reflection;
using System.Threading;
using XCommon.Log;
using XImagingXhandler.XDAL;
using static HxEnum.StateEnum;

namespace HxSocketImplement.Sockets
{
    /// <summary>
    /// 获取统一值---参数
    /// </summary>
    public static class HxSocketParameterService
    { 
        #region 添加默认参数
        /// <summary>
        /// 添加默认参数
        /// </summary>
        /// <param name="ip">IP</param>
        /// <param name="port">端口</param>
        /// <param name="equipmentId">设备ID</param>
        /// <param name="equipmentType">设备类型</param>
        /// <param name="virtualConnectionState">虚拟连接状态</param>
        /// <param name="delaySecondTime">延迟时间(毫秒)</param>
        /// <returns></returns>
        public static Result AddSocketDefaultParameter(string equipmentType, string ip, int port, string equipmentId,  bool virtualConnectionState = false, int delaySecondTime = 3000)
        {
            Result resultModel = new Result();
            try
            {
                 var result = AddSocketDefaultParameters(equipmentType, ip, port, equipmentId, virtualConnectionState, delaySecondTime);

                #region 虚拟连接
                var virtualConnectionStateResult = GetVirtualConnectionState(virtualConnectionState, delaySecondTime);
                if (virtualConnectionStateResult != null && virtualConnectionStateResult.status == StateEnum_Equipment.Completed)
                {
                    return virtualConnectionStateResult;
                }
                #endregion

                if (result)
                {
                    resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Completed, msg = "添加默认参数【成功】" });
                }
                else
                {
                    resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = "添加默认参数【失败】" });
                }
            }
            catch (Exception ex)
            {
                resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = ex.Message });
            }
            return resultModel;
        } 
        /// <summary>
        /// 添加统一值方法
        /// </summary>
        /// <param name="equipmentType">设备类别</param>
        /// <param name="ip">IP</param>
        /// <param name="port">端口</param>
        /// <param name="equipmentId">设备ID</param>
        /// <param name="virtualConnectionState">虚拟连接状态</param>
        /// <param name="delaySecondTime">延迟时间(毫秒)</param> 
        /// <returns></returns>
        private static bool AddSocketDefaultParameters(string equipmentType, string ip, int port, string equipmentId, bool virtualConnectionState, int delaySecondTime)
        {
            SocketParameterModel socketParameterModel = new SocketParameterModel();
            if (string.IsNullOrWhiteSpace(equipmentType) || string.IsNullOrWhiteSpace(ip) || port <= 0)
            {
                return false;
            }

            #region 防止数据重了
            if (HxSockServiceExecute.CacheSocketParameterData != null && HxSockServiceExecute.CacheSocketParameterData.Count > 0)
            {
                var cacheSocketParameterData = HxSockServiceExecute.CacheSocketParameterData.Where(x => x.Key == equipmentType + ip + port + equipmentId);
                if (cacheSocketParameterData != null && cacheSocketParameterData.Count() > 0)
                {
                    return true;
                }
            }
            #endregion

            socketParameterModel = GetSocketParameterModelMethod(equipmentType, ip, port, virtualConnectionState, delaySecondTime, equipmentId);
            return true;
        } 
        /// <summary>
        /// 获取统一参数值方法
        /// </summary>
        /// <param name="equipmentType">设备类别</param>
        /// <param name="ip">IP</param>
        /// <param name="port">端口</param>
        /// <param name="virtualConnectionState">虚拟连接状态</param>
        /// <param name="delaySecondTime">延迟时间(毫秒)</param>
        /// <param name="equipmentId">设备ID</param>
        /// <returns></returns>
        public static SocketParameterModel GetSocketParameterModelMethod(string equipmentType, string ip, int port, bool virtualConnectionState, int delaySecondTime, string equipmentId)
        {
            SocketParameterModel socketParameterModel = new SocketParameterModel();
            socketParameterModel.Socket = null;
            socketParameterModel.Ip = ip;
            socketParameterModel.Port = port;
            socketParameterModel.HeartmessageId = HxSockServiceExecute.InstrunctionId();// "05";
            socketParameterModel.HeartMessageType = 0;
            socketParameterModel.HeartEquipmentId = equipmentId;// "id0060";
            socketParameterModel.SpecifiedDisplay = CommonParameter.SpecifiedDisplay;
            socketParameterModel.LockReceive = new object();
            socketParameterModel.Buffer = new byte[1024 * 1024 * 10];
            socketParameterModel.EquipmentType = equipmentType;
            socketParameterModel.VirtualConnectionState = virtualConnectionState;
            socketParameterModel.DelaySecondTime = delaySecondTime;
            socketParameterModel.EquipmentId = equipmentId;
            HxSockServiceExecute.CacheSocketParameterData.Add(equipmentType + ip + port + equipmentId, socketParameterModel);

            return socketParameterModel;
        }
        #endregion

        #region 获取socket参数
        /// <summary>
        /// 获取socket参数
        /// </summary>
        /// <param name="equipmentType">类型</param> 
        /// <param name="ip">IP</param>
        /// <param name="port">端口</param>
        /// <param name="equipmentId">设备ID</param>
        /// <returns></returns>
        public static SocketParameterModel GetSocketParameter(string equipmentType, string ip, int port, string equipmentId)
        {
            SocketParameterModel socketParameterModel = new SocketParameterModel();
            if (HxSockServiceExecute.CacheSocketParameterData != null && HxSockServiceExecute.CacheSocketParameterData.Count > 0)
            {
                var cacheSocketParameterData = HxSockServiceExecute.CacheSocketParameterData.Where(x => x.Key == equipmentType + ip + port + equipmentId);
                if (cacheSocketParameterData != null && cacheSocketParameterData.Count() > 0)
                {
                    socketParameterModel = cacheSocketParameterData.FirstOrDefault().Value;
                }
            }
            return socketParameterModel;
        }
        #endregion
         
        #region 获取结果信息
        /// <summary>
        /// 获取结果信息
        /// </summary>
        /// <param name="method">方法名称</param>
        /// <param name="model">参数</param>
        /// <returns></returns>
        public static Result GetResultInfo(string method, Result model)
        {
            Result modelResult = new Result();
            modelResult.status = model.status;
            modelResult.msg = model.msg;
            modelResult.data = model.data;
            //LoggerSocketHelper.DebugLog(Environment.NewLine + "方法名称：" + method + Environment.NewLine + "参数信息：" + JsonConvert.SerializeObject(modelResult));
            LoggerSocketHelper.DebugLog(string.Format("方法名称：[{0}], 参数信息：{1}", method, JsonConvert.SerializeObject(modelResult)));

            return modelResult;
        }
        #endregion

        #region 获取方法信息
        /// <summary>
        /// 获取方法信息
        /// </summary>
        /// <returns></returns>
        public static string GetMethodInfo()
        {
            StackTrace ss = new StackTrace(true);
            // index:0为本身的方法；1为调用方法；2为其上上层，依次类推
            System.Reflection.MethodBase mb = ss.GetFrame(1).GetMethod();
            ////StackFrame[] sfs = ss.GetFrames();
            //string systemModule = "模块名:" + mb.Module.ToString() + Environment.NewLine;
            //systemModule += "命名空间名:" + mb.DeclaringType.Namespace + Environment.NewLine;
            ////仅有类名
            //systemModule += "类名:" + mb.DeclaringType.Name + Environment.NewLine;
            //systemModule += "方法名:" + mb.Name;

            string systemModule = mb.Name + " 类名:" + mb.DeclaringType.Name; 
            return systemModule;
        }
        #endregion
         
        #region 获取虚拟连接状态
        /// <summary>
        /// 获取虚拟连接状态
        /// </summary>
        /// <param name="virtualConnectionState">虚拟连接状态</param>
        /// <param name="delaySecondTime">延迟时间(毫秒)</param>
        /// <param name="isBreakConnect">是否断开连接（tue断，false连）</param>
        /// <returns></returns>
        public static Result GetVirtualConnectionState(bool virtualConnectionState, int delaySecondTime, bool isBreakConnect = false)
        {
            if (virtualConnectionState)
            {
                //System.Threading.Thread.Sleep(delaySecondTime);

                Result resultModel = new Result();
                if (isBreakConnect)
                {
                    return resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Completed, msg = "虚拟连接断开状态【成功】" });
                }
                return resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Completed, msg = "虚拟连接状态【成功】" });
            }
            return null;
        }
        #endregion

        #region 连接
        /// <summary>
        /// 连接
        /// </summary>
        /// <param name="equipmentType">类型</param> 
        /// <param name="ip">IP</param>
        /// <param name="port">端口</param>
        /// <param name="equipmentId">设备ID</param>
        /// <returns></returns>
        public static Result Connect(string equipmentType, string ip, int port, string equipmentId)
        {
            Result resultModel = new Result();

            var socketParameterModel = GetSocketParameter(equipmentType, ip, port, equipmentId);
            try
            {
                #region 虚拟连接
                var virtualConnectionStateResult = GetVirtualConnectionState(socketParameterModel.VirtualConnectionState, socketParameterModel.DelaySecondTime);
                if (virtualConnectionStateResult != null && virtualConnectionStateResult.status == StateEnum_Equipment.Completed)
                {
                    return virtualConnectionStateResult;
                }
                #endregion

                if (HxSockServiceExecute.CheckConnected(socketParameterModel.Socket, socketParameterModel.Ip) == false)
                {
                    if (socketParameterModel != null && HxSockServiceExecute.Connect(equipmentType, ip, port, equipmentId))
                    {
                        resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Completed, msg = "连接服务器【成功】" });
                    }
                    else
                    {
                        resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = "连接服务器【失败】" });
                    }
                }
                else
                {
                    resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Completed, msg = "连接服务器【成功】" });
                }
            }
            catch (Exception ex)
            {
                socketParameterModel.Socket.Shutdown(SocketShutdown.Both);
                socketParameterModel.Socket.Close();
                resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = ex.Message });
            }
            return resultModel;
        }
        /// <summary>
        /// 检查连接
        /// </summary>
        /// <param name="equipmentType">类型</param> 
        /// <param name="ip">IP</param>
        /// <param name="port">端口</param>
        /// <param name="equipmentId">设备ID</param>
        /// <returns></returns>
        public static Result CheckConnected(string equipmentType, string ip, int port, string equipmentId)
        {
            Result resultModel = new Result();
            try
            {
                var socketParameterModel = HxSockServiceExecute.GetSocketParameterModel(equipmentType, ip, port, equipmentId);

                if (socketParameterModel != null)
                {
                    #region 虚拟连接
                    var virtualConnectionStateResult = GetVirtualConnectionState(socketParameterModel.VirtualConnectionState, socketParameterModel.DelaySecondTime);
                    if (virtualConnectionStateResult != null && virtualConnectionStateResult.status == StateEnum_Equipment.Completed)
                    {
                        return virtualConnectionStateResult;
                    }
                    #endregion

                    if (HxSockServiceExecute.CheckConnected(socketParameterModel.Socket, socketParameterModel.Ip))
                    {
                        resultModel.status = StateEnum_Equipment.Completed;
                        resultModel.msg = "检查连接【成功】";
                        //resultModel = GetResultInfo(GetMethodInfo(), new Result { status = EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed), msg = "检查连接【成功】" });
                    }
                    else
                    {
                        resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = "检查连接【失败】" });
                    }
                }
                else
                {
                    resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = "检查连接【失败】默认参数为空" });
                }
            }
            catch (Exception ex)
            {
                resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = ex.Message });
            }
            return resultModel;
        }
        #endregion

        #region 断开
        /// <summary>
        /// 断开
        /// </summary>
        /// <param name="equipmentType">类型</param> 
        /// <param name="ip">IP</param>
        /// <param name="port">端口</param>
        /// <param name="equipmentId">设备ID</param>
        /// <returns></returns>
        public static Result BreakConnect(string equipmentType, string ip, int port, string equipmentId)
        {
            Result resultModel = new Result();
            try
            {
                var socketParameterModel = HxSockServiceExecute.GetSocketParameterModel(equipmentType, ip, port, equipmentId);
                if (socketParameterModel == null)
                {
                    resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = "服务器断开【未连接】" });
                    return resultModel;
                }

                #region 虚拟连接
                var virtualConnectionStateResult = GetVirtualConnectionState(socketParameterModel.VirtualConnectionState, socketParameterModel.DelaySecondTime, true);
                if (virtualConnectionStateResult != null && virtualConnectionStateResult.status == StateEnum_Equipment.Completed)
                {
                    socketParameterModel.VirtualConnectionState = false;
                    HxSockServiceExecute.CacheSocketParameterData.Remove(equipmentType + ip + port + equipmentId);
                    return virtualConnectionStateResult;
                }
                #endregion

                if (HxSockServiceExecute.BreakConnect(equipmentType, ip, port, equipmentId))
                {
                    HxSockServiceExecute.CacheSocketParameterData.Remove(equipmentType + ip + port + equipmentId);
                    resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Completed, msg = "服务器已断开【成功】" });
                }
                else
                {
                    resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = "服务器已断开【未连接】" });
                }
            }
            catch (Exception ex)
            {
                resultModel = GetResultInfo(GetMethodInfo(), new Result { status = StateEnum_Equipment.Failed, msg = ex.Message });
            }
            return resultModel;
        }
        #endregion

        #region 获取指令公共模型对象---发送
        /// <summary>
        /// 获取指令公共模型对象---发送
        /// </summary>
        /// <param name="instructCommonMethodSendModel">参数对像</param>
        /// <returns></returns>

        public static InstructCommonMethodSendModel GetInstructCommonMethodSendModel(InstructCommonMethodSendModel instructCommonMethodSendModel)
        { 
            instructCommonMethodSendModel.EquipmentType = instructCommonMethodSendModel.EquipmentType;
            instructCommonMethodSendModel.Ip = instructCommonMethodSendModel.Ip;
            instructCommonMethodSendModel.Port = instructCommonMethodSendModel.Port;
            instructCommonMethodSendModel.EquipmentId = instructCommonMethodSendModel.EquipmentId;

            // wdy
            //if ((instructCommonMethodSendModel.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.SerialPort) ||
            //    instructCommonMethodSendModel.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.SocketUDP) ||
            //    instructCommonMethodSendModel.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.SocketNonstandard)) &&
            //    instructCommonMethodSendModel.MethodParametersModel.Type == EnumManagement.GetEnumValue(ParameterTypeEnum.Send).ToString() &&
            //    instructCommonMethodSendModel.SendData.parameters != null)
            //{
            //    Dictionary<string, object> dicParams = (Dictionary<string, object>)instructCommonMethodSendModel.SendData.parameters;
            //    object value = dicParams.Values.First();
            //    instructCommonMethodSendModel.SendData.parameters = value == null ? string.Empty : value.ToString();
            //}

            if (instructCommonMethodSendModel.SendData.parameters != null)
            {
                instructCommonMethodSendModel.SendData.parameters = instructCommonMethodSendModel.SendData.parameters;// new RobotParameterModel { DestinationName = "1", Pose = "2", TargetName = "3", _Rotation = Enum_Rotation.Forward90 };
            }
            else
            {
                instructCommonMethodSendModel.SendData.parameters = new object();
            }

            instructCommonMethodSendModel.SendData.message_id = HxSockServiceExecute.InstrunctionId();
            instructCommonMethodSendModel.SendData.message_type = 2;
            instructCommonMethodSendModel.SendData.method = instructCommonMethodSendModel.SendData.method;// InstructionEnum_Equipment.Home.ToString();
            instructCommonMethodSendModel.SendData.equipment_id = instructCommonMethodSendModel.EquipmentId;
            instructCommonMethodSendModel.SendData.workflow_id = "workflow_id_" + instructCommonMethodSendModel.SendData.message_id;
            instructCommonMethodSendModel.SendData.experiment_id = instructCommonMethodSendModel.SendData.experiment_id;
            instructCommonMethodSendModel.SendData.estimate_time = 3;
            instructCommonMethodSendModel.SendData.timeout = 3;
            instructCommonMethodSendModel.SendData.description = "description_" + instructCommonMethodSendModel.EquipmentType;
            instructCommonMethodSendModel.SendData.timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

            int count = SocketInteriorService.dicManualResetEvent.Where(m => m.Key == instructCommonMethodSendModel.SendData.experiment_id).Count();
            if (count == 0)
            {
                SocketInteriorService.dicManualResetEvent.Add(instructCommonMethodSendModel.SendData.experiment_id, new ManualResetEvent(true));
            }

            return instructCommonMethodSendModel;
        }
        #endregion
    }
}