using JiepeiWMS.Common.Enums;
using JiepeiWMS.Filter;
using JiepeiWMS.IServices;
using JiepeiWMS.Model;
using JiepeiWMS.Model.Models;
using JiepeiWMS.Model.ViewModels;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Threading.Tasks;

namespace JiepeiWMS.Api.Controllers
{
    [Route("api/[controller]/[action]")]
    [ApiController]
    [Authorize(Permissions.Name)]
    public class WMOrderMainController : ControllerBase
    {
        /// <summary>
        /// 订单信息
        /// </summary>
        private readonly IWMOrderMainServices _wMOrderMainServices;
        private readonly IWMOrderInfoServices _wMOrderInfoServices;

        public WMOrderMainController(IWMOrderMainServices WMOrderMainServices,
            IWMOrderInfoServices WMOrderInfoServices)
        {
            _wMOrderMainServices = WMOrderMainServices;
            _wMOrderInfoServices = WMOrderInfoServices;
        }

        /// <summary>
        /// 查询列表
        /// </summary>
        /// <param name="page">页数</param>
        /// <param name="key">关键字</param>
        /// <param name="intPageSize">条数</param>
        /// <returns></returns>
        [HttpGet]
        public async Task<MessageModel<PageModel<WMOrderMain>>> Index(int page = 1, string key = "", int intPageSize = 50)
        {
            if (string.IsNullOrWhiteSpace(key))
                key = "";

            var PageList = await _wMOrderMainServices.GetWMOrderMainPage(page, intPageSize, key);

            return new MessageModel<PageModel<WMOrderMain>>()
            {
                msg = "获取成功",
                success = PageList.dataCount >= 0,
                response = PageList
            };
        }

        /// <summary>
        /// 获取列表
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [AllowAnonymous]
        public async Task<MessageModel<WMOrderMain>> Get(int id = 0)
        {
            return new MessageModel<WMOrderMain>()
            {
                msg = "获取成功",
                success = true,
                response = await _wMOrderMainServices.QueryById(id)
            };
        }

        /// <summary>
        /// 订单详情
        /// </summary>
        /// <param name="Id"></param>
        /// <returns></returns>
        [HttpGet]
        public async Task<MessageModel<WMOrderMain>> Detail(int Id = 0)
        {
            var model = await _wMOrderMainServices.QueryById(Id);
            if (model != null)
            {
                //var dicType = typeof(EnumWMInInventoryType)._GetValueDescriptionDicFromEnumType<EnumWMInInventoryType>();
                //string name;
                //model.OutInTypeName = dicType.TryGetValue((EnumWMInInventoryType)model.OutInType, out name) ? name : string.Empty;

                model.OrderInfoList = await _wMOrderInfoServices.Query(w => w.OrderNo == model.OrderNo);
                foreach (var item in model.OrderInfoList)
                {

                }
            }

            return new MessageModel<WMOrderMain>()
            {
                msg = "获取成功",
                success = true,
                response = model
            };
        }

        /// <summary>
        /// 获取订单信息
        /// </summary>
        /// <returns></returns>
        [HttpGet, AllowAnonymous, AuthKeySecret]
        public async Task<MessageModel<string>> CreateOrderMainInfo(WMOrderMainViewModels model)
        {
            var msg = string.Empty;
            var data = new MessageModel<string>();

            try
            {
                //验证非空
                var mainParam = await _wMOrderMainServices.ValidateReconParams(model.OrderMainModel);
                if (!string.IsNullOrWhiteSpace(mainParam))
                {
                    msg = mainParam;
                    goto ErrorResult;
                }

                var orderMainModel = await _wMOrderMainServices.GetModel(x => x.GroupNo == model.OrderMainModel.GroupNo);
                if (orderMainModel == null)
                {
                    //新增订单信息数据
                    if (model.OrderMainModel.DataType <= EnumOrderMainDataType.贴片板子内部发货.GetHashCode() || model.OrderMainModel.DataType == EnumOrderMainDataType.元器件供应商发货.GetHashCode())
                    {
                        if (model.OrderMainModel.OrderNo.StartsWith("H"))
                        {
                            model.OrderMainModel.ProType = 1;
                        }
                        else if (model.OrderMainModel.OrderNo.StartsWith("A_"))
                        {
                            model.OrderMainModel.ProType = 3;
                        }
                        else if (model.OrderMainModel.OrderNo.StartsWith("S_H"))
                        {
                            model.OrderMainModel.ProType = 2;
                        }
                        else if (model.OrderMainModel.OrderNo.StartsWith("IC_"))
                        {
                            model.OrderMainModel.ProType = 4;
                        }
                        await _wMOrderMainServices.Add(model.OrderMainModel);
                    }
                }
                else
                {
                    //更新订单信息数据
                    await _wMOrderMainServices.Update(model.OrderMainModel);
                }

                //循环子订单信息数据
                foreach (var item in model.OrderInfoList)
                {
                    //验证非空
                    var infoParam = await _wMOrderInfoServices.ValidateReconParams(item);
                    if (!string.IsNullOrWhiteSpace(infoParam))
                    {
                        msg = infoParam;
                        goto ErrorResult;
                    }

                    var orderInfoModel = await _wMOrderInfoServices.GetModel(x => x.OrderNo == item.OrderNo);
                    if (orderInfoModel == null)
                    {
                        //新增子订单信息数据
                        await _wMOrderInfoServices.Add(item);
                    }
                    else
                    {
                        //更新子订单信息数据
                        await _wMOrderInfoServices.Update(item);
                    }
                }

                data.msg = "获取订单信息成功";
                data.success = true;
                data.response = 1.ObjToString();
                return data;

            ErrorResult:
                data.msg = msg;
                data.success = false;
                return data;
            }
            catch (Exception ex)
            {
                data.msg = ex.Message;
                data.status = 500;
                return data;
            }
        }
    }
}