using Entity.Constant;
using Entity.DbModel.Station;
using log4net;
using Newtonsoft.Json;
using Service.Cloud.Client;
using Service.Cloud.Msg.Cloud.Req;
using Service.Cloud.Msg.Cloud.Resp;
using Service.Cloud.Msg.Host.Req;
using Service.Cloud.Msg.Host.Req.OutCharger;
using Service.Execute.Model;
using Service.Execute.Model.Tbox;
using Service.Init;

namespace Service.Execute.Api;

public abstract class CloudApi
{
    private const int TimeSpan = 10;

    private static readonly ILog Log = LogManager.GetLogger("CloudApi");

    /// <summary>
    /// 云平台车辆认证
    /// </summary>
    /// <param name="rfidReadModel"></param>
    /// <returns></returns>
    public static CarAuthRes? VehicleCheck(RfidReadModel rfidReadModel, SwapOrder swapOrder)

    {
        CarAuth carAuth = new()
        {
            ty = 2,
            rfid = rfidReadModel.VelVin,
            cn = rfidReadModel.VelNo,
            vi = rfidReadModel.VelVin,
            //  mac = rfidReadModel.VelMac,
            en = 0,
            dt = swapOrder.VehicleEnterTime,
            mode = 0,
        };

        Log.Info(
            $" CloudApi VehicleCheck  SendVehicleCertification param={JsonConvert.SerializeObject(carAuth)}");
        CarAuthRes? sendVehicleCertification =
            CloudClientMgr.CloudClient?.SendVehicleCertification(carAuth,
                global::System.TimeSpan.FromSeconds(TimeSpan));

        Log.Info(
            $" CloudApi VehicleCheck  SendVehicleCertification resp={JsonConvert.SerializeObject(sendVehicleCertification)}");


        return sendVehicleCertification;
    }

    /// <summary>
    /// 上报换电订单
    /// </summary>
    /// <param name="rfidReadModel"></param>
    /// <param name="swapOrder"></param>
    /// <returns></returns>
    public static int UploadSwapOrder(SwapOrder swapOrder, int seq, SwapOrderBattery swapOrderBattery, int uploadType
    ,SwapOrderReportCloud orderReportCloud)

    {
        StaSwapRecord staSwapRecord = new()
        {
            rfid = swapOrder.VehicleVin,
            sn = StaticStationInfo.StationNo,
            son = swapOrder.CloudSn,
            cn = swapOrder.VehicleNo,
            so = seq,
            ct = swapOrder.VehicleEnterTime,
            st = swapOrder.SwapBeginTime,
            dbid = swapOrderBattery.UpBatteryNo,
            deno = swapOrderBattery.UpBatteryBinNo,
            dsoc = swapOrderBattery.UpBatterySoc.ToInt(),
            //dsoe = swapOrderBattery.UpBatterySoe.ToInt(),
            et = swapOrder.SwapEndTime,
            od = 0,
            ot = swapOrder.VehicleLeaveTime,
            rs = 0,
            sflx = 0,
            sfs = uploadType,
            ubid = swapOrderBattery.DownBatteryNo,
            ueno = swapOrderBattery.DownBatteryBinNo,
            usoc = swapOrderBattery.DownBatterySoc.ToInt(),
            //  usoe = swapOrderBattery.DownBatterySoe.ToInt(),
            vin = swapOrder.VehicleVin,
            wt = new TimeSpan((swapOrder.SwapEndTime.ToDateTime().Ticks - swapOrder.SwapBeginTime.ToDateTime().Ticks))
                .TotalSeconds.ToInt(),
            vtm=orderReportCloud.Vtm,
        };
        Log.Info(
            $" CloudApi UploadSwapOrder seq={seq} SendUploadPowerChangeOrder param={JsonConvert.SerializeObject(staSwapRecord)}");

        StaSwapRecordRes? sendUploadPowerChangeOrder = CloudClientMgr.CloudClient?.SendUploadPowerChangeOrder(
            staSwapRecord,
            global::System.TimeSpan.FromSeconds(TimeSpan));
        Log.Info(
            $" CloudApi UploadSwapOrder   seq={seq} SendUploadPowerChangeOrder resp={JsonConvert.SerializeObject(sendUploadPowerChangeOrder)}");

        if (sendUploadPowerChangeOrder == null)
        {
            return -1;
        }

        return sendUploadPowerChangeOrder.re;
    }


    public static InfoEnum.BusinessSwappingForCloudState BusinessSwappingForCloudState =
        InfoEnum.BusinessSwappingForCloudState.Idle;
    /// <summary>
    /// 上报换电步序到云端
    /// </summary>
    /// <param name="state"></param>
    /// <param name="daad">是否空闲</param>
    public static void SendStateLog( int state)
    {
        if (BusinessSwappingForCloudState!= StationSoftMgr.SwappingStateMachine.BusinessSwappingForCloudState)
        {
            StationChnRunStatus stationChnRunStatus = null;

            if (state == 1)
            {
                stationChnRunStatus = new()
                {
                    ec = 0,
                    ws = StationSoftMgr.SwappingStateMachine.SwapStatus == 0 ? 2 : 3,
                    cs = (int)StationSoftMgr.SwappingStateMachine.BusinessSwappingForCloudState,
                    iv = StationSoftMgr.SwappingStateMachine.RadarInFlag == true ? 1 : 2,
                    ls = StationSoftMgr.SwappingStateMachine.VelUnlockFlag == true ? 2 : 1,
                    fl = 0,
                    ut = DateTime.Now,

                };
            }
            else
            {

                stationChnRunStatus = new()
                {
                    ec = 0,
                    ws = 1,
                    cs = 1,
                    iv = 2,
                    ls = 0,
                    fl = 0,
                    ut = DateTime.Now,

                };
            }

             CloudClientMgr.CloudClient?.SendChannelStatusReporting(stationChnRunStatus,
               global::System.TimeSpan.FromSeconds(TimeSpan));

            for (int i = 0; i < 3; i++)
            {
               
            }

        }
        BusinessSwappingForCloudState = StationSoftMgr.SwappingStateMachine.BusinessSwappingForCloudState;
        return;
    }

    /// <summary>
    /// 上报车辆数据
    /// </summary>
    public static void UploadTBoxCarInfo(SwapOrder swapOrder, TboxCarInfoModel model)
    {
        return;
    }
    /// <summary>
    /// 换电车辆数据上报
    /// </summary>
    /// <param name="req"></param>
    public static void SendVehicleDataReporting(SwappingStateMachine machine,int vet)
    {
        var carInfoBatteryInfos = machine.BoxCarInfoModel?.CarInfo?.BatteryInfos;
        CardataReport cardataReport = new()
        {
            on = machine.SwapOrder.Sn,
            ct = DateTime.Now,
            cn = machine.SwapOrder.VehicleNo,
            rfid = "",
            Vi = machine.SwapOrder.VehicleVin,
            mc = "",
            bn = carInfoBatteryInfos.Count > 0 ? carInfoBatteryInfos[0].BatteryNo : "",
            ec = 0,
            soc = carInfoBatteryInfos.Count > 0 ? Convert.ToSingle(carInfoBatteryInfos[0].Soc) : 0,
            bskm = Convert.ToSingle(machine.BoxCarInfoModel?.ElecMsg?.SubMile),
            btkm = Convert.ToSingle(machine.BoxCarInfoModel?.ElecMsg?.TotalMile),
            soh = carInfoBatteryInfos.Count > 0 ? Convert.ToSingle(carInfoBatteryInfos[0].Soh) : 0,
            soe = carInfoBatteryInfos.Count > 0 ? Convert.ToSingle(carInfoBatteryInfos[0].Soe) : 0,
            vtm = Convert.ToSingle(machine.BoxCarInfoModel?.ElecMsg?.TotalMile),
            vet = vet,
            vtdc = Convert.ToInt32(machine.BoxCarInfoModel?.ElecMsg?.AccDischargeCount),
            vtfe = Convert.ToInt32(machine.BoxCarInfoModel?.ElecMsg?.AccFallbackCount),
            vtcc = Convert.ToInt32(machine.BoxCarInfoModel?.ElecMsg?.AccChargeCount),
            vtec = Convert.ToInt32(machine.BoxCarInfoModel?.ElecMsg?.AccKgce),
            rtdc = Convert.ToInt32(machine.BoxCarInfoModel?.ElecMsg?.ThisTimeRealDischarge),
            lsdc = Convert.ToInt32(machine.BoxCarInfoModel?.ElecMsg?.LastTimeBalanceDischarge),
            rtfc = Convert.ToInt32(machine.BoxCarInfoModel?.ElecMsg?.ThisTimeRealFeedbackPower),
            lsfc = Convert.ToInt32(machine.BoxCarInfoModel?.ElecMsg?.LastTimeBalanceFeedbackPower),
            rtcc = Convert.ToInt32(machine.BoxCarInfoModel?.ElecMsg?.ThisTimeRealChargeCount),
            lscc = Convert.ToInt32(machine.BoxCarInfoModel?.ElecMsg?.LastTimeBalanceChargeCount),
            rtec = Convert.ToInt32(machine.BoxCarInfoModel?.ElecMsg?.ThisTimeRealKgce),
            ltfc = Convert.ToInt32(machine.BoxCarInfoModel?.ElecMsg?.LastTimeBalanceKgce),
            wsec = Convert.ToInt32(machine.BoxCarInfoModel?.ElecMsg?.ElectricityToBeSettled),
        };
        CloudClientMgr.CloudClient?.SendVehicleDataReporting(cardataReport,
            global::System.TimeSpan.FromSeconds(TimeSpan));

    }
    /// <summary>
    /// 云平台下发换电指令
    /// </summary>
    /// <returns></returns>
    public static CarCanStart CarCanStart()
    {
        Log.Info(
            $" CloudApi CarCanStart  ");
        var cloudClientCarCanStart = CloudClientMgr.CloudClient.CarCanStart;
        Log.Info(
            $" CloudApi CarCanStart resp= {JsonConvert.SerializeObject(cloudClientCarCanStart)}");
        return cloudClientCarCanStart;
    }

    /// <summary>
    /// 清除下发的换电指令
    /// </summary>
    /// <returns></returns>
    public static bool ClearCarCanStartInfo()
    {
        CloudClientMgr.CloudClient.CarCanStart = null;
        return true;
    }

    /// <summary>
    /// 9.2.1.3 站控上报充电枪充电结束事件
    /// </summary>
    /// <param name="req"></param>
    public static void SendPileEndCharge(PileEndCharge req)
    {
        CloudClientMgr.CloudClient?.SendPileEndCharge(req,
            global::System.TimeSpan.FromSeconds(TimeSpan));
    }

    /// <summary>
    /// 9.2.1.7 站控上报充电枪充电遥测数据
    /// </summary>
    /// <param name="req"></param>
    public static void SendPileChargeRealtime(PileChargeRealtime req)
    {
        CloudClientMgr.CloudClient?.SendPileChargeRealtime(req,
            global::System.TimeSpan.FromSeconds(TimeSpan));
    }
    
    /// <summary>
    /// 9.2.1.5 站控上报充电枪实时数据上报
    /// </summary>
    /// <param name="req"></param>
    public static void SendPileRealtime(PileRealtime req)
    {
        CloudClientMgr.CloudClient?.SendPileRealtime(req,
            global::System.TimeSpan.FromSeconds(TimeSpan));
    }

    /// <summary>
    /// 换电站状态上报
    /// </summary>
    /// <param name="req"></param>
    public static void SendHostStatusReported(StationRunStatus req)
    {
        CloudClientMgr.CloudClient?.SendHostStatusReported(req,
            global::System.TimeSpan.FromSeconds(TimeSpan));
    }

    /// <summary>
    /// 空调信息
    /// </summary>
    /// <param name="req"></param>
    public static void SendAirConditioningData(AcDataInfo req)
    {

        CloudClientMgr.CloudClient?.SendAirConditioningData(req,
            global::System.TimeSpan.FromSeconds(TimeSpan));
    }
    /// <summary>
    /// 换电站温湿度数据信息
    /// </summary>
    /// <param name="req"></param>
    public static void SendEvmDataInfo(EvmDataInfo req)
    {

        CloudClientMgr.CloudClient?.SendEvmDataInfo(req,
            global::System.TimeSpan.FromSeconds(TimeSpan));
    }
    /// <summary>
    /// 电能表累计值信息
    /// </summary>
    /// <param name="req"></param>
    public static void SendPowerTotal(PowerTotal req)
    {

        CloudClientMgr.CloudClient?.SendPowerTotal(req,
            global::System.TimeSpan.FromSeconds(TimeSpan));
    }
    /// <summary>
    /// 换电站电能表变化值信息
    /// </summary>
    /// <param name="req"></param>
    public static void SendStaChargingTotal(StaChargingTotal req)
    {

        CloudClientMgr.CloudClient?.SendStaChargingTotal(req,
            global::System.TimeSpan.FromSeconds(TimeSpan));
    }
    /// <summary>
    /// 换电站分时用电统计信息
    /// </summary>
    /// <param name="req"></param>
    public static void SendStaHourEnergyVal(StaHourEnergyVal req)
    {
        CloudClientMgr.CloudClient?.SendStaHourEnergyVal(req,
            global::System.TimeSpan.FromSeconds(TimeSpan));
    }
    /// <summary>
    /// 电能表小时能耗值信息
    /// </summary>
    /// <param name="req"></param>
    public static void SendMeterEnergyKwh(MeterEnergyKwh req)
    {
        CloudClientMgr.CloudClient?.SendMeterEnergyKwh(req,
            global::System.TimeSpan.FromSeconds(TimeSpan));
    }
    /// <summary>
    /// 电能表每天能耗值信息
    /// </summary>
    /// <param name="req"></param>
    public static void SendMeterDayEnergyVal(MeterDayEnergyVal req)
    {
        CloudClientMgr.CloudClient?.SendMeterDayEnergyVal(req,
            global::System.TimeSpan.FromSeconds(TimeSpan));
    }
    /// <summary>
    /// 换电站每天用电统计信息
    /// </summary>
    /// <param name="req"></param>
    public static void SendStaDayEnergyVal(StaDayEnergyVal req)
    {
        CloudClientMgr.CloudClient?.SendStaDayEnergyVal(req,
            global::System.TimeSpan.FromSeconds(TimeSpan));
    }
    /// <summary>
    /// 换电站日运行统计结果信息
    /// </summary>
    /// <param name="req"></param>
    public static void SendStaDayOpeEnergyVal(StaDayOpeEnergyVal req)
    {
        CloudClientMgr.CloudClient?.SendStaDayOpeEnergyVal(req,
            global::System.TimeSpan.FromSeconds(TimeSpan));
    }
    /// <summary>
    /// 换电站分时用电计费信息
    /// </summary>
    /// <param name="req"></param>
    public static void SendStaHourAmountVal(StaHourAmountVal req)
    {
        CloudClientMgr.CloudClient?.SendStaHourAmountVal(req,
            global::System.TimeSpan.FromSeconds(TimeSpan));
    }

    /// <summary>
    /// 换电站进行签到认证
    /// </summary>
    /// <param name="req"></param>
    public static void SendSignIn(SignIn req)
    {
        SignIn signIn = new()
        {
            sn = StaticStationInfo.StationNo,
            ky = StaticStationInfo.StationSn,
            st = "02",
            dv = "",
            sv = StaticStationInfo.StationSftVer.ToString(),
            ss = StaticStationInfo.Sevstatus,
            ca = Convert.ToSingle(StaticStationInfo.DistributionCapacity),

            VS = "",
            cp = 0,
            bs="",
            lo="",
            la="",
            en=1,
            cn=1,
            eid=1,
            oid=1,


        };
        CloudClientMgr.CloudClient?.SendSignIn(req,
            global::System.TimeSpan.FromSeconds(TimeSpan));
    }

    public static void SendReportingDeviceList(DevList req)
    {
        DevList devList = new()
        {
            
        };
        CloudClientMgr.CloudClient?.SendReportingDeviceList(req,
            global::System.TimeSpan.FromSeconds(TimeSpan));
    }
}