using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;
using HH.WMS.BLL;
using HH.WMS.BLL.Basic;
using HH.WMS.Common;
using HH.WMS.Entitys;
using HH.WMS.WebApi.Areas.Common.Controllers;
using HH.WMS.Entitys.Sys;
using HH.WMS.Entitys.Common;
using HH.WMS.Entitys.Basic;
using HH.WMS.Entitys.Algorithm;
using Newtonsoft.Json;

namespace HH.WMS.WebApi.Areas.Basic
{
    public class CommonController : BaseController
    {
        #region 获取定义的编码
        /// <summary>
        /// 获取定义的编码
        /// </summary>
        /// <param name="ruleName">编号名</param>
        /// <returns></returns>
        public OperateResult GenBillNo(string ruleName)
        {
            return ValidateToken(x =>
            {
                return this.GetCode(x, ruleName);
            });
        }
        #endregion

        #region 物料列表-分页
        /// <summary>
        /// 物料列表-分页
        /// </summary>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        [HttpPost]
        public OperateResult ItemList(SearchModel searchModel)
        {
            return ValidateToken(searchModel.TokenId, x =>
            {
                try
                {
                    int total;
                    var list = BLLCreator.Create<TN_WMS_ITEMBLL>().GetItemList(searchModel, out total);
                    return OperateResult.Succeed(null, new
                    {
                        rows = list,
                        total = total
                    });
                }
                catch (Exception ex)
                {
                    return OperateResult.Error(ex.Message);
                }
            });
        }


        /// <summary>
        /// 物料列表-分页
        /// </summary>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetListItemByCode(string itemCode, string itemName, string model, int pageIndex, int pageSize)
        {
            try
            {

                OperateResult result = new OperateResult();
                int total;
                List<AutoBomItemEntity> list = BLLCreator.Create<TN_WMS_ITEMBLL>().GetListItemByCode(itemCode, itemName, model, pageIndex, pageSize, out total);
                //foreach (AutoBomItemEntity entity in list)
                //{
                //   entity.CN_S_MODEL = entity.CN_S_MODEL.Replace("\"", "'");
                //}
                result = OperateResult.Succeed(null, new
                        {
                            rows = list,
                            total = total
                        });
                return result;

            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 客户列表-分页
        /// <summary>
        /// 客户列表-分页
        /// </summary>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        [HttpPost]
        public OperateResult CustomList(SearchModel searchModel)
        {
            try
            {
                return ValidateToken(searchModel.TokenId, x =>
                    {
                        int total;
                        var list = BLLCreator.Create<TN_AB_CUSTOMERBLL>().GetCustomList(searchModel, out total);
                        return OperateResult.Succeed(null, new
                        {
                            rows = list,
                            total = total
                        });
                    });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 仓库列表
        [HttpGet]
        public OperateResult NoTokenStockList()
        {
            try
            {
                if (SysCache.Stock == null || SysCache.Stock.Count == 0)
                    SysCache.Stock = BLLCreator.Create<TN_WMS_STOCKBLL>().GetStockList();
                return OperateResult.Succeed(null, SysCache.Stock);
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        /// <summary>
        /// 仓库列表
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public OperateResult StockList()
        {
            try
            {
                return ValidateToken(x =>
                  {
                      //if (SysCache.Stock == null || SysCache.Stock.Count == 0)
                      SysCache.Stock = BLLCreator.Create<TN_WMS_STOCKBLL>().GetStockList();
                      return OperateResult.Succeed(null, SysCache.Stock);
                  });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 库区列表
        /// <summary>
        /// 库区列表
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetAreaList(int pageIndex, int pageSize, string areaName)
        {
            try
            {
                return ValidateToken(x =>
                  {
                      int total;
                      List<AutoBomStockAreaEntity> result = BLLCreator.Create<TN_WMS_STOCKBLL>().GetAreaList(pageIndex, pageSize, areaName, out total);

                      List<AutoBomStockAreaEntity> newList = new List<AutoBomStockAreaEntity>();
                      foreach (var entity in result)
                      {
                          if (SysCache.Stock == null || SysCache.Stock.Count == 0)
                              SysCache.Stock = BLLCreator.Create<TN_WMS_STOCKBLL>().GetStockList();

                          entity.CN_S_STOCK_NAME = SysCache.Stock.Find(p => p.CN_S_STOCK_CODE == entity.CN_S_STOCK_CODE).CN_S_STOCK_NAME;
                          newList.Add(entity);
                      }

                      return OperateResult.Succeed(null, new
                      {
                          rows = newList,
                          total = total
                      });
                  });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }

        #region (PDA)获取库区信息
        /// <summary>
        /// 根据库区类型获取库区信息
        /// </summary>
        /// <param name="areaType">库区类型</param>
        /// <returns></returns>
        /// <History>[Hanhe(XDL)] created  2019/03/20</History>
        [HttpGet]
        public string GetStockArea(string areaType)
        {
            try
            {
                return ValidateToken(x =>
                {
                    List<AutoBomStockAreaEntity> areaModel = BLLCreator.Create<TN_AB_B_STOCK_AREABLL>().GetListByStockArea(areaType);
                    return JsonConvert.SerializeObject(OperateResult.Succeed("", areaModel));
                });
            }
            catch (Exception ex)
            {
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message));
            }
        }

        /// <summary>
        /// 根据作业区类型获取库区列表
        /// </summary>
        /// <param name="areaClass">作业区类型</param>
        /// <returns></returns>
        [HttpGet]
        public string GetAreaByAreaClass(string areaClass)
        {
            try
            {
                return ValidateToken(x =>
                {
                    if (string.IsNullOrEmpty(areaClass))
                    {
                        return JsonConvert.SerializeObject(OperateResult.Error("请提供作业区类型！"));
                    }
                    List<AutoBomStockAreaEntity> areaModel = BLLCreator.Create<TN_AB_B_STOCK_AREABLL>().GetAreaByAreaClass(areaClass);
                    return JsonConvert.SerializeObject(OperateResult.Succeed("", areaModel));
                });
            }
            catch (Exception ex)
            {
                return JsonConvert.SerializeObject(OperateResult.Error(ex.Message));
            }
        }
        #endregion


        /// <summary>
        /// 库区和仓库列表
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetStockAndAreaList(int pageIndex, int pageSize, string areaName)
        {
            try
            {
                return ValidateToken(x =>
                  {
                      int total;
                      List<AutoBomStockAreaEntity> result = BLLCreator.Create<TN_WMS_STOCKBLL>().GetAreaList(pageIndex, pageSize, areaName, out total);

                      List<AutoBomStockAreaEntity> newList = new List<AutoBomStockAreaEntity>();
                      List<TN_AB_STOCKEntity> stockList = new List<TN_AB_STOCKEntity>();

                      if (SysCache.Stock == null || SysCache.Stock.Count == 0)
                          SysCache.Stock = BLLCreator.Create<TN_WMS_STOCKBLL>().GetStockList();
                      stockList = SysCache.Stock;

                      foreach (var entity in stockList)
                      {
                          newList.Add(new AutoBomStockAreaEntity()
                          {
                              CN_S_AREA_CODE = "",
                              CN_S_AREA_NAME = "",
                              CN_S_STOCK_CODE = entity.CN_S_STOCK_CODE,
                              CN_S_STOCK_NAME = entity.CN_S_STOCK_NAME
                          });
                      }
                      foreach (var entity in result)
                      {
                          if (SysCache.Stock.Find(p => p.CN_S_STOCK_CODE == entity.CN_S_STOCK_CODE) != null)
                          {
                              entity.CN_S_STOCK_NAME = SysCache.Stock.Find(p => p.CN_S_STOCK_CODE == entity.CN_S_STOCK_CODE).CN_S_STOCK_NAME;
                          }

                          newList.Add(entity);
                      }

                      return OperateResult.Succeed(null, new
                      {
                          rows = newList,
                          total = total + stockList.Count
                      });
                  });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }

        #region 库区列表
        /// <summary>
        /// 库区列表
        /// </summary>
        /// <param name="include">包含库区类型 1:库区  2：作业区   3：逻辑分区  4：1+2 </param>
        /// <param name="stockCode">仓库号</param>
        /// <returns></returns>
        /// <History>[Hanhe(DBS)] created by 2018/12/04</History>
        public OperateResult GetArea(string stockCode, int include)
        {
            return ValidateToken(x =>
            {
                List<AutoBomStockAreaEntity> areaList = BLLCreator.Create<TN_AB_B_STOCK_AREABLL>().GetArea(include, stockCode);
                return OperateResult.Succeed("", areaList);
            });
        }
        #endregion

        /// <summary>
        /// 根据库区类型返回库区列表
        /// </summary>
        /// <param name="areaType">库区类型(1:库区，2：逻辑分区，4：作业区)</param>
        /// <param name="tokenId">tokenId</param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetAreaListByType(string areaType)
        {
            try
            {
                return ValidateToken(x =>
                {
                    List<AutoBomStockAreaEntity> areaList = BLLCreator.Create<TN_AB_B_STOCK_AREABLL>().GetAreaListByType(areaType);
                    return OperateResult.Succeed(null, areaList);
                });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 获取系统全部策略
        /// <summary>
        /// 获取系统全部策略
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public OperateResult SysStrategyList()
        {
            try
            {
                return ValidateToken(x =>
                   {
                       if (SysCache.SysStrategy == null || SysCache.SysStrategy.Count == 0)
                           SysCache.SysStrategy = BLLCreator.Create<DapperBLL<TN_WM_B_STRATEGY_VALUEEntity>>().GetList();
                       return OperateResult.Succeed(null, SysCache.SysStrategy);
                   });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 获取系统单个策略
        /// <summary>
        /// 获取系统单个策略
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetSysStrategy(string stockCode, string key)
        {
            try
            {
                return ValidateToken(m =>
                     {
                         TN_WM_B_STRATEGY_VALUEEntity model = SysCache.SysStrategy.Find(x => x.CN_S_STOCK_CODE.Equals(stockCode) && x.CN_S_CODE.Equals(key));
                         if (model == null)
                         {
                             model = BLLCreator.Create<DapperBLL<TN_WM_B_STRATEGY_VALUEEntity>>().GetSingleEntity(new
                             {
                                 CN_S_STOCK_CODE = stockCode,
                                 CN_S_CODE = key
                             });
                             if (model == null)
                             {
                                 return OperateResult.Error("不存在该策略！");
                             }
                             else
                             {
                                 SysCache.SysStrategy.Add(model);
                             }
                         }
                         return OperateResult.Succeed("", model);
                     });
            }
            catch (Exception ex)
            {
                return OperateResult.Error(ex.Message);
            }
        }
        #endregion

        #region 模糊匹配10条先
        /// <summary>
        /// 模糊匹配10条先
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetMatchItem(string key)
        {
            return ValidateToken(x =>
            {
                try
                {
                    var list = BLLCreator.Create<TN_WMS_ITEMBLL>().GetMatchItem(key);
                    return OperateResult.Succeed(null, list);
                }
                catch (Exception ex)
                {
                    return OperateResult.Error(ex.Message);
                }
            });
        }
        #endregion

        #region 获取物流公司
        /// <summary>
        /// 获取物流公司
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetLogisticsCompany()
        {
            return ValidateToken(x =>
            {
                try
                {
                    var list = BLLCreator.Create<DapperBLL<TN_WM_LOGISTICS_COMPANYEntity>>().GetList();
                    return OperateResult.Succeed(null, list);
                }
                catch (Exception ex)
                {
                    return OperateResult.Error(ex.Message);
                }
            });
        }
        #endregion

        #region 获取打印机
        /// <summary>
        /// 获取打印机
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetPrintTemplet(string stockCode, string templetType, string printer, string logistics)
        {
            return ValidateToken(t =>
            {
                List<TN_WM_PRINT_TEMPLETEntity> list = new List<TN_WM_PRINT_TEMPLETEntity>();
                //if (!templetType.Equals("物流单") || string.IsNullOrEmpty(logistics))
                //{
                list = BLLCreator.Create<DapperBLL<TN_WM_PRINT_TEMPLETEntity>>().GetList(new
                {
                    CN_S_STOCK_CODE = stockCode,
                    CN_S_TEMPLET_TYPE = templetType,
                    CN_S_PRINTER = printer
                });
                //}
                //else
                //{
                if (!string.IsNullOrEmpty(logistics))
                {
                    var s = BLLCreator.Create<DapperBLL<TN_WM_LOGISTICS_TEMPLET_RELEntity>>().GetList(new
                    {
                        CN_S_LOGISTICS_FLAG = logistics
                    });
                    list = list.FindAll(x => s.Select(y => y.CN_S_TEMPLET_NAME).Contains(x.CN_S_TEMPLET_NAME));
                }
                //}
                if (string.IsNullOrEmpty(printer))
                {
                    list = list.Where(m => !string.IsNullOrEmpty(m.CN_S_PRINTER))
                        .GroupBy(x => x.CN_S_PRINTER)
                        .Select(y => new TN_WM_PRINT_TEMPLETEntity
                    {
                        CN_S_PRINTER = y.Key
                    }).ToList();
                }
                return OperateResult.Succeed(null, list);
            });
        }
        #endregion

        #region 获取打印模板
        /// <summary>
        /// 获取打印模板
        /// </summary>
        /// <param name="stockCode">仓库号</param>
        /// <param name="templetType">模板类型</param>
        /// <returns></returns>
        /// <History>[Hanhe(dbs)] creater 2018-12-21</History>
        [HttpGet]
        public OperateResult GetPrintTypeTemplet(string stockCode, string templetType)
        {
            return ValidateToken(t =>
            {
                var list = BLLCreator.Create<DapperBLL<TN_WM_PRINT_TEMPLETEntity>>().GetList(new
                {
                    CN_S_STOCK_CODE = stockCode,
                    CN_S_TEMPLET_TYPE = templetType
                });
                return OperateResult.Succeed(null, list);
            });
        }
        #endregion

        #region 获取货主
        /// <summary>
        /// 获取货主
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetOwner()
        {
            return ValidateToken(t =>
            {
                var list = BLLCreator.Create<DapperBLL<TN_WM_B_OWNEREntity>>().GetList();
                return OperateResult.Succeed(null, list);
            });
        }
        public OperateResult GetOwnerWithoutDefault()
        {
            return ValidateToken(t =>
            {
                var list = BLLCreator.Create<DapperBLL<TN_WM_B_OWNEREntity>>().GetList(new { CN_B_DEFAULT = false });
                return OperateResult.Succeed(null, list);
            });
        }
        #endregion

        #region 客户地址
        /// <summary>
        /// 客户地址
        /// </summary>
        /// <param name="customCode"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetCustomerAddress(string customCode)
        {
            return ValidateToken(t =>
            {
                var result = BLLCreator.Create<TN_AB_CUSTOMERBLL>().GetCustomerAddress(customCode);
                return OperateResult.Succeed(null, result);
            });
        }
        #endregion

        #region 默认地址
        /// <summary>
        /// 默认地址
        /// </summary>
        /// <param name="customCode"></param>
        /// <returns></returns>
        [HttpGet]
        public OperateResult GetDefaultAddress(string customCode)
        {
            return ValidateToken(t =>
            {
                var result = BLLCreator.Create<TN_AB_CUSTOMERBLL>().GetDefaultAddress(customCode);
                return OperateResult.Succeed(null, result);
            });
        }
        #endregion
    }

}