using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using FluentResults;
using GSG.NET.Concurrent;
using GSG.NET.Excel;
using GSG.NET.Extensions;
using GSG.NET.Logging;
using GSG.NET.Quartz;
using GSG.NET.Utils;
using OHV.Common.Events;
using OHV.Common.Model;
using OHV.Common.Shareds;
using OHV.SqliteDAL;
using Prism.Events;
using Prism.Ioc;
using Prism.Modularity;
using VehicleControlSystem.ControlLayer;
using VehicleControlSystem.ControlLayer.Drive;
using VehicleControlSystem.ControlLayer.IO;
using VehicleControlSystem.ControlLayer.MQ;
using VehicleControlSystem.ControlLayer.Serial.BatteryTabos;
using VehicleControlSystem.Managers;

namespace VehicleControlSystem
{
    [Module(ModuleName = "VCSystem")]
    public class VCSystem : IModule, IDisposable
    {
        Logger logger = Logger.GetLogger();

        Scheduler scheduler = null;
        public AutoManager autoManager = null;
        HostManager hostManager = null;
        SqliteManager sql = null;

        IEventAggregator eventAggregator = null;

        public IIO IO = null;
        public ZmqManager ZmqManager { get; set; }
        BMUManager bMUManager = null;
        Conveyor conveyor = null;
        Steering steering = null;
        GSIDrive drive = null;
        Clamp clamp = null;
        public Vehicle vehicle = null;

        public RouteManager RouteManager { get; set; }

        public List<Alarm> Alarms { get; set; }

        public VCSystem(IEventAggregator ea, SqliteManager sql)
        {
            this.sql = sql;

            this.eventAggregator = ea;

            this.eventAggregator.GetEvent<ApplicationExitEvent>().Subscribe((o) => Dispose(), true);

            this.eventAggregator.GetEvent<VCSMessagePubSubEvent>().Unsubscribe(ReceivedMessageEvent);
            this.eventAggregator.GetEvent<VCSMessagePubSubEvent>().Subscribe(this.ReceivedMessageEvent, ThreadOption.BackgroundThread);
        }

        public void Init()
        {
            GSG.NET.Utils.MidnightNotifier.DayChanged += MidnightNotifier_DayChanged;

            QuartzUtils.Invoke("HIS_ALARM", QuartzUtils.GetExpnHour(5), this.CleanHisAlarm);

            this.Alarms = new ExcelMapper(Path.Combine(System.Environment.CurrentDirectory) + @"\Config\AlarmDefind.xlsx").Fetch<Alarm>().ToList();

            this.RouteManager = RouteManager.Instance;
            RouteManager.Instance.Init(this.sql);

            //Create IO
            this.IO = new EzIO();
            var mapPath = Path.Combine(System.Environment.CurrentDirectory) + @"\Config\IO.xlsx";
            this.IO.LoadIOMap(mapPath);
            this.IO.RunIOThread();

            var ezIO = this.IO as EzIO;
            ezIO.OnContd += EzIO_OnContd;
            ezIO.OnDiscontd += EzIO_OnDiscontd;
            ezIO.OnChangedIO += EzIO_OnChangedIO;
            ezIO.OnFirstColtd += EzIO_OnFirstColtd;

            //Battery
            this.bMUManager = new BMUManager();
            this.bMUManager.BMUConfig = new ControlLayer.Serial.BatteryTabos.Config() { ID = "0" };
            var setV = Convert.ToInt32(sql.ConfigDal.GetById(ConstString.BatteryCanType).Value);
            var canType = CastTo<BMUManager.eCANSelect>.From<int>(setV);
            this.bMUManager.Connect(canType);

            //Conveyor
            this.conveyor = new Conveyor(this.IO as EzIO);

            //Clamp
            this.clamp = new Clamp(this.sql, this.eventAggregator);
            this.clamp.Init();

            //Steering
            this.steering = new Steering();

            //ZeroMQ
            this.ZmqManager = new ZmqManager();
            this.ZmqManager.AssignRefObject(this.bMUManager, this.steering, this.IO);
            this.ZmqManager.Init();

            this.steering.AssignRefObject(this.IO, this.sql, this.eventAggregator, this.ZmqManager);

            //Drive
            this.drive = new GSIDrive(this.sql, this.steering, this.ZmqManager, this.Alarms);
            this.drive.Init();

            //Process
            this.autoManager = new AutoManager(this.IO, this.eventAggregator, this.sql, this.Alarms);
            this.scheduler = new Scheduler(eventAggregator, this.autoManager, this.sql, this.bMUManager);
            this.vehicle = new Vehicle(this.eventAggregator);

            this.hostManager = new HostManager(this.eventAggregator, this.vehicle, this.sql, this.autoManager, this.scheduler, this.IO);

            var refObject = new VehicleRefObjects();
            refObject.IO = this.IO as EzIO;
            refObject.BMUManager = this.bMUManager;
            refObject.Drive = this.drive;
            refObject.Conveyor = this.conveyor;
            refObject.Clamp = this.clamp;
            refObject.Steering = this.steering;
            refObject.ZmqManager = this.ZmqManager;
            refObject.Alarms = this.Alarms;
            refObject.Sqlite = this.sql;
            refObject.AutoManager = this.autoManager;
            refObject.HostManager = this.hostManager;

            this.vehicle.DependencyInjection(refObject);
            this.vehicle.PropertyChanged += Vehicle_PropertyChanged;

            this.hostManager.Init();
            this.vehicle.Init();
            this.scheduler.Init();
            this.autoManager.Init(this.vehicle);

            this.sql.CommandDAL.Clean();
            this.sql.SubCmdDAL.Clean();
        }

        private void MidnightNotifier_DayChanged(object sender, EventArgs e)
        {
            try
            {
                var info = this.sql.VehicleInfoDAL.GetAll().FirstOrDefault();
                var iDist = Convert.ToInt32(info.CumulativeDistance);
                this.hostManager.Send_TotalDistacne(iDist);
            }
            catch (Exception ex)
            {
                logger.E(ex);
            }        
        }

        void UIRenderingComplete()
        {
        }

        private void Vehicle_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            var arg = new GUIMessageEventArgs();
            arg.Kind = GUIMessageEventArgs.eGUIMessageKind.ModelPropertyChange;
            arg.MessageKey = MessageKey.Vehicle;
            arg.ModelPropertyName = e.PropertyName;

            var property = sender.GetType().GetProperty(e.PropertyName);
            var newValue = property.GetValue(sender, null);

            arg.ModelPropertyName = e.PropertyName;
            arg.Args = newValue;

            GUIMessageEventPublish(arg);
        }

        public void CleanHisAlarm()
        {
            var backup = DateTime.Now.AddDays(-15);
            sql.HisAlarmDAL.Delete(x => x.OccurTime < backup);
        }

        #region EzIO Event
        private void EzIO_OnChangedIO(BitBlock bit)
        {
            //this.eventAggregator.GetEvent<IOChangedPubSubEvent>().Publish(new IOChangedMessageEventArgs { Args = bit });
        }

        private void EzIO_OnDiscontd(string ID)
        {
            //throw new NotImplementedException();
        }

        private void EzIO_OnContd(string ID)
        {
            //IO 연결 시 할일 들을 여기서 하자.
            this.IO.OutputOn("OUT_TEACH_MODE");
            this.autoManager.LampStateProperty = eLampState.Alarm;

            //throw new NotImplementedException();
        }

        private void EzIO_OnFirstColtd(string ID)
        {
            if (this.IO.IsOff("IN_MC_ON"))
            {
                this.vehicle.OccurVehicleAlarm(29);
            }

            this.steering.RequestControl(eSteeringState.Left);//초기에 직선 주행 상태로 핸들 조정.
        }

        #endregion

        #region ReqMessage Method
        void ReceivedMessageEvent(VCSMessageEventArgs msg)
        {
            switch (msg.Kind)
            {
                case VCSMessageEventArgs.eVCSMessageKind.ReqIOObject:
                    ReqIOObjectMessage();
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqIOMapList:
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqCommandList:
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqAutoModeChange:
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqManualModeChange:
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ModelPropertyChange:
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqAlarmReset:
                    ReqAlarmReset();
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqVehicleModeChange:
                    this.ReqVehicleModeChange(msg);
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqEStop:
                    ReqEStop();
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqBuzzerStop:
                    ReqBuzzerStop();
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqMachineModeChg:
                    ReqMachineModeChg(msg);
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqAddCommand:
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqTest:
#if TEST
                    ReqTest();
#endif
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqConveyorMove:
                    ReqConveyorMove(msg);
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqConveyorLoad:
                    ReqConveyorLoad(msg);
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqConveyorUnload:
                    ReqConveyorUnload();
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqObstaclePatternChg:
                    ReqObsticlePatternChange(msg);
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqObstaclePatternNo:
                    ReqObsticlePatternNo();
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqPIOConveyor:
                    this.ReqPIOConveyor(msg);
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqPIOBatteryCharge:
                    this.ReqPIOBattery(msg);
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqBatteryState:
                    this.ReqBatteryState();
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqPIOBatteryChargeStop:
                    this.ReqBatteryChargeStop(msg);
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqRouteManager:
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqDirveSpeed:
                    this.ReqSetDriveSpeed(msg);
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqSpeedProfile:
                    this.ReqSetSpeedProfile(msg);
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqJogSpeed:
                    this.ReqSetJogSpeed(msg);
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqParamsSave:
                    this.ReqParamsSave(msg);
                    break;
                case VCSMessageEventArgs.eVCSMessageKind.ReqVehicleOnRailStateChg:
                    this.ReqVehicleOnRailStateChg(msg);
                    break;

                default:
                    break;
            }
        }

        private void ReqVehicleOnRailStateChg(VCSMessageEventArgs msg)
        {
            var reply = new GUIMessageEventArgs();
            reply.Kind = GUIMessageEventArgs.eGUIMessageKind.RspVehicleOnRailStateChg;

            var mode = CastTo<eVehicleOnRailState>.From<object>(msg.Arg);
            if (mode == eVehicleOnRailState.Install)
            {
                this.vehicle.VehicleOnRailState = eVehicleOnRailState.Install;
                reply.Args = eVehicleOnRailState.Install;
                reply.Result = FluentResults.Results.Ok<eVehicleOnRailState>(eVehicleOnRailState.Install);
            }
            else
            {
                this.vehicle.VehicleOnRailState = eVehicleOnRailState.Removed;
                reply.Args = eVehicleOnRailState.Removed;
                reply.Result = FluentResults.Results.Ok<eVehicleOnRailState>(eVehicleOnRailState.Removed);
            }

            GUIMessageEventPublish(reply);
        }

        private void ReqParamsSave(VCSMessageEventArgs msg)
        {
            var reply = new GUIMessageEventArgs
            {
                Kind = GUIMessageEventArgs.eGUIMessageKind.RspParamsSave,
                Result = FluentResults.Results.Fail("Fail ReqParamsSave"),
            };

            var result = this.ZmqManager.SetJogSpeed((double)msg.Args["JogSpeed"]);
            if (!result)
            {
                GUIMessageEventPublish(reply);
                return;
            }

            result = this.ZmqManager.SetDriveSpeed(msg.Args["Linear"].ToString(), msg.Args["Curve"].ToString());
            if (!result)
            {
                logger.E($"Set DriveSPeed Error");
                return;
            }

            result = this.ZmqManager.SetDriveSpeedProfile(msg.Args["Accel"].ToString(), msg.Args["Decel"].ToString(),
                    msg.Args["Creep"].ToString(), msg.Args["CreepDistance"].ToString());
            if (!result)
            {
                logger.E($"Set SpeedProfile Error");
                return;
            }

            //Save Parameter.
            int ret = this.ZmqManager.SetDriveControl(eDriveControl.ParameterSave);
            if (ret != ConstInt.EXECUTE_SUCCESS)
            {
                GUIMessageEventPublish(reply);
                return;
            }

            reply.Result = FluentResults.Results.Ok();
            GUIMessageEventPublish(reply);

            //refresh Parameter.
            this.ZmqManager.SynchronizedParmeter();
        }
        private void ReqSetJogSpeed(VCSMessageEventArgs msg)
        {
            var reply = new GUIMessageEventArgs
            {
                Kind = GUIMessageEventArgs.eGUIMessageKind.RspJogSpeed,
                Result = FluentResults.Results.Fail("Fail SetJogSpeed"),
            };

            if (msg.Args.ContainsKey("JogSpeed"))
            {
                if (this.ZmqManager.SetJogSpeed((double)msg.Args["JogSpeed"]))
                {
                    reply.Result = FluentResults.Results.Ok();
                }
            }

            GUIMessageEventPublish(reply);
        }

        private void ReqSetSpeedProfile(VCSMessageEventArgs msg)
        {
            var reply = new GUIMessageEventArgs
            {
                Kind = GUIMessageEventArgs.eGUIMessageKind.RspSpeedProfile,
                Result = FluentResults.Results.Fail("Fail SetSpeedProfile"),
            };

            if (msg.Args.ContainsKey("Accel") && msg.Args.ContainsKey("Decel") && msg.Args.ContainsKey("Creep") && msg.Args.ContainsKey("CreepDistance"))
            {
                if (this.ZmqManager.SetDriveSpeedProfile(msg.Args["Accel"].ToString(), msg.Args["Decel"].ToString(),
                    msg.Args["Creep"].ToString(), msg.Args["CreepDistance"].ToString()))
                {
                    reply.Result = FluentResults.Results.Ok();
                }
            }

            GUIMessageEventPublish(reply);
        }

        private void ReqSetDriveSpeed(VCSMessageEventArgs msg)
        {
            var reply = new GUIMessageEventArgs
            {
                Kind = GUIMessageEventArgs.eGUIMessageKind.RspDirveSpeed,
                Result = FluentResults.Results.Fail("Fail SetSpeedProfile"),
            };

            if (msg.Args.ContainsKey("Linear") && msg.Args.ContainsKey("Curve"))
            {
                if (this.ZmqManager.SetDriveSpeed(msg.Args["Linear"].ToString(), msg.Args["Curve"].ToString()))
                {
                    reply.Result = FluentResults.Results.Ok();
                }
            }

            GUIMessageEventPublish(reply);
        }

        void ReqBatteryState()
        {
            BatteryInfo battery = new BatteryInfo();

            battery.Voltage = vehicle.BatteryVoltage;
            battery.Current = vehicle.BatteryCurrent;
            battery.ChargeTime = vehicle.BatteryChargeTime;
            battery.DisChargeTime = vehicle.BatteryDisChargeTime;
            battery.Capacity = vehicle.BatteryCapacity;
            battery.Energy = vehicle.BatteryEnergy;
            battery.SOC = vehicle.BatteryStateOfCharge;
            battery.SOH = vehicle.BatteryStateOfHealth;
            battery.State = vehicle.BatteryState;
            battery.IsConnect = vehicle.BatteryIsConnect;
            battery.Temperature = vehicle.BatteryTemperature;

            var reply = new GUIMessageEventArgs()
            {
                Args = battery,
                Kind = GUIMessageEventArgs.eGUIMessageKind.RspBatteryState
            };

            GUIMessageEventPublish(reply);
        }
        private void ReqConveyorMove(VCSMessageEventArgs msg)
        {
            this.vehicle.ReqConveyorMove(msg.MessageText);
        }

        private void ReqObsticlePatternNo()
        {
            var reply = new GUIMessageEventArgs();
            reply.Kind = GUIMessageEventArgs.eGUIMessageKind.RspObstaclePatternNo;
            reply.MessageText = this.vehicle.GetObstacleDetectPattern().ToString();

            GUIMessageEventPublish(reply);
        }

        private void ReqObsticlePatternChange(VCSMessageEventArgs msg)
        {
            var patternNo = Convert.ToInt32(msg.MessageText);
            this.vehicle.ChgObstacleDetectPattern(patternNo);

            var reply = new GUIMessageEventArgs();
            reply.Kind = GUIMessageEventArgs.eGUIMessageKind.RspObstaclePatternChg;
            reply.Result = FluentResults.Results.Ok();

            GUIMessageEventPublish(reply);
        }

        private void ReqConveyorUnload()
        {
            int result = 0;
            result = this.vehicle.ConveyorUnload();

            result = this.vehicle.ConveyorLoad();

            var reply = new GUIMessageEventArgs()
            {
                Kind = GUIMessageEventArgs.eGUIMessageKind.RspConveyorLoad,
                Result = FluentResults.Results.Ok()
            };

            if (result != 0)
            {
                reply.Result = FluentResults.Results.Fail("Conveyor Load FAIL");
            }

            GUIMessageEventPublish(reply);
        }

        private void ReqConveyorLoad(VCSMessageEventArgs msg)
        {
            int result = 0;

            result = this.vehicle.ConveyorLoad();

            var reply = new GUIMessageEventArgs()
            {
                Kind = GUIMessageEventArgs.eGUIMessageKind.RspConveyorLoad,
                Result = FluentResults.Results.Ok()
            };

            if (result != 0)
            {
                reply.Result = FluentResults.Results.Fail("Conveyor Load FAIL");
            }

            GUIMessageEventPublish(reply);
        }

        private void ReqPIOConveyor(VCSMessageEventArgs msg)
        {
            int result = 0;

            var reply = new GUIMessageEventArgs()
            {
                Kind = GUIMessageEventArgs.eGUIMessageKind.RspPIOConveyor,
                MessageText = msg.MessageText,

            };

            /*PIO Load// Unload*/
            if (msg.MessageText.Equals("PL"))
                result = this.vehicle.ManualPIOAndLoad();
            else
                result = this.vehicle.ManualPIOAndUnlaod();

            //실행 결과 확인 
            if (result == ConstInt.EXECUTE_SUCCESS)
                reply.Result = FluentResults.Results.Ok();
            else
            {
                string alarmText = string.Empty;
                var alarm = this.Alarms.Where(a => a.AlarmId == result).FirstOrDefault();
                if (alarm == null)
                    alarmText = "Not Define";
                else
                    alarmText = alarm.Text;

                reply.Result = FluentResults.Results.Fail(alarmText);
            }

            GUIMessageEventPublish(reply);
        }

        private void ReqPIOBattery(VCSMessageEventArgs msg)
        {
            int result = 1;

            var reply = new GUIMessageEventArgs()
            {
                Kind = GUIMessageEventArgs.eGUIMessageKind.RspPIOBatteryCharge,
                MessageText = msg.MessageText,
            };

            result = this.vehicle.StartBatteryCharge();

            if (result == ConstInt.EXECUTE_SUCCESS)
                reply.Result = FluentResults.Results.Ok();
            else
            {
                string alarmText = string.Empty;
                var alarm = this.Alarms.Where(a => a.AlarmId == result).FirstOrDefault();
                if (alarm == null)
                    alarmText = "Not Define";
                else
                    alarmText = alarm.Text;

                reply.Result = FluentResults.Results.Fail(alarmText);
            }

            GUIMessageEventPublish(reply);
        }

        private void ReqBatteryChargeStop(VCSMessageEventArgs msg)
        {
            int result = 1;

            var reply = new GUIMessageEventArgs()
            {
                Kind = GUIMessageEventArgs.eGUIMessageKind.RsqPIOBatteryChargeStop,
                MessageText = msg.MessageText,
            };

            result = this.vehicle.StopBatteryCharge();

            if (result <= 0)
                reply.Result = FluentResults.Results.Ok();
            else
                reply.Result = FluentResults.Results.Fail("Battery Charge Stop Fail");

            GUIMessageEventPublish(reply);
        }

        private void ReqTest()
        {
            var isS = QuartzUtils.StopSchedule("SteerTest");

            LockUtils.Wait(1000);
            QuartzUtils.Invoke("SteerTest", QuartzUtils.GetExpnSecond(30), StartSteerTest);
        }

        bool isSteerLeft = true;
        void StartSteerTest()
        {
            var sT = SwUtils.CurrentTimeMillis;

            if (isSteerLeft)
            {
                this.steering.RequestControl(eSteeringState.Right);
                isSteerLeft = false;
            }
            else
            {
                this.steering.RequestControl(eSteeringState.Left);
                isSteerLeft = true;
            }
        }

        private void ReqMachineModeChg(VCSMessageEventArgs msg)
        {
            var reply = new GUIMessageEventArgs();
            reply.Kind = GUIMessageEventArgs.eGUIMessageKind.RspMachineModeChg;

            var mode = CastTo<eMachineMode>.From<object>(msg.Arg);
            if (mode == eMachineMode.HostMode)
            {
                if (this.autoManager.OperationModeProperty != eOperatationMode.AutoMode)
                    reply.Result = FluentResults.Results.Fail("Vehicle Not Start");
                else
                {
                    if (vehicle.VehicleOnRailState != eVehicleOnRailState.Install)
                        reply.Result = Results.Fail("Vehicle is not On Rail");
                    else
                    {
                        this.vehicle.MachineMode = eMachineMode.HostMode;
                        reply.Result = FluentResults.Results.Ok();
                        reply.Args = eMachineMode.HostMode;
                    }
                }
            }
            else
            {
                this.vehicle.MachineMode = eMachineMode.LocalMode;
                reply.Result = FluentResults.Results.Ok<eMachineMode>(eMachineMode.LocalMode);
                reply.Args = eMachineMode.LocalMode;
            }

            GUIMessageEventPublish(reply);
        }

        private void ReqBuzzerStop()
        {
            this.IO.OutputOff("OUT_BUZZER_00");
            this.IO.OutputOff("OUT_BUZZER_01");
            this.IO.OutputOff("OUT_BUZZER_02");
        }

        private void ReqAlarmReset()
        {
            //this.autoManager.IsErrorProcessing = false;
            //this.vehicle.VehicleStateProperty = eVehicleState.Idle;

            if (!this.IO.IsOn("IN_MC_ON"))
            {
                this.IO.WriteOutputIO("OUT_SAFETY_RESET", true);
                Thread.Sleep(2000);
                this.IO.WriteOutputIO("OUT_SAFETY_RESET", false);
                Thread.Sleep(1000);
            }

            if (this.conveyor.IsInverterError())
            {
                this.conveyor.OnOffConveyor(false);
            }

            this.ZmqManager.SetDriveControl(eDriveControl.ResetFault);

            this.autoManager.IsErrorProcessing = false;
            this.vehicle.VehicleStateProperty = eVehicleState.Idle;
            this.vehicle.PIOClear();
        }

        private void ReqEStop()
        {
            this.vehicle.EStop();
            autoManager.ProcessAlarm(23);
        }

        private void ReqVehicleModeChange(VCSMessageEventArgs msg)
        {
            GUIMessageEventArgs reply;
            if (msg.MessageKey.Equals(MessageKey.AutoMode))
            {
//#if TEST
//                if (!QuartzUtils.StopSchedule("SteerTest"))
//                    return;
//#endif

                if (!this.ZmqManager.IsReqConnected)
                {
                    reply = new GUIMessageEventArgs { Kind = GUIMessageEventArgs.eGUIMessageKind.RspVehicleModeChange, Result = FluentResults.Results.Fail(new Error("Drive P/G not Connected")), MessageKey = MessageKey.ManualMode };
                    GUIMessageEventPublish(reply);
                    return;
                }

                if (!this.ZmqManager.IsCanStanbyLocation)
                {
                    reply = new GUIMessageEventArgs { Kind = GUIMessageEventArgs.eGUIMessageKind.RspVehicleModeChange, Result = FluentResults.Results.Fail(new Error("NotOnRoute")), MessageKey = MessageKey.ManualMode };
                    GUIMessageEventPublish(reply);
                    return;
                }

                int result = vehicle.InitializationVehicle();
                if (result != ConstInt.EXECUTE_SUCCESS)
                {
                    var al = this.Alarms.FirstOrDefault(a => a.AlarmId == result);
                    reply = new GUIMessageEventArgs { Kind = GUIMessageEventArgs.eGUIMessageKind.RspVehicleModeChange, Result = FluentResults.Results.Fail(new Error(al.Text)), MessageKey = MessageKey.ManualMode };
                    GUIMessageEventPublish(reply);
                    return;
                }

                //ToDo: 주행 측 준비 되면 활성.
                result = drive.DriveInit();
                if (result != ConstInt.EXECUTE_SUCCESS)
                {
                    var al = this.Alarms.FirstOrDefault(a => a.AlarmId == result);
                    if (al == null)
                        al = new Alarm()
                        {
                            Text = "Not Define"
                        };
                    reply = new GUIMessageEventArgs { Kind = GUIMessageEventArgs.eGUIMessageKind.RspVehicleModeChange, Result = FluentResults.Results.Fail(new Error(al.Text)), MessageKey = MessageKey.ManualMode };
                    GUIMessageEventPublish(reply);
                    return;
                }

                if (!ZmqManager.SetOperationState(eOperatationMode.AutoMode))
                {
                    var al = this.Alarms.Where(x => x.AlarmId == 38).FirstOrDefault();
                    reply = new GUIMessageEventArgs { Kind = GUIMessageEventArgs.eGUIMessageKind.RspVehicleModeChange, Result = FluentResults.Results.Fail(new Error(al.Text)), MessageKey = MessageKey.ManualMode };
                    GUIMessageEventPublish(reply);
                    return;
                }

                //2020.08.13. Kang. Break 는 자동 상태 일때 주행에서 Control.
                this.IO.OutputOff("OUT_DRIVE_BRAKE_OFF");

                this.autoManager.AutoModeStateProperty = eAutoModeState.StartRun;
                this.autoManager.OperationModeProperty = eOperatationMode.AutoMode;
                reply = new GUIMessageEventArgs { Kind = GUIMessageEventArgs.eGUIMessageKind.RspVehicleModeChange, Result = FluentResults.Results.Ok(), MessageKey = MessageKey.AutoMode };
                GUIMessageEventPublish(reply);
            }
            else
            {
                //2020.07.29. Kang. Vehicle Stop 시 LocalMode 변경.
                this.vehicle.MachineMode = eMachineMode.LocalMode;

                //2020.08.04. Kang Manual Mode 변경은 조그 사용 화면 DirveView 를 사용 시에만 전환.
                //if (!ZmqManager.SetOperationState(eOperatationMode.ManualMode))
                //{
                //    var al = this.Alarms.Where(x => x.AlarmId == 38).FirstOrDefault();
                //    reply = new GUIMessageEventArgs { Kind = GUIMessageEventArgs.eGUIMessageKind.RspVehicleModeChange, Result = FluentResults.Results.Fail(new Error(al.Text)), MessageKey = MessageKey.ManualMode };
                //    GUIMessageEventPublish(reply);
                //    return;
                //}

                //명령 삭제 위치 변경 AutoManager OperationState 변경시로 이동
                //this.sql.SubCmdDAL.Clean();
                //this.sql.CommandDAL.Clean();

                this.autoManager.AutoModeStateProperty = OHV.Common.Shareds.eAutoModeState.WaitStop;
                reply = new GUIMessageEventArgs { Kind = GUIMessageEventArgs.eGUIMessageKind.RspVehicleModeChange, Result = FluentResults.Results.Ok(), MessageKey = MessageKey.ManualMode };
                GUIMessageEventPublish(reply);
            }

        }

        void ReqIOObjectMessage()
        {
            var rspMsg = new GUIMessageEventArgs { Kind = GUIMessageEventArgs.eGUIMessageKind.RspIOObject, Args = this.IO };
            this.eventAggregator.GetEvent<GUIMessagePubSubEvent>().Publish(rspMsg);
        }

        void ReqDriveDistanceReset()
        {
            var info = sql.VehicleInfoDAL.GetAll().FirstOrDefault();
            info.TripDistance = 0d;
            info.TripResetTime = DateTime.Now;

            sql.VehicleInfoDAL.Update(info);
        }

        #endregion

        /// <summary>
        /// GUI 로 보내는 Event
        /// </summary>
        /// <param name="args"></param>
        public void GUIMessageEventPublish(GUIMessageEventArgs args)
        {
            this.eventAggregator.GetEvent<GUIMessagePubSubEvent>().Publish(args);
        }

        public void Dispose()
        {
            this.scheduler.Dispose();
            this.hostManager.Dispose();
            this.vehicle.Dispose();
            this.autoManager.Dispose();

            this.bMUManager.Disconnect();
            this.drive.Dispose();
            this.steering.Dispose();
            this.ZmqManager.Dispose();

            (this.IO as IDisposable).Dispose(); //IO 는 마지막에 정리함.
        }

        public void RegisterTypes(IContainerRegistry containerRegistry)
        {
            if (!containerRegistry.IsRegistered<VCSystem>())
                containerRegistry.RegisterSingleton<VCSystem>();
        }

        public void OnInitialized(IContainerProvider containerProvider)
        {
            this.Init();
        }
    }
}