// Admin.NET 项目的版权、商标、专利和其他相关权利均受相应法律法规的保护。使用本项目应遵守相关法律法规和许可证的要求。
//
// 本项目主要遵循 MIT 许可证和 Apache 许可证（版本 2.0）进行分发和使用。许可证位于源代码树根目录中的 LICENSE-MIT 和 LICENSE-APACHE 文件。
//
// 不得利用本项目从事危害国家安全、扰乱社会秩序、侵犯他人合法权益等法律法规禁止的活动！任何基于本项目二次开发而产生的一切法律纠纷和责任，我们不承担任何责任！

using Admin.NET.Core.Service;
using AngleSharp.Dom;
using DocumentFormat.OpenXml.Vml.Office;
using Elastic.Clients.Elasticsearch.Tasks;
using IoTClient;
using Microsoft.AspNetCore.Http;
using WCS.Application.Entity;
namespace WCS.Application;

/// <summary>
/// 分拣任务表服务
/// </summary>
[ApiDescriptionSettings(ApplicationConst.GroupName, Order = 100)]
public class WcsCheckTaskService : IDynamicApiController, ITransient
{
    private readonly SqlSugarRepository<WcsCheckTask> _wcsCheckTaskRep;
    private readonly SqlSugarRepository<WcsDevice> _wcsDeviceRep;
    private readonly SqlSugarRepository<WcsOderTask> _wcsOderTaskRep;
    private readonly SqlSugarRepository<WcsMateialPzInfo> _wcsMateialPzInfoRep;

    public WcsCheckTaskService(SqlSugarRepository<WcsCheckTask> wcsCheckTaskRep, SqlSugarRepository<WcsDevice> wcsDeviceRep, SqlSugarRepository<WcsOderTask> wcsOderTaskRep, SqlSugarRepository<WcsMateialPzInfo> wcsMateialPzInfoRep)
    {
        _wcsCheckTaskRep = wcsCheckTaskRep;
        _wcsDeviceRep = wcsDeviceRep;
        _wcsOderTaskRep = wcsOderTaskRep;
        _wcsMateialPzInfoRep = wcsMateialPzInfoRep;
    }

    /// <summary>
    /// 分页查询分拣任务表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Page")]
    [DisplayName("分页查询分拣任务表")]
    public async Task<SqlSugarPagedList<WcsCheckTaskOutput>> Page(PageWcsCheckTaskInput input)
    {
		input.SearchKey = input.SearchKey?.Trim();
        var query = _wcsCheckTaskRep.AsQueryable()
            .WhereIF(!string.IsNullOrEmpty(input.SearchKey), u =>
                u.OrderNo.Contains(input.SearchKey)
                || u.RoboatNo.Contains(input.SearchKey)
                || u.LineNo.Contains(input.SearchKey)
                || u.Port.Contains(input.SearchKey)
                || u.LotNo.Contains(input.SearchKey)
                || u.SkuNo.Contains(input.SearchKey)
                || u.SkuName.Contains(input.SearchKey)
                || u.BoxType.Contains(input.SearchKey)
                || u.Status.Contains(input.SearchKey)
                || u.PZNo.Contains(input.SearchKey)
                || u.PalletNo.Contains(input.SearchKey)
            )
            .WhereIF(!string.IsNullOrWhiteSpace(input.OrderNo), u => u.OrderNo.Contains(input.OrderNo.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.RoboatNo), u => u.RoboatNo.Contains(input.RoboatNo.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.LineNo), u => u.LineNo.Contains(input.LineNo.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.Port), u => u.Port.Contains(input.Port.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.LotNo), u => u.LotNo.Contains(input.LotNo.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SkuNo), u => u.SkuNo.Contains(input.SkuNo.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.SkuName), u => u.SkuName.Contains(input.SkuName.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.BoxType), u => u.BoxType.Contains(input.BoxType.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.Status), u => u.Status.Contains(input.Status.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.PZNo), u => u.PZNo.Contains(input.PZNo.Trim()))
            .WhereIF(!string.IsNullOrWhiteSpace(input.PalletNo), u => u.PalletNo.Contains(input.PalletNo.Trim()))
            .WhereIF(input.BoxInsert>0, u => u.BoxInsert == input.BoxInsert)
            .WhereIF(input.BoxCount>0, u => u.BoxCount == input.BoxCount)
            .WhereIF(input.Qty>0, u => u.Qty == input.Qty)
            .WhereIF(input.FinishQty>0, u => u.FinishQty == input.FinishQty)
            .WhereIF(input.BindTimeRange != null && input.BindTimeRange.Length == 2, u => u.BindTime >= input.BindTimeRange[0] && u.BindTime <= input.BindTimeRange[1])
            .WhereIF(input.BindUserId>0, u => u.BindUserId == input.BindUserId)
            .Select<WcsCheckTaskOutput>();
		return await query.OrderBuilder(input).ToPagedListAsync(input.Page, input.PageSize);
    }

    /// <summary>
    /// 增加分拣任务表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Add")]
    [DisplayName("增加分拣任务表")]
    public async Task<long> Add(AddWcsCheckTaskInput input)
    {
        var entity = input.Adapt<WcsCheckTask>();
        await _wcsCheckTaskRep.InsertAsync(entity);
        return entity.Id;
    }

    /// <summary>
    /// 删除分拣任务表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Delete")]
    [DisplayName("删除分拣任务表")]
    public async Task Delete(DeleteWcsCheckTaskInput input)
    {
        var entity = await _wcsCheckTaskRep.GetFirstAsync(u => u.Id == input.Id) ?? throw Oops.Oh(ErrorCodeEnum.D1002);
        await _wcsCheckTaskRep.FakeDeleteAsync(entity);   //假删除
        //await _wcsCheckTaskRep.DeleteAsync(entity);   //真删除
    }

    /// <summary>
    /// 更新分拣任务表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "Update")]
    [DisplayName("更新分拣任务表")]
    public async Task Update(UpdateWcsCheckTaskInput input)
    {
        var entity = input.Adapt<WcsCheckTask>();
        await _wcsCheckTaskRep.AsUpdateable(entity).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
    }

    /// <summary>
    /// 获取分拣任务表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "Detail")]
    [DisplayName("获取分拣任务表")]
    public async Task<WcsCheckTask> Detail([FromQuery] QueryByIdWcsCheckTaskInput input)
    {
        return await _wcsCheckTaskRep.GetFirstAsync(u => u.Id == input.Id);
    }

    /// <summary>
    /// 获取分拣任务表列表
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpGet]
    [ApiDescriptionSettings(Name = "List")]
    [DisplayName("获取分拣任务表列表")]
    public async Task<List<WcsCheckTaskOutput>> List([FromQuery] PageWcsCheckTaskInput input)
    {
        return await _wcsCheckTaskRep.AsQueryable().Select<WcsCheckTaskOutput>().ToListAsync();
    }

    /// <summary>
    /// 手动绑定任务
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "BindTaskForPLC")]
    [DisplayName("手动绑定任务")]
    public async Task BindTaskForPLC(BindTaskPLCInput input)
    {
        var deviceInfo = await _wcsDeviceRep.GetByIdAsync(input.deviceId);
        if (deviceInfo == null)
        {
            throw Oops.Oh("设备工位信息不存在");
        }
        //任务信息
        var taskInfo = await _wcsOderTaskRep.GetByIdAsync(input.oderTaskId);
        if (taskInfo == null)
        {
            throw Oops.Oh("任务信息不存在");
        }
        if (taskInfo.Status != TaskStatusEnum.Wait)
        {
            throw Oops.Oh("任务状态异常");
        }
        taskInfo.Status = TaskStatusEnum.Doing;//正在执行

        //物料品种信息
        var skuInfo = await _wcsMateialPzInfoRep.Context.Queryable<WcsMateialPzInfo>().Where(w => w.SkuNo == taskInfo.SkuNo).FirstAsync();
        if (skuInfo == null)
        {
            throw Oops.Oh("物料品种信息不存在");
        }
        //码垛绑定信息
        var checkTaskInfo = await _wcsCheckTaskRep.Context.Queryable<WcsCheckTask>().Where(w => w.Port == deviceInfo.StationNum).FirstAsync();
        if (checkTaskInfo == null)
        {
            throw Oops.Oh("分拣任务信息不存在");
        }
        if (checkTaskInfo.Status != "0")
        {
            throw Oops.Oh("该工位已绑定任务，请勿再次绑定");
        }
        checkTaskInfo.OrderNo = taskInfo.OrderNo;
        checkTaskInfo.LotNo = taskInfo.LotNo;
        checkTaskInfo.SkuNo = taskInfo.SkuNo;
        checkTaskInfo.SkuName = taskInfo.SkuName;
        checkTaskInfo.BoxType = taskInfo.BoxType;
        checkTaskInfo.Qty = taskInfo.Qty;
        checkTaskInfo.Status = "1";//已绑定
        checkTaskInfo.PZNo = skuInfo.PZNo;

        #region#给PLC写入抓箱品种号、批次号、通道状态
        var modPlc = await _wcsDeviceRep.Context.Queryable<WcsPlc>().FirstAsync(s => s.Id == deviceInfo.PlcId);
        if (modPlc == null)
        {
            throw Oops.Bah("找不到PLC信息");
        }
        PLCUtil modUtil = new PLCUtil(modPlc);
        if (modUtil.Connected)
        {
            var listResult = new List<Result>();
            listResult.Add(modUtil.SetPlcDBValueRepeat(checkTaskInfo.PosType, checkTaskInfo.DbNumber, checkTaskInfo.PlcPos, checkTaskInfo.PZNo));//品种号
            listResult.Add(modUtil.SetPlcDBValueRepeat(checkTaskInfo.PosTypeLot, checkTaskInfo.DbNumber, checkTaskInfo.PosLot, checkTaskInfo.LotNo));//批次号
            listResult.Add(modUtil.SetPlcDBValueRepeat(checkTaskInfo.PosTypeStatus, checkTaskInfo.DbNumber, checkTaskInfo.PosStatus, "1"));//绑定状态 0：未绑定 1：已绑定
            if (listResult.All(s => s.IsSucceed))
            {
                //写入流程字成功后更新码垛绑定信息
                await _wcsCheckTaskRep.AsUpdateable(checkTaskInfo).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();

                //写入流程字成功后更新任务状态
                await _wcsOderTaskRep.AsUpdateable(taskInfo).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
            }
            else
            {
                throw Oops.Bah("与PCL交互失败，绑定失败！");
            }
        }
        else
        {
            throw Oops.Bah("PCL未连接，绑定失败！");
        }
        #endregion
    }

    /// <summary>
    /// 任务结批
    /// </summary>
    /// <param name="input"></param>
    /// <returns></returns>
    [HttpPost]
    [ApiDescriptionSettings(Name = "CloseTaskForPLC")]
    [DisplayName("任务结批")]
    public async Task CloseTaskForPLC(CloseTaskPLCInput input)
    {
        //绑定信息
        var checkTaskList = _wcsCheckTaskRep.Context.Queryable<WcsCheckTask>().Where(w => w.LotNo == input.lotNo && w.Status == "1").ToList();
        if (checkTaskList.Count <= 0)
        {
            throw Oops.Bah("找不到该批次分拣任务信息");
        }
        //任务信息
        var taskInfo = _wcsOderTaskRep.Context.Queryable<WcsOderTask>().First(w => w.OrderNo == checkTaskList[0].OrderNo);
        if (taskInfo != null)
        {
            taskInfo.Status = TaskStatusEnum.Complete;//已结束
            //更新任务状态
            await _wcsOderTaskRep.AsUpdateable(taskInfo).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
        }
        foreach (var item in checkTaskList)
        {
            #region#给PLC写入结批批次号
            var deviceInfo = await _wcsDeviceRep.Context.Queryable<WcsDevice>().FirstAsync(w => w.StationNum == item.Port && w.DeviceType== DeviceTypeEnum.Show);
            if (deviceInfo == null)
            {
                throw Oops.Bah($"找不到工位号：{item.Port} 的码垛工位信息");
            }
            var modPlc = await _wcsDeviceRep.Context.Queryable<WcsPlc>().FirstAsync(s => s.Id == deviceInfo.PlcId);
            if (modPlc == null)
            {
                throw Oops.Bah($"找不到PLC信息");
            }
            PLCUtil modUtil = new PLCUtil(modPlc);
            if (modUtil.Connected)
            {
                var listResult = new List<Result>();
                listResult.Add(modUtil.SetPlcDBValueRepeat(item.PosType, item.DbNumber, item.PlcPos, "0"));//品种号
                listResult.Add(modUtil.SetPlcDBValueRepeat(item.PosTypeLot, item.DbNumber, item.PosLot, ""));//批次号
                listResult.Add(modUtil.SetPlcDBValueRepeat(item.PosTypeStatus, item.DbNumber, item.PosStatus, "0"));//绑定状态 0：未绑定 1：已绑定

                if (listResult.All(s => s.IsSucceed))
                {
                    //写入流程字成功后更新分拣任务
                    item.OrderNo = "";
                    item.TaskNo = "";
                    item.LotNo = "";
                    item.SkuNo = "";
                    item.SkuName = "";
                    item.BoxType = "";
                    item.Qty = 0;
                    item.BoxCount = 0;
                    item.PZNo = "";
                    //item.PalletNo = "";
                    item.Status = "0";//未绑定 

                    //更新分拣任务
                    await _wcsCheckTaskRep.AsUpdateable(item).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
                }
                else
                {
                    throw Oops.Bah("与PCL交互失败，结批失败！");
                }
            }
            else
            {
                throw Oops.Bah("PCL未连接，结批失败！");
            }


            //Service.WcsDevice.Dto.WcsDeviceTaskOrderDto order=  await _wcsDeviceRep.Context.Queryable<WcsDevice>()
            //    .InnerJoin<WcsPlc>((device, plc) => device.PlcId == plc.Id)
            //    .LeftJoin<WcsCheckTask>((device, plc, task) => device.StationNum == task.Port)
            //    .Where((device, plc, task) => device.PlcId == 1000 && task.Port=="")
            //    .Select((device, plc, task) => new Service.WcsDevice.Dto.WcsDeviceTaskOrderDto()
            //    {
            //        Id = device.Id,
            //        Text = device.Text,
            //        TaskNo = task.TaskNo,
            //        OrderNo = task.OrderNo,
            //        LotNo = task.LotNo,
            //        SkuNo = task.SkuNo,
            //        SkuName = task.SkuName,
            //        LineNo = task.LineNo,
            //        Status = task.Status,
            //        PZNo = task.PZNo,
            //        Qty = task.Qty,

            //        Type = plc.Type
            //    })
            //    .FirstAsync();
            ////下发分拣任务
            //HubUtil.PublicCheckTask(order.Adapt<Service.WcsDevice.Dto.WcsDeviceTaskOrderDto>());

            #endregion
        }  
    }
}