OHV/Dev/OHV/VehicleControlSystem/ControlLayer/MQ/ZmqManager.cs

using GSG.NET.Concurrent;
using GSG.NET.Extensions;
using GSG.NET.Logging;
using GSG.NET.ObjectBase;
using NetMQ;
using NetMQ.Monitoring;
using NetMQ.Sockets;
using OHV.Common.Model;
using OHV.Common.Shareds;
using StackExchange.Redis.Extensions.Core.Extensions;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using System.Text;
using System.Threading.Tasks;
using VehicleControlSystem.ControlLayer.Serial.BatteryTabos;
using VehicleControlSystem.ControlLayer.Serial.DataModel;
using VehicleControlSystem.Managers;

namespace VehicleControlSystem.ControlLayer.MQ
{
    public class ZmqManager : ControlObjectBase, IDisposable
    {
        Logger logger = Logger.GetLogger();

        PublisherSocket pub = null;
        SubscriberSocket sub = null;
        RequestSocket req = null;
        ResponseSocket rep = null;

        NetMQPoller poller = null;
        NetMQPoller subPoller = null;
        NetMQMonitor monitor = null;

        BMUManager bMUManager = null;
        Steering steering = null;

        ThreadCancel threadCancel = new ThreadCancel();

        private bool isReqConnected = false;
        public bool IsReqConnected
        {
            get { return isReqConnected; }
            set { isReqConnected = value; }
        }

        #region Properties
        private eSteeringState requestSteering = eSteeringState.None;
        public eSteeringState RequestSteering
        {
            get { return requestSteering; }
            set { SetField( ref this.requestSteering, value ); }
        }

        private bool isDriveMoving = false;
        public bool IsDriveMoving
        {
            get { return isDriveMoving; }
            set
            {
                if ( SetField( ref isDriveMoving, value ) )
                {
                    pub.SendMoreFrame( "DriveStart" ).SendFrame( value.ToString() );
                }
            }
        }

        private eOperatationMode operatationMode;
        public eOperatationMode OperationMode
        {
            get { return operatationMode; }
            set { operatationMode = value; }
        }

        private int currentPointNo;
        public int CurrentPointNo
        {
            get { return currentPointNo; }
            set
            {
                if ( SetField( ref this.currentPointNo, value ) )
                    pub.SendMoreFrame( "CurrentPoint" ).SendFrame( value.ToString() );
            }
        }

        private int segmentID;
        public int SegmentID
        {
            get { return segmentID; }
            set
            {
                if ( SetField( ref this.segmentID, value ) )
                {
                    var segment = RouteManager.Instance.Segments.Where( s => s.ID == value ).FirstOrDefault();
                    if ( segment == null )
                        return;

                    this.pub.SendMoreFrame( "CurrentRailFrom" ).SendFrame( segment.route_type );
                }
            }
        }

        private double frontLoadFactor;
        public double FrontLoadFactor
        {
            get { return frontLoadFactor * 0.1; }
            set { SetField( ref this.frontLoadFactor, value ); }
        }

        private double rearLoadFactor;
        public double RearLoadFactor
        {
            get { return rearLoadFactor * 0.1; }
            set { SetField( ref this.rearLoadFactor, value ); }
        }

        private double frontRPM;
        public double FrontRPM
        {
            get { return Math.Truncate( frontRPM * 10 ) / 10; }
            set { SetField( ref this.frontRPM, value ); }
        }

        private double rearRPM;
        public double RearRPM
        {
            get { return Math.Truncate( rearRPM * 10 ) / 10; }
            set { SetField( ref this.rearRPM, value ); }
        }

        private int currentMCR;

        public int CurrentMCR
        {
            get { return currentMCR; }
            set
            {
                if ( SetField( ref this.currentMCR, value ) )
                {
                    this.pub.SendMoreFrame( "MCRValue" ).SendFrame( value.ToString() );
                }
            }
        }

        #endregion

        public ZmqManager( BMUManager bMU, Steering steering )
        {
            NetMQ.NetMQConfig.Cleanup();

            this.bMUManager = bMU;
            this.steering = steering;
        }

        public void Init()
        {
            pub = new PublisherSocket();
            pub.Bind( "tcp://127.0.0.1:5570" );

            sub = new SubscriberSocket();
            sub.Connect( "tcp://127.0.0.1:5565" );
            //sub.Connect( "tcp://127.0.0.1:5566" );
            //sub.Connect( "tcp://127.0.0.1:5577" );
            sub.Subscribe( "" ); //All
            sub.ReceiveReady += Sub_ReceiveReady;

            rep = new ResponseSocket();
            rep.Bind( "tcp://127.0.0.1:5568" );
            rep.ReceiveReady += Rep_ReceiveReady;

            req = new RequestSocket();
            this.monitor = new NetMQMonitor( req, "inproc://rep.inproc", SocketEvents.Disconnected | SocketEvents.Connected );
            this.monitor.Connected += ( s, a ) => 
            { 
                this.IsReqConnected = true; 
                CurrentPointNo = GetCurrentPointNo();
                SetCurrentSteeringState( this.steering.GetSteeringState() );
            };
            this.monitor.Disconnected += ( s, a ) => { this.IsReqConnected = false; };
            this.monitor.StartAsync();

            req.Connect( "tcp://127.0.0.1:5567" );

            this.poller = new NetMQPoller { this.rep };
            this.poller.RunAsync();

            this.subPoller = new NetMQPoller { this.sub };
            this.subPoller.RunAsync();

            this.bMUManager.OnChangedReceivedData += BMUManager_OnChangedReceivedData;
        }

        private void BMUManager_OnChangedReceivedData( Serial.DataModel.ReceivedData obj )
        {
            var kind = CastTo<eDataKind>.From<Enum>( obj.DataKind );
            switch ( kind )
            {
                case eDataKind.Current:
                    this.pub.SendMoreFrame( "BatteryCurrent" ).SendFrame( obj.Value.ToString() ); ;
                    break;
                case eDataKind.Voltage:
                case eDataKind.BatteryState:
                case eDataKind.ChargeCompleteTime:
                case eDataKind.DisChargeCompleteTime:
                case eDataKind.SOC:
                case eDataKind.SOH:
                case eDataKind.ResidualCapacity:
                case eDataKind.ResidualEnergy:
                case eDataKind.Temperature:
                    break;
                default:
                    break;
            }
        }

        public void Dispose()
        {
            this.threadCancel.Cancel();

            this.monitor.Stop();
            this.monitor.Dispose();

            this.poller.Stop();
            this.poller.Dispose();

            this.subPoller.Stop();
            this.subPoller.Dispose();

            this.sub.Dispose();
            this.req.Dispose();
        }

        private void Rep_ReceiveReady( object sender, NetMQSocketEventArgs e )
        {
            var ret = e.Socket.ReceiveMultipartStrings();
            logger.D( $"[rep] - {ret[1]}" );

            try
            {
                if ( ret[0].Equals( "setm" ) )
                {
                    var v = ret[1].Split( '/' );

                    rep.SendMoreFrame( "setm" ).SendFrame( $"ok/{v[0]}" ); //응답처리 부터 하자.
                    switch ( v[0] )
                    {
                        case "3050":
                            {
                                logger.D( $"[Steering_Rep] - 3050/{v[0]}" );
                                switch ( v[1] )
                                {
                                    case "1":
                                        this.RequestSteering = eSteeringState.Left;
                                        break;
                                    case "-1":
                                        this.RequestSteering = eSteeringState.Right;
                                        break;
                                    default:
                                        this.RequestSteering = eSteeringState.None;
                                        break;
                                }
                            }
                            break;

                        case "111":
                            {
                                if ( v[1].Equals( "1" ) )
                                    OperationMode = eOperatationMode.AutoMode;
                                else
                                    OperationMode = eOperatationMode.ManualMode;
                            }
                            break;

                        case "113":
                            {
                            }
                            break;

                        case "4012":
                            if ( v[1].Equals( "3" ) )
                                IsDriveMoving = true;
                            else
                                IsDriveMoving = false;
                            break;

                        case "3009":
                            {
                                int iV = 0;
                                int.TryParse( v[1], out iV );
                                this.CurrentPointNo = iV;
                                int.TryParse( v[2], out iV );
                                this.SegmentID = iV;
                            }
                            break;
                        default:
                            break;
                    }

                }

                if ( ret[0].Equals( "getm" ) )
                {
                    var v = ret[1].Split( '/' );
                    switch ( v[0] )
                    {
                        case "3060":
                            {
                                switch ( this.steering.GetSteeringState() )
                                {
                                    case eSteeringState.None:
                                        rep.SendMoreFrame( "getm" ).SendFrame( $"ok/{v[0]}/0" );
                                        break;
                                    case eSteeringState.Left:
                                        rep.SendMoreFrame( "getm" ).SendFrame( $"ok/{v[0]}/1" );
                                        break;
                                    case eSteeringState.Right:
                                        rep.SendMoreFrame( "getm" ).SendFrame( $"ok/{v[0]}/-1" );
                                        break;
                                    default:
                                        rep.SendMoreFrame( "getm" ).SendFrame( $"ok/{v[0]}/0" );
                                        break;
                                }
                            }
                            break;
                        default:
                            break;
                    }
                }

            }
            catch ( Exception exception )
            {
                logger.E( exception );
            }
        }

        private void Sub_ReceiveReady( object sender, NetMQ.NetMQSocketEventArgs e )
        {
            var ret = e.Socket.ReceiveMultipartStrings();
            //logger.I( ret );

            var vl = ret[1].Split( '/' );

            switch ( ret[0] )
            {
                case "7028":
                    {
                        var ll = Convert.ToDouble( vl[0] );
                        this.FrontRPM = Math.Truncate( ll * 100 ) / 100;
                        var li = Convert.ToDouble( vl[1] );
                        this.RearRPM = Math.Truncate( li * 100 ) / 100;
                    }
                    break;

                case "7030":
                    {
                        var ll = Convert.ToDouble( vl[0] );
                        this.FrontLoadFactor = Math.Truncate( ll * 100 ) / 100;
                        var rL = Convert.ToDouble( vl[1] );
                        this.RearLoadFactor = Math.Truncate( rL * 100 ) / 100;
                    }
                    break;

                case "3050": //TargetSteering
                    {
                        //switch ( ret[1] )
                        //{
                        //    case "1":
                        //        this.RequestSteering = eSteeringState.Left;
                        //        break;
                        //    case "-1":
                        //        this.RequestSteering = eSteeringState.Right;
                        //        break;
                        //    default:
                        //        this.RequestSteering = eSteeringState.None;
                        //        break;
                        //}
                    }
                    break;

                case "111": //0=StartUp, 1=DeviceOpened, 2=DiviceOpenFailed, 3=ManualOP, 4=AutomaticOp, 5=DeviceCloseed, 6=Finished
                    break;

                case "3010": //진행중의 길의 모양, 0이면 정지 상태
                    {
                        var v = ret[1].Split( ';' );
                        switch ( v[0] )
                        {
                            case "1":
                                //this.RequestSteering = eSteeringState.Left;
                                break;
                            case "-1":
                                //this.RequestSteering = eSteeringState.Right;
                                break;
                            default:
                                //this.RequestSteering = eSteeringState.None;
                                break;
                        }
                    }
                    break;
                //case "Tag":
                //    {
                //        var v = ret[1].Split( ';' );
                //        this.CurrentPointNo = Convert.ToInt16(v[0]);
                //    }
                //break;

                default:
                    break;
            }
        }

        void Th_SubPoller()
        {
            while ( !this.threadCancel.Canceled )
            {
                LockUtils.Wait( 1000 );
                //this.pub.SendMoreFrame( "1000" ).SendFrame( "Test" );
                LockUtils.Wait( 100 );

                NetMQMessage msg = new NetMQMessage();
                if ( this.sub.TryReceiveMultipartMessage( TimeSpan.FromSeconds( 1 ), ref msg ) )
                {
                    var m = msg;
                }
            }
        }

        object lockObj = new object();
        bool Request( string topic, string value, out string response )
        {
            logger.D( $"req - {value}" );

            List<string> repll = new List<string>();
            response = string.Empty;


            lock ( lockObj )
            {
                if ( !this.IsReqConnected )
                    return false;
                try
                {
                    //if ( this.req.HasOut )
                    this.req.SendMoreFrame( topic ).SendFrame( value );

                    if ( this.req.TryReceiveMultipartStrings( TimeSpan.FromSeconds( 5 ), ref repll ) )
                        return true;
                    else
                        return false;

                }
                catch ( Exception e )
                {
                    logger.E( e );
                    this.req.Dispose();
                    //this.monitor.Stop();
                    //this.monitor.Dispose();

                    req = new RequestSocket();
                    //this.monitor = new NetMQMonitor( req, "inproc://rep.inproc", SocketEvents.Disconnected | SocketEvents.Connected );
                    //this.monitor.Connected += ( s, a ) => { this.IsReqConnected = true; CurrentPointNo = GetCurrentPointNo(); };
                    //this.monitor.Disconnected += ( s, a ) => { this.IsReqConnected = false; };
                    //this.monitor.StartAsync();

                    req.Connect( "tcp://127.0.0.1:5567" );

                    return false;
                }
            }
        }

        bool SetRequest( string index, string value )
        {
            logger.D( $"req - {index} / {value}" );

            List<string> repll = new List<string>();

            if ( !this.IsReqConnected )
                return false;

            lock ( lockObj )
            {

                try
                {
                    //if ( this.req.HasOut )
                    this.req.SendMoreFrame( "setm" ).SendFrame( index + "/" + value );

                    if ( !this.req.TryReceiveMultipartStrings( TimeSpan.FromSeconds( 5 ), ref repll ) )
                        return false;
                }
                catch ( Exception e )
                {
                    logger.E( e );
                    this.req.Dispose();
                    //this.monitor.Stop();
                    //this.monitor.Dispose();

                    req = new RequestSocket();
                    //this.monitor = new NetMQMonitor( req, "inproc://rep.inproc", SocketEvents.Disconnected | SocketEvents.Connected );
                    //this.monitor.Connected += ( s, a ) => { this.IsReqConnected = true; CurrentPointNo = GetCurrentPointNo(); };
                    //this.monitor.Disconnected += ( s, a ) => { this.IsReqConnected = false; };
                    //this.monitor.StartAsync();

                    req.Connect( "tcp://127.0.0.1:5567" );

                    return false;
                }
            }
            return true;
        }

        bool GetRequst( string index, out List<string> vll )
        {
            logger.D( $"req - {index}" );

            vll = new List<string>();

            if ( !this.IsReqConnected )
                return false;

            lock ( lockObj )
            {

                try
                {
                    //if ( this.req.HasOut )
                    this.req.SendMoreFrame( "getm" ).SendFrame( index );

                    List<string> repll = new List<string>();

                    if ( !this.req.TryReceiveMultipartStrings( TimeSpan.FromSeconds( 5 ), ref repll ) )
                        return false;

                    repll.RemoveAt( 0 );

                    var ret = repll[0].Split( '/' );
                    repll.Clear();

                    foreach ( var item in ret )
                    {
                        if ( item.Equals( "ok" ) || item.Equals( "nok" ) || item.Equals( index ) )
                            continue;
                        repll.Add( item );
                    }
                    vll = repll;
                }
                catch ( Exception e )
                {
                    logger.E( e );
                    this.req.Dispose();
                    req = new RequestSocket();
                    req.Connect( "tcp://127.0.0.1:5567" );
                    return false;
                }
            }

            return true;
        }

        #region Get Request Method
        public eOperatationMode GetOperationMode()
        {
            List<string> rll;
            if ( !this.GetRequst( "111", out rll ) )
            {
                logger.E( $"[Get Operation Mode] - Response Time Out" );
                return eOperatationMode.InitialMode;
            }

            if ( rll[0].Equals( "1" ) )
                return eOperatationMode.AutoMode;
            else
                return eOperatationMode.ManualMode;
        }

        public int GetCurrentPointNo()
        {
            int ret = 0;
            List<string> rll;
            if ( this.GetRequst( "3009", out rll ) )
            {
                int.TryParse( rll[0], out ret );
            }
            else
                logger.E( $"[Get Current Point] - Response Time Out" );

            return ret;
        }
        #endregion

        #region Set Request Method
        internal int SetStartMove()
        {
            if ( !SetRequest( "3031", "2" ) )
            {
                logger.E( $"[Set Start Move] - Response Time Out" );
                return 38;
            }

            return ConstInt.EXECUTE_SUCCESS;
        }
        internal int SetTargetPoint( string point )
        {
            if ( !SetRequest( "3033", point ) )
            {
                logger.E( $"[Set TargetPoint] - Response Time Out" );
                return 38;
            }

            return ConstInt.EXECUTE_SUCCESS;
        }

        internal void SetObstruction( eObstacleState state )
        {
            string outStr = string.Empty;
            string val = string.Empty;

            switch ( state )
            {
                case eObstacleState.Normal:
                    val = "0";
                    break;
                case eObstacleState.Abnormal:
                    val = "3";
                    break;
                case eObstacleState.Blocked:
                    val = "2";
                    break;
                case eObstacleState.Decelerate:
                    val = "1";
                    break;
                default:
                    break;
            }
            if ( !this.SetRequest( "5001", val ) )
                logger.E( $"[Set Obstruction] - Response Time Out" );

        }

        internal void SetOperationState( eOperatationMode mode )
        {
            string outStr = string.Empty;
            string val = string.Empty;

            if ( mode == eOperatationMode.AutoMode )
                val = "1";
            else if ( mode == eOperatationMode.ManualMode )
                val = "0";
            else
            { }

            if ( !SetRequest( "112", val ) )
                logger.E( $"[Set Operation State] - Response Time Out" );
        }

        internal void SetMCState( bool isOn )
        {
            string outStr = string.Empty;
            string val = string.Empty;

            if ( isOn )
                val = "1";
            else
                val = "0";

            if ( !this.SetRequest( "5000", val ) )
                logger.E( $"[Set MCState] - Response Time Out" );
        }

        internal void SetCurrentSteeringState( eSteeringState state )
        {
            string outStr = string.Empty;
            string val = string.Empty;

            switch ( state )
            {
                case eSteeringState.None:
                    val = "0";
                    break;
                case eSteeringState.Left:
                    val = "1";
                    break;
                case eSteeringState.Right:
                    val = "-1";
                    break;
                default:
                    break;
            }
            if ( !this.SetRequest( "3060", val ) )
                logger.E( $"[Set Current Steering] - Response Time Out" );

            logger.D( $"[Steering_Req] - 3060/{val}" );
        }
        #endregion
    }
}