OHV/Dev/OHV/VehicleControlSystem/Managers/Scheduler.cs

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using GSG.NET.Concurrent;
using GSG.NET.Logging;
using GSG.NET.Utils;
using OHV.Common.Events;
using OHV.Common.Model;
using OHV.Common.Shareds;
using OHV.SqliteDAL;
using Prism.Events;
using VehicleControlSystem.ControlLayer.Serial.BatteryTabos;
using VehicleControlSystem.ControlLayer.Serial.DataModel;

namespace VehicleControlSystem.Managers
{
    public class Scheduler : IDisposable
    {
        static Logger logger = Logger.GetLogger();

        private List<Command> commands;

        public List<Command> CommandsList
        {
            get { return commands; }
            set { commands = value; }
        }

        Thread thread = null;
        bool isThreadAlive = false;

        IEventAggregator eventAggregator;
        AutoManager autoManager;
        SqliteManager sql = null;
        BMUManager bMUManager = null;

        public event Action<Command> OnMaualAddedCommand;

        public bool IsCreateDryRunCommand { get; set; } = false;

        public Scheduler( IEventAggregator ea, AutoManager autoManager, SqliteManager sqlite, BMUManager bMU )
        {
            this.CommandsList = new List<Command>();
            eventAggregator = ea;// CommonServiceLocator.ServiceLocator.Current.GetInstance<IEventAggregator>();
            eventAggregator.GetEvent<VCSMessagePubSubEvent>().Subscribe( OnReceivedMessageEvent );

            this.autoManager = autoManager;
            this.sql = sqlite;
            this.bMUManager = bMU;
        }

        private void OnReceivedMessageEvent( VCSMessageEventArgs obj )
        {
            if ( obj.Kind == VCSMessageEventArgs.eVCSMessageKind.ReqAddCommand )
            {
                //var vInof = sql.VehicleInfoDAL.GetInfo();
                //if ( vInof.VehicleState == OHV.Common.Shareds.eVehicleState.Move )
                //    this.sql.CommandDAL.Clean();

                this.AddCommand( obj.Command );
            }

            //var m = new GUIMessageEventArgs() { MessageText = obj.MessageText, MessageKey = obj.MessageKey };
            //m.Command = ObjectCopyUtils.DeepClone(obj.Command);
            //GUIMessagePublish(m);
        }

        void GUIMessagePublish( GUIMessageEventArgs args )
        {
            eventAggregator.GetEvent<GUIMessagePubSubEvent>().Publish( args );
        }

        public void Init()
        {
            this.isThreadAlive = true;
            this.thread = ThreadUtils.Invoke( this.ExcuteCommand );
        }

        public bool AddCommand( Command cmd )
        {
            try
            {
                this.sql.CommandDAL.Insert( cmd );
                logger.I( $"[Command Added] - Target : {cmd.TargetID} / Type : {cmd.Type}" );
            }
            catch ( Exception ex )
            {
                logger.E( ex );
                return false;
            }

            return true;
        }

        bool RemoveCommand( Command cmd )
        {
            if ( !this.CommandsList.Remove( cmd ) )
            {
                logger.D( $"Scheduler - [Command] : RemoveCommand fail ID-{cmd.CommandID} / Result-{cmd.Result} " );
                return false;
            }

            logger.D( $"Scheduler - [Command] : RemoveCommand OK ID-{cmd.CommandID} / Result-{cmd.Result} " );
            return true;
        }

        void ExcuteCommand()
        {
            while ( isThreadAlive )
            {
                Thread.Sleep( 300 );
                try
                {
                    var state = this.autoManager.OperationModeProperty;
                    switch ( state )
                    {
                        case OHV.Common.Shareds.eOperatationMode.ManualMode:
                            break;
                        case OHV.Common.Shareds.eOperatationMode.AutoMode:
                            {
                                switch ( this.autoManager.AutoModeStateProperty )
                                {
                                    case OHV.Common.Shareds.eAutoModeState.ErrorStop:
                                        break;
                                    case OHV.Common.Shareds.eAutoModeState.StartRun:
                                        break;
                                    case OHV.Common.Shareds.eAutoModeState.Run:
                                        Command cmd = sql.CommandDAL.GetAll().FirstOrDefault();
                                        if ( cmd == null )
                                        {
                                            this.DryRunTest();
                                            continue;
                                        }

                                        DoWork( cmd );
                                        break;
                                    case OHV.Common.Shareds.eAutoModeState.Stop:
                                        break;
                                    default:
                                        break;
                                }
                            }
                            break;
                        case OHV.Common.Shareds.eOperatationMode.InitialMode:
                            break;
                        default:
                            break;
                    }
                }
                catch ( Exception ex )
                {
                    logger.E( ex );
                }
            }
            logger.D( "[Scheduler] - Command Thread Dispose" );
        }


        int copyTarget = 0;
        bool isSTK = false;
        void DryRunTest()
        {
            if ( !IsCreateDryRunCommand )
                return;

            if ( this.bMUManager.ReceivedDataDic[eDataKind.SOC].Value <= 25 )
            {
//!                var chargePoint = "2";
//                Command chageCmd = new Command() { TargetID = chargePoint, Type = eCommandType.Charging };
//                chageCmd.ByWho = eCommandByWho.LocalSystem;

//                this.AddCommand( chageCmd );

                this.IsCreateDryRunCommand = false;
                return;
            }

            //string targetPoint = string.Empty;
            //if ( isSTK )
            //{
            //    targetPoint = RouteManager.Instance.Equipments.Where( x => x.Name.Equals( "CHARGING_02" ) ).SingleOrDefault().pointID.ToString();
            //    isSTK = false;
            //}
            //else
            //{
            //    targetPoint = RouteManager.Instance.Equipments.Where( x => x.Name.Equals( "STOKER_LIFT_IP01" ) ).SingleOrDefault().pointID.ToString();
            //    isSTK = true;
            //}

            //Command cmd = new Command() { TargetID = targetPoint, Type = eCommandType.Move };
            //cmd.ByWho = eCommandByWho.LocalSystem;

            //this.AddCommand( cmd );
            //LockUtils.Wait( 2500 );


            var ram = NumUtils.Random( 0 , RouteManager.Instance.Equipments.Count - 1 );
            if ( ram == this.copyTarget )
                return;
            else
            {
                var target = RouteManager.Instance.Equipments[ ram ];
                this.copyTarget = ram;

                var targetPoint = target.pointID.ToString();
                Command cmd = new Command() { TargetID = targetPoint , Type = eCommandType.Move };
                cmd.ByWho = eCommandByWho.LocalSystem;

                this.AddCommand( cmd );
                LockUtils.Wait( 2500 );

                //if ( ( target.Name.Equals( "CHARGING_02" ) ) || ( target.Name.Equals( "STOKER_LIFT_IP01" ) ) ||
                //    ( target.Name.Equals( "STOKER_LIFT_OP01" ) ) || ( target.Name.Equals( "WORK_STATION_IP01" ) ) ||
                //    ( target.Name.Equals( "WORK_STATION_OP01" ) ) )
                //{
                //    this.copyTarget = ram;

                //    var targetPoint = target.pointID.ToString();
                //    Command cmd = new Command() { TargetID = targetPoint, Type = eCommandType.Move };
                //    cmd.ByWho = eCommandByWho.LocalSystem;

                //    this.AddCommand( cmd );
                //    LockUtils.Wait( 2000 );
                //}
            }
        }

        private void DoWork( Command cmd )
        {
            switch ( cmd.State )
            {
                case OHV.Common.Shareds.eCommandState.Queued:
                    if ( sql.SubCmdDAL.Count <= 0 ) //
                    {
                        switch ( cmd.Type )
                        {
                            case OHV.Common.Shareds.eCommandType.Move:
                            case OHV.Common.Shareds.eCommandType.MoveNLoad:
                            case OHV.Common.Shareds.eCommandType.MoveNUnload:
                            case OHV.Common.Shareds.eCommandType.Charging:
                            case eCommandType.Cancel:
                                CreateSubCommand( cmd, eSubCommandType.Move );
                                break;
                            default:
                                break;
                        }
                        cmd.State = eCommandState.Processing;
                        this.sql.CommandDAL.Update( cmd );

                        if ( cmd.ByWho == OHV.Common.Shareds.eCommandByWho.LocalSystem || cmd.ByWho == OHV.Common.Shareds.eCommandByWho.LocalOverWrite )
                            this.OnMaualAddedCommand?.BeginInvoke( cmd, null, null );
                    }
                    break;

                case OHV.Common.Shareds.eCommandState.Processing:
                    {
                        var subCmd = sql.SubCmdDAL.GetAll().FirstOrDefault();
                        if ( subCmd == null ) // Move 명령을 수행 완료 했다고 판단.
                        {
                            if ( cmd.IsSecondCommanded )
                            {
                                cmd.State = eCommandState.Complete;
                                sql.CommandDAL.Update( cmd );
                                break;
                            }

                            if ( cmd.Type == OHV.Common.Shareds.eCommandType.MoveNLoad )
                            {
                                if ( this.CreateSubCommand( cmd, eSubCommandType.Load ) )
                                    cmd.IsSecondCommanded = true;
                                sql.CommandDAL.Update( cmd );
                                break;
                            }
                            else if ( cmd.Type == OHV.Common.Shareds.eCommandType.MoveNUnload )
                            {
                                if ( this.CreateSubCommand( cmd, eSubCommandType.Unload ) )
                                    cmd.IsSecondCommanded = true;
                                sql.CommandDAL.Update( cmd );
                                break;
                            }
                            else if ( cmd.Type == OHV.Common.Shareds.eCommandType.Charging )
                            {
                                if ( this.CreateSubCommand( cmd, eSubCommandType.Charge ) )
                                    cmd.IsSecondCommanded = true;
                                sql.CommandDAL.Update( cmd );
                                break;
                            }
                            else //Move Command complete
                            {
                                cmd.State = eCommandState.Complete;
                                sql.CommandDAL.Update( cmd );
                                break;
                            }
                        }
                        else
                        {
                            if ( subCmd.CmdID.Equals( cmd.CommandID ) ) //진행중 판단
                                break;
                        }
                    }
                    break;

                case OHV.Common.Shareds.eCommandState.Complete:
                    sql.CommandDAL.Delete( cmd.CommandID );
                    logger.I( $"[Command Deleted] - Target : {cmd.TargetID} / Type : {cmd.Type}" );
                    break;
                default:
                    break;
            }
        }

        private void CommandCancel( Command cmd )
        {
            
        }

        private bool CreateSubCommand( Command cmd, eSubCommandType type )
        {
            //명령을 만들기 전에 Vehicle 의 상태를 확인하여 만들자.
            switch ( type )
            {
                case eSubCommandType.Move:
                    break;
                case eSubCommandType.Load:
                    break;
                case eSubCommandType.Unload:
                    break;
                case eSubCommandType.Charge:
                    break;
                case eSubCommandType.Cancel:
                    break;
                default:
                    break;
            }

            var sub = new SubCmd
            {
                CmdType = SubCmd.eCmdType.Auto,
                Type = type,
                TargetID = cmd.TargetID,
                CmdID = cmd.CommandID,
                TargetList = new List<string>( cmd.TargetList ),
            };

            sql.SubCmdDAL.Insert( sub );
            logger.I( $"{sub.ID} Sub Command Create - Type={sub.Type}, TargetID={sub.TargetID}, CommandID={sub.CmdID}" );

            return true;
        }

        #region IDisposable Support
        private bool disposedValue = false; // 중복 호출을 검색하려면

        protected virtual void Dispose( bool disposing )
        {
            if ( !disposedValue )
            {
                if ( disposing )
                {
                    // TODO: 관리되는 상태(관리되는 개체)를 삭제합니다.
                    this.isThreadAlive = false;
                    if ( !this.thread.Join( 3000 ) )
                        ThreadUtils.Kill( this.thread );
                }

                // TODO: 관리되지 않는 리소스(관리되지 않는 개체)를 해제하고 아래의 종료자를 재정의합니다.
                // TODO: 큰 필드를 null로 설정합니다.

                disposedValue = true;
            }
        }

        // TODO: 위의 Dispose(bool disposing)에 관리되지 않는 리소스를 해제하는 코드가 포함되어 있는 경우에만 종료자를 재정의합니다.
        // ~Scheduler()
        // {
        //   // 이 코드를 변경하지 마세요. 위의 Dispose(bool disposing)에 정리 코드를 입력하세요.
        //   Dispose(false);
        // }

        // 삭제 가능한 패턴을 올바르게 구현하기 위해 추가된 코드입니다.
        public void Dispose()
        {
            // 이 코드를 변경하지 마세요. 위의 Dispose(bool disposing)에 정리 코드를 입력하세요.
            Dispose( true );
            // TODO: 위의 종료자가 재정의된 경우 다음 코드 줄의 주석 처리를 제거합니다.
            // GC.SuppressFinalize(this);
        }
        #endregion
    }
}