using System.Text.Json;
using Microsoft.AspNetCore.Mvc;
using SlnMesnac.Config;
using SlnMesnac.Model.domain;
using SlnMesnac.Model.dto;
using SlnMesnac.Plc;
using SlnMesnac.Repository.service;

namespace SlnMesnac.Controllers;

/// <summary>
/// MCS 投料校验
/// </summary>
[Route("api/[controller]")]
[ApiController]
public class McsIngCheckController
{
    private ILogger<McsIngCheckController> _logger;
    private AppConfig _appConfig;
    private PlcPool _plcPool;
    private IWmsTaskOutService _wmsTaskOutService;
    private IMcsBinToMaterService _mcsBinToMaterService;
    private IMcsMaterialInfoService _mcsMaterialInfoService;
    private IInputRecordService _inputRecordService;


    /// <summary>
    /// 
    /// </summary>
    /// <param name="logger"></param>
    /// <param name="mcsBinToMaterService"></param>
    /// <param name="appConfig"></param>
    /// <param name="wmsTaskOutService"></param>
    /// <param name="plcPool"></param>
    /// <param name="mcsMaterialInfoService"></param>
    public McsIngCheckController(ILogger<McsIngCheckController> logger,
        IMcsBinToMaterService mcsBinToMaterService,
        AppConfig appConfig,
        IWmsTaskOutService wmsTaskOutService,
        PlcPool plcPool,
        IMcsMaterialInfoService mcsMaterialInfoService,
        IInputRecordService inputRecordService)
    {
        _logger = logger;
        _mcsBinToMaterService = mcsBinToMaterService;
        _appConfig = appConfig;
        _wmsTaskOutService = wmsTaskOutService;
        _plcPool = plcPool;
        _mcsMaterialInfoService = mcsMaterialInfoService;
        _inputRecordService = inputRecordService;
    }

    
    /// <summary>
    /// 根据物料条码获取MCS物料信息
    /// </summary>
    /// <param name="MaterialBarcode"></param>
    /// <returns></returns>
    [HttpGet("GetMcsMaterialInfo/{MaterialBarcode}")]
    public ApiResponse GetMcsMaterialInfo(string MaterialBarcode)
    {
        var result = new ApiResponse();
        try
        {
            do
            {
                WmsTaskOut wmsInfo = this.GetWmsTaskOutBySerialNum(MaterialBarcode);
                if (wmsInfo == null)
                {
                    result.SetFailure($"物料信息获取失败，根据物料条码获取MCS物料编号为空，时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
                    break;
                }
                var info = _mcsMaterialInfoService.GetMcsMaterialInfoByMatCode(wmsInfo.MaterNo);
                if(info == null)
                {
                    result.SetFailure($"物料信息获取失败，根据物料编号获取MCS物料信息为空，时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
                }
                else
                {
                    string matStr = JsonSerializer.Serialize(info);
                    result.SetSuccess(matStr);
                    _logger.LogInformation($"获取物料信息成功：{matStr}，时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
                }
            } while (false);
        }
        catch(Exception e)
        {
            result.SetException(e, "MCS物料信息获取异常");
            _logger.LogError($"MCS物料信息获取异常:{e.Message}");
        }
        return result;
    }

    /// <summary>
    /// 上辅机投料校验
    /// </summary>
    /// <param name="ingredientInfo"></param>
    /// <returns></returns>
    [HttpPost("BigMaterial")]
    public ApiResponse McsMaterialCheck(IngredientInfo? ingredientInfo)
    {
        var result = new ApiResponse();
        try
        {
            do
            {
                if (ingredientInfo == null)
                {
                    result.SetSuccess($"上辅机校验失败，缺少必要参数，时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
                    break;
                }
                
                _logger.LogInformation($"上辅机验证参数：{JsonSerializer.Serialize(ingredientInfo)}");
                
                McsBinToMater mcsInfo = _mcsBinToMaterService.GetMcsBinToMaterByBinNo(ingredientInfo.EquipId, ingredientInfo.CanNumber);
                if (mcsInfo == null)
                {
                    result.SetFailure($"上辅机校验失败，根据料罐获取对应信息为空，时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
                    break;
                }

                WmsTaskOut wmsInfo = this.GetWmsTaskOutBySerialNum(ingredientInfo.MaterialBarcode);
                if (wmsInfo == null)
                {
                    result.SetFailure($"上辅机校验失败，根据物料条码获取物料信息为空，时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
                    break;
                }
                    
                if (mcsInfo.MatCode.Contains(wmsInfo.MaterNo))
                {
                    result.SetSuccess($"上辅机校验成功，时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
                }
                else
                {
                    result.SetFailure($"上辅机校验失败，物料不匹配，时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
                    break;
                }
                
                if (ingredientInfo.IsOpen == 1)
                {
                    
                    var openFlag = SendMcsOpenInstruct(mcsInfo.BinNo);
                    if (openFlag)
                    {
                        _logger.LogInformation($"上辅机开仓指令下发成功");
                        result.SetSuccess($"上辅机校验成功，开仓指令下发成功，时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
                    }
                    else
                    {
                        _logger.LogInformation("上辅机开仓指令下发失败");
                        result.SetSuccess($"上辅机校验成功，开仓指令下发失败，时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
                        break;
                    }
                }
                        
                //保存数据
                ingredientInfo.EquipId = mcsInfo.EquipId;
                ingredientInfo.CanNumber = mcsInfo.BinNo.ToString();
                SaveInputRecord(ingredientInfo, 1, "");
            } while (false);
            
        }
        catch (Exception e)
        {
            result.SetException(e,"上辅机投料校验异常");
            _logger.LogError($"上辅机投料校验异常:{e.Message}");
        }

        return result;
    }
    
    /// <summary>
    /// 获取Mcs投料记录
    /// </summary>
    /// <param name="apiRequestParam"></param>
    /// <returns></returns>
    [HttpPost("GetMcsInputRecord")]
    public ApiResponse GetMcsInputRecord(ApiRequestParam? apiRequestParam)
    {
        var result = new ApiResponse();
        try
        {
            do
            {
                var inputRecordList = _inputRecordService.GetMcsInputRecordList();

                if (inputRecordList != null)
                {
                    if (!string.IsNullOrEmpty(apiRequestParam.MaterialBarcode))
                        inputRecordList = inputRecordList.Where(x => x.MaterialBarcode == apiRequestParam.MaterialBarcode)
                            .ToList();
                    if (!string.IsNullOrEmpty(apiRequestParam.CanNumber))
                        inputRecordList = inputRecordList.Where(x => x.CanNumber == apiRequestParam.CanNumber).ToList();
                    if (!string.IsNullOrEmpty(apiRequestParam.beginTime))
                        inputRecordList = inputRecordList.Where(x => x.RecordTime >= Convert.ToDateTime(apiRequestParam.beginTime)).ToList();
                    if (!string.IsNullOrEmpty(apiRequestParam.endTime))
                        inputRecordList = inputRecordList.Where(x => x.RecordTime <= Convert.ToDateTime(apiRequestParam.endTime)).ToList();
                }
                
                string matStr = JsonSerializer.Serialize(inputRecordList);
                result.SetSuccess(matStr);
                _logger.LogInformation($"获取Mcs投料记录成功：{matStr}，时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
                
            } while (false);
        }
        catch(Exception e)
        {
            result.SetException(e, "获取Cwss投料记录异常");
            _logger.LogError($"获取Cwss投料记录异常:{e.Message}");
        }
        return result;
    }
    
    /// <summary>
    /// 下发MCS开仓指令
    /// </summary>
    /// <param name="binNo"></param>
    /// <returns></returns>
    /// <exception cref="ArgumentException"></exception>
    private bool SendMcsOpenInstruct(int binNo)
    {
        bool result = false;
        var plcInfo = _plcPool.GetPlcByKey("mcs");
        string[] binStatusArray = _appConfig.mcsBinStatusAddr.Split(",");
        List<int> binStatusResult = new List<int>();
        foreach (var item in binStatusArray)
        {
            bool res = plcInfo.readBoolByAddress(item);
            if (res)
            {
                binStatusResult.Add(1);
            }
            else
            {
                binStatusResult.Add(0);
            }
        }

        var allOtherNumbersList = binStatusResult.Where((num, index) => index != binNo - 1).ToList();
        bool allOtherNumbersAreZero = allOtherNumbersList.Contains(0);
        if (allOtherNumbersAreZero)
        {
            throw new ArgumentException($"开仓指令下发异常，存在门锁未关到位的料仓，时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
        }
            
        result = plcInfo.writeValueByAddress(binNo, _appConfig.mcsOpenAddr);

        if (!result)
        {
            throw new ArgumentException($"开仓指令下发失败，时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
        }

        return result;
    }
    
    /// <summary>
    /// 根据物料条码获取WMS出库记录反馈信息
    /// </summary>
    /// <param name="MaterialBarcode"></param>
    /// <returns></returns>
    private WmsTaskOut GetWmsTaskOutBySerialNum(string MaterialBarcode)
    {
        WmsTaskOut? result = null;
        try
        {
            result = _wmsTaskOutService.GetWmsTaskOutBySerialNum(MaterialBarcode);
            _logger.LogInformation($"根据物料条码：{MaterialBarcode};获取WMS出库记录：{JsonSerializer.Serialize(result)}，时间：{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");
        }
        catch (Exception ex)
        {
            _logger.LogError($"根据物料条码：{MaterialBarcode};获取WMS出库记录异常：{ex.Message}");
        }
        return result;
    }
    
    /// <summary>
    /// 保存投料记录
    /// </summary>
    private void SaveInputRecord(IngredientInfo info,int isFlag,string remark)
    {
        try
        {
            McsInputRecord mcsInputRecord = new McsInputRecord()
            {
                MaterialBarcode = info.MaterialBarcode,
                CanNumber = info.CanNumber,
                EquipId = info.EquipId,
                InputQuantity = info.InputQuantity,
                InputWeight = info.InputWeight,
                IsRemainder = info.IsRemainder,
                RemainderQuantity = info.RemainderQuantity,
                RemainderWeight = info.RemainderWeight,
                IsOpen = info.IsOpen,
                IsFlag = isFlag,
                Remark = remark,
                RecordTime = DateTime.Now
            };

            bool result = _inputRecordService.SaveMcsInputRecord(mcsInputRecord);

            if (result)
            {
                _logger.LogInformation($"投料记录:{JsonSerializer.Serialize(mcsInputRecord)}保存成功");
            }
            else
            {
                _logger.LogInformation($"投料记录:{JsonSerializer.Serialize(mcsInputRecord)}保存失败");
            }
        }
        catch (Exception ex)
        {
            _logger.LogError($"投料记录保存异常:{ex.Message}");
        }
    }
}