using POSV.Entity;
using POSV.HttpApi;
using POSV.HttpResponse;
using POSV.Utils;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace POSV.StoreBusiness
{
    public class StoreBusinessUtils
    {

        private static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();

        protected static Dictionary<string, string> _errorDesc = new Dictionary<string, string>();

        static StoreBusinessUtils()
        {
            //------------------------------------------------------
            //系统没有定义的错误代码
            _errorDesc.Add("9999", "应答的报文解析异常");
        }

        #region 保存操作异常日志

        public static void SaveOperationLog(string operateType,string memo)
        {
            StoreOperationLogEntity entity = new StoreOperationLogEntity();
            var createTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
            /// 101登录102退出103交班
            /// 201消单202开钱箱203删菜204更改数量
            /// 301折扣302赠送303议价304取消优惠305免单
            string operateTypeTxt = "";
            switch (operateType) {
                case "101":
                    operateTypeTxt = "登录";
                    break;
                case "102":
                    operateTypeTxt = "退出登录";
                    break;
                case "103":
                    operateTypeTxt = "交班";
                    break;
                case "201":
                    operateTypeTxt = "消单";
                    break;
                case "202":
                    operateTypeTxt = "开钱箱";
                    break;
                case "203":
                    operateTypeTxt = "删除单品";
                    break;
                case "204":
                    operateTypeTxt = "更改数量";
                    break;
                case "301":
                    operateTypeTxt = "折扣";
                    break;
                case "302":
                    operateTypeTxt = "赠送";
                    break;
                case "303":
                    operateTypeTxt = "议价";
                    break;
                case "304":
                    operateTypeTxt = "取消优惠";
                    break;
                case "305":
                    operateTypeTxt = "免单";
                    break;
                default:
                    operateTypeTxt = "未知操作";
                    break;
            }
            entity.Id = IdWorkerUtils.Instance.NextId();
            entity.TenantId = Global.Instance.Authc.TenantId;
            entity.WorkerNo = Global.Instance.Worker.No;//员工工号
            entity.DeviceName = DeviceUtils.Instance.ComputerName;//设备名称
            entity.DeviceIp = DeviceUtils.Instance.IPAddress;//本地IP地址
            entity.DeviceMac = DeviceUtils.Instance.MacAddress;//本机MAC
            entity.Type = operateType;
            entity.TypeTxt = operateTypeTxt;
            entity.PosNo = Global.Instance.Authc.PosNo;
            entity.OperationTime = createTime;
            entity.StoreId = Global.Instance.Authc.StoreId; //门店ID
            entity.StoreName = Global.Instance.Worker.StoreInfo.Name;//门店名称
            entity.StoreNo = Global.Instance.Authc.StoreNo;//门店编号
            entity.ShiftName = Global.Instance.BusinessPlanLog.Name;//班次编号
            entity.ShiftNo = Global.Instance.BusinessPlanLog.No;//班次名称
            entity.CreateDate = createTime;//创建时间
            entity.CreateUser = Global.Instance.Worker.No;//创建人
            entity.Memo = string.Format("操作员:{0},{1}进行{2}{3}", Global.Instance.Worker.No, createTime, operateTypeTxt,memo);
            using (var db = Global.Instance.OpenDataBase)
            {
                using (var trans = db.GetTransaction())
                {
                    db.Insert(entity);
                    trans.Complete();
                }
            }
            //设置日志上传为true
            Global.isHaveUpLoadBusLog = true;
        }

        #endregion

        #region 根据员工编号查询员工信息
        public static Worker LocalWorker(string workerNo)
        {

            List<Worker> lists = new List<Worker>();
            Worker worker = null;
            using (var db = Global.Instance.OpenDataBase)
            {

                //主单数据
                lists = db.Query<Worker>("where no = @0;", workerNo).ToList();
            }
            if (lists!=null && lists.Count>0) {
                worker = lists[0];
            }
            return worker;
        }

        #endregion
        #region 本地数据版本

        public static List<PosServerDataVersion> LocalVersion(){

            List<PosServerDataVersion> versionList = new List<PosServerDataVersion>(); 
            using (var db = Global.Instance.OpenDataBase)
            {
                versionList = db.Fetch<PosServerDataVersion>("where tenantId = '"+Global.Instance.Worker.TenantId +"' ");
            }
            return versionList;
        }

        public static void SaveVersion(List<PosServerDataVersion> versionList)
        {
            using (var db = Global.Instance.OpenDataBase)
            {
                using (var trans = db.GetTransaction())
                {
                    string sql = "delete from pos_server_data_version;";
                    db.Execute(sql);
                    db.InsertBatch(versionList);
                    trans.Complete();
                }
            }
        }

        #endregion

        #region 云参数设置

        /// <summary>
        ///  云参数设置
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Tuple<bool, string, StoreBusinessEntityResponse<StoreYunSetResponse>> StoreYunSet(StoreYunSetRequest request)
        {
            Tuple<bool, string, StoreBusinessEntityResponse<StoreYunSetResponse>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                parameters.Add("method", "store.yun.set");
                parameters.Add("storeId", request.StoreId);
                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<StoreBusinessEntityResponse<StoreYunSetResponse>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, StoreBusinessEntityResponse<StoreYunSetResponse>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, StoreBusinessEntityResponse<StoreYunSetResponse>>(false, data.Message, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, StoreBusinessEntityResponse<StoreYunSetResponse>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "云参数下载异常");

                result = new Tuple<bool, string, StoreBusinessEntityResponse<StoreYunSetResponse>>(false, "云参数下载异常,本次操作无效", null);
            }

            return result;
        }
        #endregion

        #region 服务器数据版本

        /// <summary>
        /// 服务器数据版本
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Tuple<bool, string, StoreBusinessListResponse<PosServerDataVersionResponse>> PosServerDataVersion(PosServerDataVersionRequest request)
        {
            Tuple<bool, string, StoreBusinessListResponse<PosServerDataVersionResponse>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                parameters.Add("method", "pos.serverdataversion.down");

                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<StoreBusinessListResponse<PosServerDataVersionResponse>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, StoreBusinessListResponse<PosServerDataVersionResponse>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, StoreBusinessListResponse<PosServerDataVersionResponse>>(false, data.Message, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, StoreBusinessListResponse<PosServerDataVersionResponse>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "数据版本获取异常");

                result = new Tuple<bool, string, StoreBusinessListResponse<PosServerDataVersionResponse>>(false, "数据版本获取异常,本次操作无效", null);
            }

            return result;
        }
        #endregion

        #region 门店云数据汇总

        /// <summary>
        /// 门店云数据汇总
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Tuple<bool, string, StoreBusinessListResponse<SalesOrderSummaryResponse>> SalesOrderSummary(SalesOrderSummaryRequest request)
        {
            Tuple<bool, string, StoreBusinessListResponse<SalesOrderSummaryResponse>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                parameters.Add("method", "store.sales.order.summary");
                parameters.Add("storeId", request.StoreId);
                parameters.Add("workerNo", request.WorkerNo);
                parameters.Add("typeIds", request.TypeIds);
                parameters.Add("startDate", request.StartDate);
                parameters.Add("endDate", request.EndDate);

                var ignoreParameters = new List<string>();
                ignoreParameters.Add("workerNo");
                ignoreParameters.Add("typeIds");
                ignoreParameters.Add("startDate");
                ignoreParameters.Add("endDate");

                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<StoreBusinessListResponse<SalesOrderSummaryResponse>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, StoreBusinessListResponse<SalesOrderSummaryResponse>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, StoreBusinessListResponse<SalesOrderSummaryResponse>>(false, data.Message, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, StoreBusinessListResponse<SalesOrderSummaryResponse>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "获取云销售数据异常");

                result = new Tuple<bool, string, StoreBusinessListResponse<SalesOrderSummaryResponse>>(false, "获取云销售数据异常,本次操作无效", null);
            }

            return result;
        }
        #endregion

        /// <summary>
        /// 营业日菜品明细销售统计
        /// </summary> 
        public static Tuple<bool, string, ListPagerResponse<SalesDayDetailSummaryResponse>> SalesOrderSummary(SalesDayDetailSummaryRequest request)
        {
            Tuple<bool, string, ListPagerResponse<SalesDayDetailSummaryResponse>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                parameters.Add("method", "store.sales.day.product.summary");
                parameters.Add("storeId", request.StoreId); 
               

                var ignoreParameters = new List<string>();

                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
                parameters.Add("startDate", request.StartDate);
                parameters.Add("endDate", request.EndDate);
                parameters.Add("pageNumber", request.PageNumber.ToString());
                parameters.Add("pageSize", request.PageSize.ToString());
                parameters.Add("productNo", request.ProductNo);
                parameters.Add("seriesId", request.SeriesId);
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<ListPagerResponse<SalesDayDetailSummaryResponse>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, ListPagerResponse<SalesDayDetailSummaryResponse>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, ListPagerResponse<SalesDayDetailSummaryResponse>>(false, data.Message, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, ListPagerResponse<SalesDayDetailSummaryResponse>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "获取营业日菜品明细销售统计异常");

                result = new Tuple<bool, string, ListPagerResponse<SalesDayDetailSummaryResponse>>(false, "获取营业日菜品明细销售统计异常,本次操作无效", null);
            }

            return result;
        }

        #region POS设置信息上传

        /// <summary>
        /// POS设置信息上传
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Tuple<bool, string, StoreBusinessEntityResponse<PosSetPlanUpResponse>> PosSetPlanUp(PosSetPlanUpRequest request)
        {
            Tuple<bool, string, StoreBusinessEntityResponse<PosSetPlanUpResponse>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                parameters.Add("method", "pos.setplan.up");
                parameters.Add("planId", request.PlanId);
                parameters.Add("resources", request.Resources);
                parameters.Add("shortcut", request.Shortcut);
                parameters.Add("module", request.Module);
                parameters.Add("config", request.Config);

                var ignoreParameters = new List<string>();
                ignoreParameters.Add("resources");
                ignoreParameters.Add("shortcut");
                ignoreParameters.Add("module");
                ignoreParameters.Add("config");
                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<StoreBusinessEntityResponse<PosSetPlanUpResponse>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, StoreBusinessEntityResponse<PosSetPlanUpResponse>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, StoreBusinessEntityResponse<PosSetPlanUpResponse>>(false, data.Message, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, StoreBusinessEntityResponse<PosSetPlanUpResponse>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "POS设置信息上传异常");

                result = new Tuple<bool, string, StoreBusinessEntityResponse<PosSetPlanUpResponse>>(false, "POS设置信息上传异常,本次操作无效", null);
            }

            return result;
        }
        #endregion

        #region 门店参数方案

        /// <summary>
        /// 门店参数方案
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Tuple<bool, string, StoreBusinessListResponse<PosSetPlanResponse>> PosSetPlan(PosSetPlanRequest request)
        {
            Tuple<bool, string, StoreBusinessListResponse<PosSetPlanResponse>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                parameters.Add("method", "pos.setplan");
                parameters.Add("storeId", request.StoreId);
                parameters.Add("terminalType", "x86");

                var ignoreParameters = new List<string>();
                ignoreParameters.Add("terminalType");

                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<StoreBusinessListResponse<PosSetPlanResponse>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, StoreBusinessListResponse<PosSetPlanResponse>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, StoreBusinessListResponse<PosSetPlanResponse>>(false, data.Message, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, StoreBusinessListResponse<PosSetPlanResponse>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "门店参数方案异常");

                result = new Tuple<bool, string, StoreBusinessListResponse<PosSetPlanResponse>>(false, "门店参数方案异常,本次操作无效", null);
            }

            return result;
        }
        #endregion

        #region 优惠券核销

        /// <summary>
        /// 优惠券核销
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Tuple<bool, string, StoreBusinessEntityResponse<string>> StoreCouponCheck(StoreCouponCheckRequest request)
        {
            Tuple<bool, string, StoreBusinessEntityResponse<string>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                parameters.Add("method", "store.coupon.check");
                parameters.Add("storeId", Global.Instance.Authc.StoreId);
                parameters.Add("couponCode", request.CouponCode);
                parameters.Add("busNo", request.BusNo);
                parameters.Add("storeName", Global.Instance.Authc.StoreName);
                parameters.Add("storeNo", Global.Instance.Authc.StoreNo);
                parameters.Add("workerNo", Global.Instance.BusinessPlanLog.WorkerNo);
                parameters.Add("posNo", Global.Instance.Authc.PosNo);

                var ignoreParameters = new List<string>();
                ignoreParameters.Add("couponCode");
                ignoreParameters.Add("busNo");
                ignoreParameters.Add("storeName");
                ignoreParameters.Add("storeNo");
                ignoreParameters.Add("workerNo");
                ignoreParameters.Add("posNo");
                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<StoreBusinessEntityResponse<string>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, StoreBusinessEntityResponse<string>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, StoreBusinessEntityResponse<string>>(false, data.Message, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, StoreBusinessEntityResponse<string>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "优惠券核销异常");

                result = new Tuple<bool, string, StoreBusinessEntityResponse<string>>(false, "优惠券核销异常,本次操作无效", null);
            }

            return result;
        }

        /// <summary>
        /// 优惠券核销校验
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static Tuple<bool, string, StoreBusinessEntityResponse<string>> StoreCouponCheckOut(StoreCouponCheckRequest request)
        {
            Tuple<bool, string, StoreBusinessEntityResponse<string>> result = null;

            try
            {
                OpenApi api = OpenApiUtils.Instance.NextApi(ApiType.Business);
                SortedList<string, string> parameters = OpenApiUtils.Instance.NewParameters(api);

                parameters.Add("method", "store.coupon.checkout");
                parameters.Add("storeId", Global.Instance.Authc.StoreId);
                parameters.Add("couponCode", request.CouponCode);
                var ignoreParameters = new List<string>();
                ignoreParameters.Add("couponCode");
                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignoreParameters));
                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                //获取成功
                if (Constant.IsSuccessful(response))
                {
                    var data = JsonUtils.Deserialize<StoreBusinessEntityResponse<string>>(response);
                    if (data.Status == 1)
                    {
                        result = new Tuple<bool, string, StoreBusinessEntityResponse<string>>(true, data.Message, data);
                    }
                    else
                    {
                        result = new Tuple<bool, string, StoreBusinessEntityResponse<string>>(false, data.Message, data);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);
                    result = new Tuple<bool, string, StoreBusinessEntityResponse<string>>(false, errorMessage, null);
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "优惠券核销校验异常");

                result = new Tuple<bool, string, StoreBusinessEntityResponse<string>>(false, "优惠券核销校验异常,本次操作无效", null);
            }

            return result;
        }

        #endregion

        protected static string PaserErrors(string response)
        {
            string result = string.Empty;
            try
            {
                logger.Error(response);

                Errors mainError = JsonUtils.Deserialize<Errors>(response);
                if (_errorDesc.ContainsKey(mainError.Code))
                {
                    result = _errorDesc[mainError.Code];
                }
                else
                {
                    result = mainError.Message;
                }

                List<SubErrors> subError = mainError.SubErrors;
                if (subError != null && subError.Count > 0)
                {
                    SubErrors error = subError[0];
                    if (_errorDesc.ContainsKey(error.Code))
                    {
                        result = _errorDesc[error.Code];
                    }
                    else
                    {
                        result = error.Message;
                    }
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "非法的错误信息格式");

                result = _errorDesc["9999"];
            }

            return result;
        }
    }
}