using AutoMapper;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using WMS.Web.Core;
using WMS.Web.Core.Dto;
using WMS.Web.Core.Dto.Erp;
using WMS.Web.Core.Dto.Erp.Org;
using WMS.Web.Core.Dto.Erp.Supplier;
using WMS.Web.Core.Dto.SingleData;
using WMS.Web.Core.Internal.Results;
using WMS.Web.Domain.Infrastructure;
using WMS.Web.Domain.IService.Public;
using WMS.Web.Domain.Values;
using WMS.Web.Domain.Values.Single;

namespace WMS.Web.Api.Controllers
{
    /// <summary>
    /// 系统配置
    /// </summary>
    [Route("api/[controller]")]
    [ApiController]
    public class SysConfigController : ControllerBase
    {
        private readonly ILoginService _loginService;
        private readonly IBasicsRepositories _basicsRepositories;
        private readonly IBoxRepositories _boxRepositories;
        private readonly IErpService _erpService;
        private readonly ISingleDataService _singleDataService;
        private readonly ISerialNumbersRepositories _serialNumbersRepositories;
        private readonly IBoxInventoryRepositories _boxInventoryRepositories;
        private readonly IMapper _mapper;
        private readonly IErpBasicDataExtendService _erpBasicDataExtendService;
        private readonly IOutStockRepositories _outStockRepositories;
        private readonly IMoveBoxRecordRepositories _moveBoxRecordRepositories;
        private readonly ILogger<SysConfigController> _logger;

        public SysConfigController(ILoginService loginService, IBasicsRepositories basicsRepositories,
            IBoxRepositories boxRepositories, IErpService erpService, ISingleDataService singleDataService,
            ISerialNumbersRepositories serialNumbersRepositories, IBoxInventoryRepositories boxInventoryRepositories,
            IMapper mapper, IErpBasicDataExtendService erpBasicDataExtendService, IOutStockRepositories outStockRepositories,
            ILogger<SysConfigController> logger, IMoveBoxRecordRepositories moveBoxRecordRepositories)
        {
            _loginService = loginService;
            _basicsRepositories = basicsRepositories;
            _boxRepositories = boxRepositories;
            _erpService = erpService;
            _singleDataService = singleDataService;
            _serialNumbersRepositories = serialNumbersRepositories;
            _boxInventoryRepositories = boxInventoryRepositories;
            _mapper = mapper;
            _erpBasicDataExtendService = erpBasicDataExtendService;
            _outStockRepositories = outStockRepositories;
            _logger = logger;
            _moveBoxRecordRepositories = moveBoxRecordRepositories;
        }

        /// <summary>
        /// 获取系统类型所需要下拉列表
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("GetStatus")]
        public Task<Result<EnumStatusResponse>> GetStatus()
        {
            EnumStatusResponse response = new EnumStatusResponse();
            foreach (OutStockType enumv in Enum.GetValues(typeof(OutStockType)))
            {
                response.OutStockType.Add((int)enumv, enumv.GetRemark());
            }
            foreach (MoveBoxType enumv in Enum.GetValues(typeof(MoveBoxType)))
            {
                response.MoveBoxType.Add((int)enumv, enumv.GetRemark());
            }
            foreach (TakeStockType enumv in Enum.GetValues(typeof(TakeStockType)))
            {
                response.TakeStockType.Add((int)enumv, enumv.GetRemark());
            }
            foreach (InstockType enumv in Enum.GetValues(typeof(InstockType)))
            {
                response.InstockType.Add((int)enumv, enumv.GetRemark());
            }
            foreach (InstockStatus enumv in Enum.GetValues(typeof(InstockStatus)))
            {
                response.InstockStatus.Add((int)enumv, enumv.GetRemark());
            }
            foreach (BackRecordType enumv in Enum.GetValues(typeof(BackRecordType)))
            {
                response.BackRecordType.Add((int)enumv, enumv.GetRemark());
            }
            foreach (InventoryInOutType enumv in Enum.GetValues(typeof(InventoryInOutType)))
            {
                response.InventoryInOutType.Add((int)enumv, enumv.GetRemark());
            }
            foreach (OrderType enumv in Enum.GetValues(typeof(OrderType)))
            {
                response.OrderType.Add((int)enumv, enumv.GetRemark());
            }
            foreach (ShelfMethod enumv in Enum.GetValues(typeof(ShelfMethod)))
            {
                response.ShelfMethod.Add((int)enumv, enumv.GetRemark());
            }
            foreach (FileDownLoadOrderType enumv in Enum.GetValues(typeof(OrderType)))
            {
                response.FileDownLoadOrderType.Add((int)enumv, enumv.GetRemark());
            }
            foreach (ExportStatus enumv in Enum.GetValues(typeof(ExportStatus)))
            {
                response.ExportStatus.Add((int)enumv, enumv.GetRemark());
            }
            foreach (InventoryInOutMethod enumv in Enum.GetValues(typeof(InventoryInOutMethod)))
            {
                response.InventoryInOutMethod.Add((int)enumv, enumv.GetRemark());
            }
            foreach (OutStockStatus enumv in Enum.GetValues(typeof(OutStockStatus)))
            {
                response.OutStockStatus.Add((int)enumv, enumv.GetRemark());
            }
            foreach (SyncStatus enumv in Enum.GetValues(typeof(SyncStatus)))
            {
                if ((int)enumv == 0 || (int)enumv == 1 || (int)enumv == 4)
                    response.SyncStatus.Add((int)enumv, enumv.GetRemark());
            }

            //2
            //1
            return Task.FromResult(Result<EnumStatusResponse>.ReSuccess(response));
        }

        /// <summary>
        /// 获取仓库
        /// </summary>
        /// <param name="name">仓库模糊匹配 不必填</param>
        /// <returns></returns>
        [HttpGet]
        [Route("GetUcStock")]
        public async Task<ResultList<UcStockResponse>> GetUcStock([FromQuery] string name)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null || loginInfo.UserInfo == null)
                return ResultList<UcStockResponse>.ReFailure(ResultCodes.Token_Invalid_Error);
            var r = await _basicsRepositories.GetUcStockAsync(ManagementSystemCode.GLXT0004.ToString(), name, loginInfo.UserInfo.CompanyId);
            return ResultList<UcStockResponse>.ReSuccess(r);
        }

        /// <summary>
        /// 获取组织-erp基础数据
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("GetOrg/{name}")]
        public async Task<ResultList<PullDownStrResponse>> GetOrg([FromRoute] string name)
        {
            var orgs_result = await _erpService.BillQueryForOrg();
            List<PullDownStrResponse> pullList = new List<PullDownStrResponse>();
            foreach (var c in orgs_result.Data.Where(w => w.Name.Contains(name)))
            {
                pullList.Add(new PullDownStrResponse()
                {
                    Id = c.Id.ToString(),
                    Name = c.Name,
                    Code = c.Number
                });
            }
            return ResultList<PullDownStrResponse>.ReSuccess(pullList);
        }

        /// <summary>
        /// 获取供应商-erp基础数据
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("GetSupplier/{name}")]
        public async Task<ResultList<PullDownStrResponse>> GetSupplier([FromRoute] string name)
        {
            var supplier_result = await _erpService.BillQueryForSupplier();
            List<PullDownStrResponse> pullList = new List<PullDownStrResponse>();
            foreach (var c in supplier_result.Data.Where(w => w.Name.Contains(name)))
            {
                pullList.Add(new PullDownStrResponse()
                {
                    Id = c.Id.ToString(),
                    Name = c.Name,
                    Code = c.Number
                });
            }

            return ResultList<PullDownStrResponse>.ReSuccess(pullList);
        }

        /// <summary>
        /// 根据仓库获取仓位
        /// </summary>
        /// <param name="id">仓库id</param>
        /// <returns></returns>
        [HttpGet]
        [Route("GetSubUcStock/{id}")]
        public async Task<Result<List<UcStockResponse>>> GetSubUcStock([FromRoute] int id)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null || loginInfo.UserInfo == null)
                return Result<List<UcStockResponse>>.ReFailure(ResultCodes.Token_Invalid_Error);
            var r = await _basicsRepositories.GetSubUcStockAsync(id);
            return Result<List<UcStockResponse>>.ReSuccess(r);
        }
        /// <summary>
        /// 根据仓库获取金蝶子仓库
        /// </summary>
        /// <param name="number">仓库编码</param>
        /// <param name="name">模糊匹配</param>
        /// <returns></returns>
        [HttpGet]
        [Route("GetErp_SubUcStock/{number}/{orgCode}")]
        public async Task<Result<List<UcStockResponse>>> GetErp_SubUcStock([FromRoute] string number, [FromRoute] string orgCode, [FromQuery] string name)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null || loginInfo.UserInfo == null)
                return Result<List<UcStockResponse>>.ReFailure(ResultCodes.Token_Invalid_Error);

            List<UcStockResponse> list = new List<UcStockResponse>();
            if (!number.Substring(0, 2).Equals("HD") && !number.Substring(0, 2).Equals("GD"))
                return Result<List<UcStockResponse>>.ReSuccess(list);

            var subs = await _erpService.BillQueryForSubStock();
            var res = subs.Data.Where(w => w.OrgCode.Equals(orgCode) && w.StockCode.Equals(number));
            if (!string.IsNullOrEmpty(name))
                res = res.Where(w => w.Name.Contains(name));
            list = res.Select(s => new UcStockResponse()
            {
                Id = s.Id,
                Code = s.Code,
                Name = s.Name,
                Disable = false
            }).ToList();//.Skip(0).Take(10)

            return Result<List<UcStockResponse>>.ReSuccess(list);
        }

        /// <summary>
        /// 获取出库单客户下拉列表
        /// </summary>
        /// <param name="name">客户名</param>
        /// <returns></returns>
        [HttpGet]
        [Route("GetCustomers/{name}")]
        public async Task<Result<List<PullDownStrResponse>>> GetCustomers([FromRoute] string name)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null || loginInfo.UserInfo == null)
                return Result<List<PullDownStrResponse>>.ReFailure(ResultCodes.Token_Invalid_Error);
            var customers = await _erpService.BillQueryForCustomer();
            var orgs = await _erpService.BillQueryForOrg();
            List<PullDownStrResponse> pullList = new List<PullDownStrResponse>();
            foreach (var c in customers.Data.Where(w => w.Name.Contains(name)))
            {
                pullList.Add(new PullDownStrResponse()
                {
                    Id = "c_" + c.Id,
                    Name = c.Name,
                    Code = c.Number
                });
            }
            foreach (var o in orgs.Data.Where(w => w.Name.Contains(name)))
            {
                pullList.Add(new PullDownStrResponse()
                {
                    Id = "o_" + o.Id,
                    Name = o.Name,
                    Code = o.Number
                });
            }

            return Result<List<PullDownStrResponse>>.ReSuccess(pullList);
        }

        /// <summary>
        /// 获取仓位：模糊名称
        /// </summary>
        ///  <param name="name">仓位名称模糊匹配</param>
        /// <returns></returns>
        [HttpGet]
        [Route("GetSubUcStockByName/{name}")]
        public async Task<Result<List<UcSubStockResponse>>> GetSubUcStockByName([FromRoute] string name)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null || loginInfo.UserInfo == null)
                return Result<List<UcSubStockResponse>>.ReFailure(ResultCodes.Token_Invalid_Error);
            var r = await _basicsRepositories.GetSubUcStockAsync(ManagementSystemCode.GLXT0004.ToString(), name, loginInfo.UserInfo.CompanyId);
            return Result<List<UcSubStockResponse>>.ReSuccess(r);
        }
        /// <summary>
        /// 获取仓位：精确名字
        /// </summary>
        ///  <param name="name">精确名字</param>
        /// <returns></returns>
        [HttpGet]
        [Route("GetSubUcStockPrecisionByName/{name}")]
        public async Task<Result<UcSubStockResponse>> GetSubUcStockPrecisionByName([FromRoute] string name)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null || loginInfo.UserInfo == null)
                return Result<UcSubStockResponse>.ReFailure(ResultCodes.Token_Invalid_Error);
            var r = await _basicsRepositories.GetSubUcStockAsync(ManagementSystemCode.GLXT0004.ToString(), name, loginInfo.UserInfo.CompanyId);
            var subStock = r.FirstOrDefault(f => f.Name.Equals(name));
            if (subStock == null) return Result<UcSubStockResponse>.ReFailure(ResultCodes.NoDateError);
            return Result<UcSubStockResponse>.ReSuccess(subStock);
        }

        /// <summary>
        /// 根据箱号获取箱信息
        /// </summary>
        /// <param name="boxBillNos">必填</param>
        /// <returns></returns>
        [HttpGet]
        [Route("GetBox")]
        public async Task<ResultList<BoxResponse>> GetBox([FromQuery] List<string> boxBillNos)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null || loginInfo.UserInfo == null)
                return ResultList<BoxResponse>.ReFailure(ResultCodes.Token_Invalid_Error);

            boxBillNos = boxBillNos.ConvertAll(d => d.ToLower());
            var res = await _boxRepositories.GetBox(boxBillNos);
            var bStrList = res.Select(s => s.BoxBillNo.ToLower()).ToList();
            var ex = boxBillNos.Except(bStrList).ToList();
            if (ex.Count() > 0)
                return ResultList<BoxResponse>.ReFailure("箱号" + JsonConvert.SerializeObject(ex) + "不存在", 800000);

            return ResultList<BoxResponse>.ReSuccess(res);
        }

        /// <summary>
        /// 根据箱号获取箱信息(综合)
        /// </summary>
        /// <param name="boxBillNo">必填</param>
        /// <param name="isReminder">没有箱时是否提示 false 返回数据 true或者不传 弹出提示</param>
        /// <returns></returns>
        [HttpGet]
        [Route("GetBoxSynthesis")]
        public async Task<Result<BoxResponse>> GetBoxSynthesis([FromQuery] string boxBillNo, [FromQuery] bool? isReminder = true)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null || loginInfo.UserInfo == null)
                return Result<BoxResponse>.ReFailure(ResultCodes.Token_Invalid_Error);

            var result = await _boxInventoryRepositories.GetInfoBy(boxBillNo);
            BoxResponse boxResponse = _mapper.Map<BoxResponse>(result);
            if (boxResponse != null)
            {
                var materials_result = await _erpService.BillQueryForMaterial();
                var materials = materials_result.Data.ToList();

                foreach (var detail in boxResponse.Details)
                {
                    detail.MaterialName = _erpBasicDataExtendService.GetMaterialName(materials, detail.MaterialId);
                    detail.MaterialNumber = _erpBasicDataExtendService.GetMaterialNumber(materials, detail.MaterialId);
                    detail.Specifications = _erpBasicDataExtendService.GetMaterialSpecifications(materials, detail.MaterialId);
                }
                boxResponse.BoxBillNo = boxBillNo;
                boxResponse.Details = boxResponse.Details.Where(w => w.Qty > 0).ToList();
                boxResponse.TotalQty = boxResponse.Details.Sum(s => s.Qty);
                return Result<BoxResponse>.ReSuccess(boxResponse);
            }

            var res = await _boxRepositories.GetBox(new List<string>() { boxBillNo });
            if (res.Count() <= 0 && isReminder == false) return Result<BoxResponse>.ReSuccess(new BoxResponse());
            if (res.Count() <= 0) return Result<BoxResponse>.ReFailure(ResultCodes.BoxNoData);
            return Result<BoxResponse>.ReSuccess(res.First());
        }


        /// <summary>
        /// 根据箱号获取箱对应出库单信息 最新一条
        /// </summary>
        /// <param name="boxBillNo">必填</param>
        /// <returns></returns>
        [HttpGet]
        [Route("GetBox_OutStock")]
        public async Task<Result<BoxResponse>> GetBox_OutStock([FromQuery] string boxBillNo)
        {
            var res = await _boxRepositories.GetBox(new List<string>() { boxBillNo });
            if (res.Count() <= 0)
                return Result<BoxResponse>.ReFailure("箱号" + boxBillNo + "不存在", 800000);
            var response = res[0];
            var detail = await _outStockRepositories.GetDetailsByBoxId(response.Id);
            if (detail.Count() == 0)
                return Result<BoxResponse>.ReFailure("箱号" + boxBillNo + "未出库", 800000);
            response.Details = detail;
            response.TotalQty = detail.Sum(s => s.Qty);
            return Result<BoxResponse>.ReSuccess(response);
        }

        /// <summary>
        /// 根据箱号获取箱对应移箱单信息 最新一条
        /// </summary>
        /// <param name="boxBillNo">必填</param>
        /// <returns></returns>
        [HttpGet]
        [Route("GetBox_MoveBoxRecord")]
        public async Task<Result<BoxResponse>> GetBox_MoveBoxRecord([FromQuery] string boxBillNo)
        {
            var res = await _boxRepositories.GetBox(new List<string>() { boxBillNo });
            if (res.Count() <= 0)
                return Result<BoxResponse>.ReFailure("箱号" + boxBillNo + "不存在", 800000);
            var response = res[0];
            var detail = await _moveBoxRecordRepositories.GetDetailsByBoxId(response.Id);
            if (detail.Count() == 0)
                return Result<BoxResponse>.ReFailure("箱号" + boxBillNo + "未移箱下架", 800000);
            response.Details = detail;
            response.TotalQty = detail.Sum(s => s.Qty);
            return Result<BoxResponse>.ReSuccess(response);
        }

        /// <summary>
        /// 根据序列号或规格型号,物料编码搜索物料信息-PDA
        /// </summary>
        /// <param name="serialNumber">序列号或规格型号或无聊编码</param>
        /// <returns></returns>
        [HttpGet]
        [Route("GetMaterial")]
        public async Task<Result<MaterialResponse>> GetMaterial([FromQuery] string serialNumber)
        {
            var loginInfo = _loginService.GetLoginInfo(this.HttpContext.Request.Headers["Authorization"]);
            if (loginInfo == null || loginInfo.UserInfo == null)
                return Result<MaterialResponse>.ReFailure(ResultCodes.Token_Invalid_Error);

            _logger.LogInformation($"请求序列号信息:{serialNumber}");
            var res = await _serialNumbersRepositories.GetSerialNumber(serialNumber);
            if (res == null) return Result<MaterialResponse>.ReFailure(ResultCodes.MateriaNoData);

            return Result<MaterialResponse>.ReSuccess(res);
        }
    }
}