using Autofac;
using Entity.Attr;
using Entity.Constant;
using HybirdFrameworkCore.Autofac;
using log4net;
using Repository.Station;
using Service.Execute.Api;
using Service.Execute.Model;
using Service.Execute.Model.Tbox;
using Service.Execute.StaticTools;
using Service.Execute.SwapException;
using Service.Execute.Utils;
using Service.Init;
using Service.Plc.Client;
using Service.Station;

namespace Service.Execute.Step;

public class DoSwappingState : IState
{
    private readonly ILog _log = LogManager.GetLogger(typeof(DoSwappingState));
    private readonly CommonMgr _CommonMgr = AppInfo.Container.Resolve<CommonMgr>();

    public StateResult Handle(SwappingStateMachine machine)
    {
        //上报云平台换电开始
        machine.BusinessSwappingForCloudState = InfoEnum.BusinessSwappingForCloudState.BeginSwap;
        machine.BusinessSwappingStateUpdateTime = DateTime.Now;
        _log.Info($"BusinessSwappingForCloudState={machine.BusinessSwappingForCloudState}");
        //   CloudApi.SendStateLog(machine.SwapOrder, InfoEnum.BusinessSwappingForCloudState.BeginSwap);


        InvokeStatus holdOn = HoldOn(machine);
        if (holdOn != InvokeStatus.Done)
        {
            return SwappingStateMachine.ReturnWithInvokeErr(holdOn, ExceptionReason.None);
        }


        //旧电池拆卸
        InvokeStatus unPack = UnPack(machine);
        if (unPack != InvokeStatus.Done)
        {
            return SwappingStateMachine.ReturnWithInvokeErr(unPack, ExceptionReason.None);
        }

        //旧电池搬运
        InvokeStatus oldBatteryCarryIn = OldBatteryCarryIn(machine);
        if (oldBatteryCarryIn != InvokeStatus.Done)
        {
            return SwappingStateMachine.ReturnWithInvokeErr(oldBatteryCarryIn, ExceptionReason.None);
        }

        //新电池搬运
        InvokeStatus newBatteryCarryOut = NewBatteryCarryOut(machine);
        if (newBatteryCarryOut != InvokeStatus.Done)
        {
            return SwappingStateMachine.ReturnWithInvokeErr(newBatteryCarryOut, ExceptionReason.None);
        }

        //安装
        InvokeStatus pack = Pack(machine);
        if (pack != InvokeStatus.Done)
        {
            return SwappingStateMachine.ReturnWithInvokeErr(pack, ExceptionReason.None);
        }

        //安装完成
        InvokeStatus packFinish = PackFinish(machine);
        if (packFinish != InvokeStatus.Done)
        {
            return SwappingStateMachine.ReturnWithInvokeErr(packFinish, ExceptionReason.None);
        }


        //航车回归安全位置
        InvokeStatus toInvokeStatus = ToSafePosition(machine);
        if (toInvokeStatus != InvokeStatus.Done)
        {
            return SwappingStateMachine.ReturnWithInvokeErr(toInvokeStatus, ExceptionReason.None);
        }
        //查询换电任务是否结束


        return new StateResult()
        {
            SwappingState = SwappingState.SwapDone
        };
    }

    /// <summary>
    /// 下发plc启动换电
    /// </summary>
    /// <returns></returns>
    public InvokeStatus StartSwapping(SwappingStateMachine machine)
    {
        return Invoker.Invoke("StartSwapping", 1000, 5, machine.IsCanceled,
            () => machine.StartSwappingFlag, () =>
            {
                Task<bool> result = TBoxApi.UnLockCarManyTimes(machine.RfidReadModel.VelVin);
                bool unLock = result.Result;
                if (unLock)
                {
                    //查询当前是否有任务执行

                    var readTaskNo = PlcMgr.PlcClient?.ReadTaskNo();
                    if (readTaskNo == 0 || readTaskNo == 1)
                    {
                        PlcMgr.PlcClient?.ExChangeTaskNo(1);
                        //查询车辆锁止状态
                        var startSwapping = PlcApi.StartSwapping(machine.SwapOrderBatteryInfo.InBinInfo.No,
                            machine.SwapOrderBatteryInfo.UpBinInfo.No);

                        //查詢當前任務狀態是否被更改
                        var readPlcTaskStatus = PlcApi.ReadTaskStatus(1);
                        if (startSwapping && readPlcTaskStatus)
                        {
                            machine.SwapOrder.SwapBeginTime = DateTime.Now;
                            _CommonMgr.UpdateSwapOrder(machine);
                            machine.SwapStatus = 0;
                            machine.StartSwappingFlag = true;
                            _CommonMgr.InsertStep(InfoEnum.BusinessSwappingStep.StartSwappingFlag,
                                machine);
                        }
                    }
                    else
                    {
                        _log.Info("当前有任务在执行");
                    }
                }
            }, () => { SoundApi.PlayOneSound((int)InfoEnum.SwapInfo.ErrStartSwap); }, false, () => { }, 10,
            InvokeStatus.None);
    }


    /// <summary>
    /// plc读任务状态 上使能
    /// </summary>
    /// <param name="machine"></param>
    /// <returns></returns>
    public InvokeStatus HoldOn(SwappingStateMachine machine)
    {
        return Invoker.Invoke("plc HoldOn", 1000, 5, machine.IsCanceled,
            () => machine.PlcHoldFlag, () =>
            {
                //查询换电任务状态

                bool holdOn = PlcApi.HoldOn(1);
                if (holdOn)
                {
                    _CommonMgr.InsertStep(InfoEnum.BusinessSwappingStep.StartSwappingFlag,
                        machine);
                    SoundApi.PlayOneSound((int)InfoEnum.SwapInfo.StartSwapInfo);
                    machine.PlcHoldFlag = true;
                }
            }, () => { });
    }


    /// <summary>
    /// 读取plc任务状态电池拆卸中
    /// 读取plc任务状态电池入库搬运中
    ///   读取plc任务状态电池出库搬运中
    /// 读取plc任务状态电池安装中
    ///  读取plc任务状态电池安装完成
    /// </summary>
    /// <returns></returns>
    public InvokeStatus UnPack(SwappingStateMachine machine)
    {
        return Invoker.Invoke("plc UnPack", 500, 5, machine.IsCanceled,
            () => machine.UnOldBatteryFlag, () =>
            {
                //   machine.LedTool?.WriteProgramContent(InfoEnum.SwapInfo.InfoUnPack.GetLed());


                int status = PlcApi.ReadSwapStatus();
                //处理程序太快，plc还没有初始值的状态
                if (status == 1002 || status != 1003)
                {
                }
                else
                {
                    machine.UnOldBatteryFlag = true;
                }

                if (machine.UnOldBatteryFlag)
                {
                    _CommonMgr.InsertStep(InfoEnum.BusinessSwappingStep.UnOldBatteryFlag,
                        machine);
                }
            }, () => { SoundApi.PlayOneSound((int)InfoEnum.SwapInfo.InfoUnPack); }, false, () => { }, 10,
            InvokeStatus.None);
    }

    public InvokeStatus OldBatteryCarryIn(SwappingStateMachine machine)
    {
        return Invoker.Invoke("plc OldBatteryCarryIn", 500, 5, machine.IsCanceled,
            () => machine.StorageOldBatteryFlag, () =>
            {
                //  machine.LedTool?.WriteProgramContent(InfoEnum.SwapInfo.InfoOldBatteryCarryIn.GetLed());
                var readPlcTaskStatus = PlcApi.ReadSwapStatus();

                if (readPlcTaskStatus == 1003 || readPlcTaskStatus != 1004)
                {
                }
                else
                {
                    machine.StorageOldBatteryFlag = true;
                }

                machine.StorageOldBatteryFlag = readPlcTaskStatus == 1004;

                if (machine.StorageOldBatteryFlag)
                {
                    _CommonMgr.InsertStep(InfoEnum.BusinessSwappingStep.StorageOldBatteryFlag,
                        machine);
                }
            }, () => { SoundApi.PlayOneSound((int)InfoEnum.SwapInfo.InfoOldBatteryCarryIn); }, false, () => { }, 10,
            InvokeStatus.None);
    }

    public InvokeStatus NewBatteryCarryOut(SwappingStateMachine machine)
    {
        return Invoker.Invoke("plc NewBatteryCarryOut", 500, 5, machine.IsCanceled,
            () => machine.OutNewBatteryFlag, () =>
            {
                // machine.LedTool?.WriteProgramContent(InfoEnum.SwapInfo.InfoNewBatteryCarryOut.GetLed());

                if (PlcApi.ReadSwapStatus() == 1004)
                {
                }
                else
                {
                    machine.OutNewBatteryFlag = true;
                }

                if (machine.OutNewBatteryFlag)
                {
                    _CommonMgr.InsertStep(InfoEnum.BusinessSwappingStep.OutNewBatteryFlag,
                        machine);
                }
            }, () => { SoundApi.PlayOneSound((int)InfoEnum.SwapInfo.InfoNewBatteryCarryOut); }, false, () => { },
            10,
            InvokeStatus.None);
    }


    public InvokeStatus Pack(SwappingStateMachine machine)
    {
        return Invoker.Invoke("plc Pack ing", 500, 5, machine.IsCanceled,
            () => machine.InstallNewBatteryFlag, () =>
            {
                // machine.LedTool?.WriteProgramContent(InfoEnum.SwapInfo.InfoPack.GetLed());
                if (PlcApi.ReadSwapStatus() == 1005)
                {
                }
                else
                {
                    machine.InstallNewBatteryFlag = true;
                }

                if (machine.InstallNewBatteryFlag)
                {
                    _CommonMgr.InsertStep(InfoEnum.BusinessSwappingStep.InstallNewBatteryFlag,
                        machine);
                }
            }, () => { SoundApi.PlayOneSound((int)InfoEnum.SwapInfo.InfoPack); }, false, () => { },
            10, InvokeStatus.None);
    }

    public InvokeStatus PackFinish(SwappingStateMachine machine)
    {
        return Invoker.Invoke("plc Pack Finish", 500, 5, machine.IsCanceled,
            () => machine.FinishNewBatteryFlag, () =>
            {
                //  machine.LedTool?.WriteProgramContent(InfoEnum.SwapInfo.InfoPackFinish.GetLed());
                var readPlcTaskStatus = PlcApi.ReadSwapStatus();
                if (readPlcTaskStatus == 1006 || readPlcTaskStatus == 1007)
                {
                    machine.FinishNewBatteryFlag = true;
                    machine.BusinessSwappingForCloudState =
                        InfoEnum.BusinessSwappingForCloudState.SwapFinish;
                    //  CloudApi.SendStateLog(machine.SwapOrder, machine.BusinessSwappingForCloudState);
                    machine.BusinessSwappingStateUpdateTime = DateTime.Now;
                    SoundApi.PlayOneSound((int)InfoEnum.SwapInfo.InfoPackFinish);

                    _CommonMgr.InsertStep(InfoEnum.BusinessSwappingStep.FinishNewBatteryFlag,
                        machine);
                }
            }, () => { }, false, () => { },
            10, InvokeStatus.None);
    }

    /// <summary>
    /// 行车回归安全位置
    /// </summary>
    /// <param name="machine"></param>
    /// <returns></returns>
    public InvokeStatus ToSafePosition(SwappingStateMachine machine)
    {
        return Invoker.Invoke("plc ToSavePosition", 500, 5, machine.IsCanceled,
            () => machine.ToSafePositionFlag, () =>
            {
                //  machine.LedTool?.WriteProgramContent(InfoEnum.SwapInfo.InfoPackFinish.GetLed());

                if (PlcApi.ReadSwapStatus() == 1007)
                {
                    SoundApi.PlayOneSound((int)InfoEnum.SwapInfo.InfoToSafePosition);
                    machine.ToSafePositionFlag = true;
                    machine.BusinessSwappingStateUpdateTime = DateTime.Now;

                    machine.SwapStatus = 1;
                }
            }, () => { });
    }


    /// <summary>
    /// 车辆到位
    /// </summary>
    /// <returns></returns>
    public InvokeStatus CarInPosition2(SwappingStateMachine machine)
    {
        return Invoker.Invoke("check CarInPosition2", 500, 50, machine.IsCanceled,
            () => machine.VehiclesInPlace2Flag, () =>
            {
                var result = TBoxApi.GetCarInfo(machine.RfidReadModel.VelVin);
                TboxCarInfoModel tboxCarInfoModel = result.Result;

                int succCount = 0;
                List<bool> succL = new List<bool>()
                {
                    StaticStationInfo.TboxStateFlameout, StaticStationInfo.TboxStateBreak,
                    StaticStationInfo.TboxStateN
                };
                var successCount = succL.Where(i => i).Count();

                var status = tboxCarInfoModel?.CarStatus;

                if (StaticStationInfo.TboxStateFlameout)
                {
                    if (status?.Keys == 0)
                    {
                        succCount++;
                    }
                }

                if (StaticStationInfo.TboxStateBreak)
                {
                    if (status?.Break == 1)
                    {
                        succCount++;
                    }
                }

                if (StaticStationInfo.TboxStateN)
                {
                    if (status?.Gear == 0)
                    {
                        succCount++;
                    }
                }

                if (succCount == successCount)
                {
                    machine.VehiclesInPlace2Flag = true;
                }
            }, () =>
            {
                machine.ExceptionReason = ExceptionReason.CarInPositionError;
                //   machine.LedTool?.WriteProgramContent(InfoEnum.SwapInfo.ErrorCarInPositionTimeout.GetLed());
                SoundApi.PlayOneSound((int)InfoEnum.SwapInfo.ErrorCarInPositionTimeout);
            }, false, () => { }
            , 20, InvokeStatus.None);
    }
}