using DataEntity.Device;
using DataEntity.Share;
using DataRWDAL.Device;
using HxEnum;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Text;
using XImagingXhandler.XDAL;
using static HxEnum.StateEnum;

namespace HxSocketImplement.Sockets
{
    /// <summary>
    /// 连接设备
    /// </summary>
    public class EquConnect
    {
        #region 服务端
        #region 断开服务端
        /// <summary>
        /// 断开服务端
        /// </summary>
        public static bool BreakDeviceConnect()
        {
            bool isOk = true;

            // 根据项目ID，获取设备列表
            var lstDevice = DeviceConfigDB.GetDeviceConfigListByProjectId(Shared.SoftwareInformation.software_information_id);
            foreach (var item in lstDevice)
            {
                if (item.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.Socket))
                {
                    Result resultModel = HxSocketParameterService.BreakConnect(item.Type, item.Ip, Convert.ToInt32(item.Port), item.EquipmentId);
                    if (resultModel.status == StateEnum_Equipment.Failed)
                    {
                        isOk = false;
                    }
                }

                #region Del
                //else if (item.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.Modbus))
                //{
                //    PLCService.DisposePLC(item.EquipmentId, (item.VirtualConnectionState == EnumManagement.GetEnumValue(VirtualConnectionStateEnum.Virtually)));
                //}
                //else if (item.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.SerialPort))
                //{
                //    SerialPortParameterModel serialPortsModel = new SerialPortParameterModel { PortName = "" };
                //    SerialPorts.CloseSerialPort(serialPortsModel);
                //}
                //else if (item.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.SocketUDP))
                //{
                //    SocketUdpNonstandardClient.Close(new SocketUdpNonstandardParameterModel { EquipmentType = item.Type, Ip = item.Ip, Port = Sys.ConvertToTrimInt(item.Port), EquipmentId = item.EquipmentId });
                //}
                //else if (item.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.SocketNonstandard))
                //{
                //    SocketNonstandardClient.Close(new SocketNonstandardParameterModel { EquipmentType = item.Type, Ip = item.Ip, Port = Sys.ConvertToTrimInt(item.Port), EquipmentId = item.EquipmentId });
                //}
                #endregion
            }

            return isOk;
        }
        #endregion

        #region 作为客户端连接设备的服务端
        /// <summary>
        /// 作为客户端连接设备的服务端
        /// </summary>
        /// <returns></returns>
        public static Result ConnectService()
        {
            Result result = new Result();
            result.msg = JsonConvert.SerializeObject(GetConnectServiceStr());
            return result;
        }
        /// <summary>
        /// 获取服务端链接字符串
        /// </summary>
        /// <returns></returns>
        private static List<string> GetConnectServiceStr()
        {
            var deviceConfigResult = DeviceConfigDB.GetDeviceConfigListByProjectId(Shared.SoftwareInformation.software_information_id);
            List<string> strList = new List<string>();

            foreach (var item in deviceConfigResult)
            {
                StringBuilder sb = new StringBuilder();

                if (item.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.Socket))   //Socket-TCP
                {
                    #region SocketTCP 
                    var socketParameter = HxSocketParameterService.AddSocketDefaultParameter(item.Type, item.Ip, Convert.ToInt32(item.Port), item.EquipmentId,
                        (item.VirtualConnectionState == EnumManagement.GetEnumValue(VirtualConnectionStateEnum.Virtually)));

                    if (socketParameter != null && socketParameter.status == StateEnum_Equipment.Completed)
                    {
                        var result = HxSocketParameterService.Connect(item.Type, item.Ip, Convert.ToInt32(item.Port), item.EquipmentId);
                        if (result != null && result.status == StateEnum_Equipment.Completed)
                        {
                            sb.Append(($"IP【{item.Ip + ":" + item.Port}】，设备【{item.Name + "(" + EnumManagement.GetFieldTextByValue<CommunicateTypeEnum>(item.CommunicateType)})】{result.msg}" + Environment.NewLine));
                        }
                        else
                        {
                            sb.Append(($"IP【{item.Ip + ":" + item.Port}】，设备【{item.Name + "(" + EnumManagement.GetFieldTextByValue<CommunicateTypeEnum>(item.CommunicateType)})】->{result.msg}<-" + Environment.NewLine));
                        }
                    }
                    else
                    {
                        sb.Append(($"IP【{item.Ip + ":" + item.Port}】，设备【{item.Name + "(" + EnumManagement.GetFieldTextByValue<CommunicateTypeEnum>(item.CommunicateType)})】->{socketParameter.msg}<-" + Environment.NewLine));
                    }
                    #endregion
                }

                #region Del
                //else if (item.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.Modbus))   //Modbus
                //{
                //    #region Modbus 
                //    var result = PLCService.ConnectPLC(item.Ip, Sys.ConvertToTrimInt(item.Port), item.EquipmentId,
                //        (item.VirtualConnectionState == EnumManagement.GetEnumValue(VirtualConnectionStateEnum.Virtually)), Sys.ConvertToTrimInt(item.PlcHeartbeatAddress));

                //    if (result != null && result.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed))
                //    {
                //        sb.Append(($"IP【{item.Ip + ":" + item.Port}】，设备【{item.Name + "(" + EnumManagement.GetFieldTextByValue<CommunicateTypeEnum>(item.CommunicateType)})】{result.msg}" + Environment.NewLine));
                //    }
                //    else
                //    {
                //        sb.Append(($"IP【{item.Ip + ":" + item.Port}】，设备【{item.Name + "(" + EnumManagement.GetFieldTextByValue<CommunicateTypeEnum>(item.CommunicateType)})】->{result.msg}<-" + Environment.NewLine));
                //    }
                //    #endregion
                //}
                //else if (item.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.SerialPort))   //SerialPort
                //{
                //    #region SerialPort 
                //    SerialPortParameterModel serialPortsModel = new SerialPortParameterModel();
                //    serialPortsModel.EquipmentType = item.Type;
                //    serialPortsModel.EquipmentId = item.EquipmentId;
                //    serialPortsModel.PortName = item.PortName;
                //    serialPortsModel.VirtualConnectionState = (item.VirtualConnectionState == EnumManagement.GetEnumValue(VirtualConnectionStateEnum.Virtually));
                //    serialPortsModel.DelaySecondTime = 3000;
                //    serialPortsModel.BaudRate = Sys.ConvertToTrimInt(item.BaudRate);
                //    serialPortsModel.Parity = EnumManagement.ToEnum<Parity>(item.Parity);
                //    serialPortsModel.DataBits = Sys.ConvertToTrimInt(item.DataBits);
                //    serialPortsModel.StopBits = EnumManagement.ToEnum<StopBits>(item.StopBits);

                //    var addResult = SerialPorts.AddSerialPortDefaultParameters(serialPortsModel);
                //    if (addResult != null && addResult.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed))
                //    {
                //        var result = SerialPorts.OpenSerialPort(serialPortsModel);
                //        if (result != null && result.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed))
                //        {
                //            sb.Append(($"端口名称【{item.PortName}】，设备【{item.Name + "(" + EnumManagement.GetFieldTextByValue<CommunicateTypeEnum>(item.CommunicateType)})】{result.msg}" + Environment.NewLine));
                //        }
                //        else
                //        {
                //            sb.Append(($"端口名称【{item.PortName}】，设备【{item.Name + "(" + EnumManagement.GetFieldTextByValue<CommunicateTypeEnum>(item.CommunicateType)})】->{result.msg}<-" + Environment.NewLine));
                //        }
                //    }
                //    else
                //    {
                //        sb.Append(($"端口名称【{item.PortName}】，设备【{item.Name + "(" + EnumManagement.GetFieldTextByValue<CommunicateTypeEnum>(item.CommunicateType)})】->{addResult.msg}<-" + Environment.NewLine));
                //    }
                //    #endregion
                //}
                //else if (item.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.SocketUDP))   //SocketUDP
                //{
                //    #region SocketUDP 
                //    SocketUdpNonstandardParameterModel socketUdpNonstandardModel = new SocketUdpNonstandardParameterModel();
                //    socketUdpNonstandardModel.EquipmentType = item.Type;
                //    socketUdpNonstandardModel.EquipmentId = item.EquipmentId;
                //    socketUdpNonstandardModel.Ip = item.Ip;
                //    socketUdpNonstandardModel.Port = Sys.ConvertToTrimInt(item.Port);
                //    socketUdpNonstandardModel.VirtualConnectionState = (item.VirtualConnectionState == EnumManagement.GetEnumValue(VirtualConnectionStateEnum.Virtually));
                //    var socketParameter = SocketUdpNonstandardClient.AddSerialPortDefaultParameters(socketUdpNonstandardModel);

                //    if (socketParameter != null && socketParameter.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed))
                //    {
                //        var result = SocketUdpNonstandardClient.SocketNonstandardConnect(socketUdpNonstandardModel);
                //        if (result != null && result.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed))
                //        {
                //            sb.Append(($"IP【{item.Ip + ":" + item.Port}】，设备【{item.Name + "(" + EnumManagement.GetFieldTextByValue<CommunicateTypeEnum>(item.CommunicateType)})】{result.msg}" + Environment.NewLine));
                //        }
                //        else
                //        {
                //            sb.Append(($"IP【{item.Ip + ":" + item.Port}】，设备【{item.Name + "(" + EnumManagement.GetFieldTextByValue<CommunicateTypeEnum>(item.CommunicateType)})】->{result.msg}<-" + Environment.NewLine));
                //        }
                //    }
                //    else
                //    {
                //        sb.Append(($"IP【{item.Ip + ":" + item.Port}】，设备【{item.Name + "(" + EnumManagement.GetFieldTextByValue<CommunicateTypeEnum>(item.CommunicateType)})】->{socketParameter.msg}<-" + Environment.NewLine));
                //    }
                //    #endregion
                //}
                //if (item.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.SocketNonstandard))   //SocketNonstandard
                //{
                //    #region SocketNonstandard 
                //    SocketNonstandardParameterModel socketNonstandardModel = new SocketNonstandardParameterModel();
                //    socketNonstandardModel.EquipmentType = item.Type;
                //    socketNonstandardModel.EquipmentId = item.EquipmentId;
                //    socketNonstandardModel.Ip = item.Ip;
                //    socketNonstandardModel.Port = Sys.ConvertToTrimInt(item.Port);
                //    socketNonstandardModel.VirtualConnectionState = (item.VirtualConnectionState == EnumManagement.GetEnumValue(VirtualConnectionStateEnum.Virtually));
                //    var socketParameter = SocketNonstandardClient.AddSerialPortDefaultParameters(socketNonstandardModel);

                //    if (socketParameter != null && socketParameter.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed))
                //    {
                //        var result = SocketNonstandardClient.SocketNonstandardConnect(socketNonstandardModel);
                //        if (result != null && result.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed))
                //        {
                //            sb.Append(($"IP【{item.Ip + ":" + item.Port}】，设备【{item.Name + "(" + EnumManagement.GetFieldTextByValue<CommunicateTypeEnum>(item.CommunicateType)})】{result.msg}" + Environment.NewLine));
                //        }
                //        else
                //        {
                //            sb.Append(($"IP【{item.Ip + ":" + item.Port}】，设备【{item.Name + "(" + EnumManagement.GetFieldTextByValue<CommunicateTypeEnum>(item.CommunicateType)})】->{result.msg}<-" + Environment.NewLine));
                //        }
                //    }
                //    else
                //    {
                //        sb.Append(($"IP【{item.Ip + ":" + item.Port}】，设备【{item.Name + "(" + EnumManagement.GetFieldTextByValue<CommunicateTypeEnum>(item.CommunicateType)})】->{socketParameter.msg}<-" + Environment.NewLine));
                //    }
                //    #endregion
                //}
                #endregion

                strList.Add(sb.ToString());
            }
            return strList;
        }

        /// <summary>
        /// 获取检查设备连接状态
        /// </summary>
        /// <returns></returns>
        public static Dictionary<string, bool> GetCheckDeviceConnectState()
        {
            Dictionary<string, bool> dictionaryResult = new Dictionary<string, bool>();
            var deviceConfigResult = DeviceConfigDB.GetDeviceConfigListByProjectId(Shared.SoftwareInformation.software_information_id);

            foreach (var item in deviceConfigResult)
            {
                if (item.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.Socket))    //Socket
                {
                    var checkConnectedResult = HxSocketParameterService.CheckConnected(item.Type, item.Ip, Convert.ToInt32(item.Port), item.EquipmentId);
                    if (checkConnectedResult != null && checkConnectedResult.status == StateEnum_Equipment.Completed)
                    {
                        dictionaryResult.Add(item.Id, true);
                    }
                    else
                    {
                        dictionaryResult.Add(item.Id, false);
                    }
                }

                #region Del
                //else if (item.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.Modbus))   //Modbus
                //{
                //    if (PLCService.PlcConnectState(item.EquipmentId, (item.VirtualConnectionState == EnumManagement.GetEnumValue(VirtualConnectionStateEnum.Virtually))))
                //    {
                //        dictionaryResult.Add(item.Id, true);
                //    }
                //    else
                //    {
                //        dictionaryResult.Add(item.Id, false);
                //    }
                //}
                //else if (item.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.SerialPort))   //SerialPort
                //{
                //    SerialPortParameterModel serialPortsModel = new SerialPortParameterModel();
                //    serialPortsModel.PortName = item.PortName;
                //    if (SerialPorts.IsOpenSerialPortState(serialPortsModel))
                //    {
                //        dictionaryResult.Add(item.Id, true);
                //    }
                //    else
                //    {
                //        dictionaryResult.Add(item.Id, false);
                //    }
                //}
                //else if (item.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.SocketUDP))   //SocketUDP
                //{
                //    SocketUdpNonstandardParameterModel socketUdpNonstandardModel = new SocketUdpNonstandardParameterModel();
                //    socketUdpNonstandardModel.EquipmentType = item.Type;
                //    socketUdpNonstandardModel.EquipmentId = item.EquipmentId;
                //    socketUdpNonstandardModel.Ip = item.Ip;
                //    socketUdpNonstandardModel.Port = Sys.ConvertToTrimInt(item.Port);
                //    socketUdpNonstandardModel.VirtualConnectionState = (item.VirtualConnectionState == EnumManagement.GetEnumValue(VirtualConnectionStateEnum.Virtually));

                //    var checkConnectedResult = SocketUdpNonstandardClient.CheckConnected(socketUdpNonstandardModel);
                //    if (checkConnectedResult != null && checkConnectedResult.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed))
                //    {
                //        dictionaryResult.Add(item.Id, true);
                //    }
                //    else
                //    {
                //        dictionaryResult.Add(item.Id, false);
                //    }
                //}
                //else if (item.CommunicateType == EnumManagement.GetEnumValue(CommunicateTypeEnum.SocketNonstandard))   //SocketNonstandard
                //{
                //    SocketNonstandardParameterModel socketNonstandardModel = new SocketNonstandardParameterModel();
                //    socketNonstandardModel.EquipmentType = item.Type;
                //    socketNonstandardModel.EquipmentId = item.EquipmentId;
                //    socketNonstandardModel.Ip = item.Ip;
                //    socketNonstandardModel.Port = Sys.ConvertToTrimInt(item.Port);
                //    socketNonstandardModel.VirtualConnectionState = (item.VirtualConnectionState == EnumManagement.GetEnumValue(VirtualConnectionStateEnum.Virtually));

                //    var checkConnectedResult = SocketNonstandardClient.CheckConnected(socketNonstandardModel);
                //    if (checkConnectedResult != null && checkConnectedResult.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed))
                //    {
                //        dictionaryResult.Add(item.Id, true);
                //    }
                //    else
                //    {
                //        dictionaryResult.Add(item.Id, false);
                //    }
                //}
                #endregion
            }
            return dictionaryResult;
        }
        #endregion 
        #endregion

        #region 客户端
        #region 连接设备
        /// <summary>
        ///  连接设备
        /// </summary> 
        /// <returns></returns>
        public static Result GetClientConnect()
        {
            StringBuilder sb = new StringBuilder();
            Result result = new Result();
            // wdy
            //var model = SharedClientModel.ServiceConfigModel;
            //if (model != null)
            //{
            //    var modelParameter = HxSocketParameterService.AddSocketDefaultParameter(ParameterEnum.Enum_Equipment.Client.ToString(), model.Ip, Convert.ToInt32(model.Port), "");
            //    if (modelParameter != null && modelParameter.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed))
            //    {
            //        result = HxSocketParameterService.Connect(ParameterEnum.Enum_Equipment.Client.ToString(), model.Ip, Convert.ToInt32(model.Port), "");
            //        sb.Append($"【{model.ProName}】{result.msg}");
            //    }
            //    else
            //    {
            //        sb.Append($"【{model.ProName}】{modelParameter.msg}");
            //    }
            //}
            //result.msg = sb.ToString();
            return result;
        }
        #endregion

        #region 发消息给服务
        /// <summary>
        /// 发消息给服务
        /// </summary>
        /// <param name="HxSendBase">发送数据参数类</param> 
        /// <returns></returns>
        public static Result SendData(HxSendBase sendModel)
        {
            Result resultModel = new Result();
            //try
            //{
            //    var model = new ServiceConfigBLL().GetServiceConfigIsDefault();
            //    if (model != null)
            //    {
            //        var socketParameterModel = HxSockServiceExecute.GetSocketParameterModel(ParameterEnum.Enum_Equipment.Client.ToString(), model.Ip, Convert.ToInt32(model.Port), "");
            //        if (socketParameterModel != null)
            //        {
            //            #region 虚拟连接
            //            var virtualConnectionStateResult = HxSocketParameterService.GetVirtualConnectionState(socketParameterModel.VirtualConnectionState, socketParameterModel.DelaySecondTime);
            //            if (virtualConnectionStateResult != null && virtualConnectionStateResult.status == EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Completed))
            //            {
            //                return virtualConnectionStateResult;
            //            }
            //            #endregion

            //            #region 参数  
            //            InstructCommonMethodSendModel instructCommonMethodSendModel = HxSocketParameterService.GetInstructCommonMethodSendModel(new InstructCommonMethodSendModel()
            //            {
            //                EquipmentType = ParameterEnum.Enum_Equipment.Client.ToString(),
            //                Ip = model.Ip,
            //                Port = Convert.ToInt32(model.Port),
            //                EquipmentId = "",
            //                //  Parameters = new RobotParameterModel { DestinationName = "1", Pose = "2", TargetName = "3", _Rotation = Enum_Rotation.Forward90 },// txt_content.Text.Trim(),
            //                //Parameters = JsonHelp.SerializeObject(new RobotParameterModel { DestinationName = "1", Pose = "2", TargetName = "3", _Rotation = Enum_Rotation.Forward90 }, new List<string> { "DestinationName", "Pose", "TargetName", "_Rotation" }),
            //                SendData = new HxSendBase { experiment_id = sendModel.experiment_id, parameters = sendModel.parameters, method = sendModel.method, ExpOperationType = sendModel.ExpOperationType },

            //            });
            //            #endregion

            //            string sendJson = JsonConvert.SerializeObject(instructCommonMethodSendModel);
            //            resultModel = HxSockServiceExecute.SendData(ParameterEnum.Enum_Equipment.Client.ToString(), model.Ip, Convert.ToInt32(model.Port), "", sendJson, instructCommonMethodSendModel.SendData.workflow_id);
            //        }
            //        else
            //        {
            //            resultModel = HxSocketParameterService.GetResultInfo(HxSocketParameterService.GetMethodInfo(), new Result { status = EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Failed), msg = "获取指定设备类型缓存数据未获取到" });
            //        }
            //    }
            //    else
            //    {
            //        resultModel = HxSocketParameterService.GetResultInfo(HxSocketParameterService.GetMethodInfo(), new Result { status = EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Failed), msg = "设备数据未获取到" });
            //    }
            //}
            //catch (Exception ex)
            //{
            //    resultModel = HxSocketParameterService.GetResultInfo(HxSocketParameterService.GetMethodInfo(), new Result { status = EnumManagement.GetEnumValue(StateEnum.StateEnum_Equipment.Failed), msg = ex.Message });
            //}
            return resultModel;
        }
        #endregion
        #endregion
    }
}