using System;
using System.Collections.Generic;
using FluentScheduler;
using POSV.Entity;
using POSV.HttpApi;
using POSV.HttpResponse;
using POSV.ShoppingCart;
using POSV.Utils;
using System.Linq;
using System.Diagnostics;
using System.Threading;

namespace POSV.Job
{
    public class OrderBurdenJob : BaseApi, IJob
    {
        private static NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();

        private readonly object _lock = new object();

        private bool isRunning = false;

        public void Execute()
        {
            //lock (_lock)
            //{



            //}

            var sw = new Stopwatch();

            if (!Global.Instance.IsLogin)
            {
                logger.Debug("未登录忽略本次上传");
                return;
            }

            if (!Global.Instance.Online)
            {
                logger.Debug("脱机状态，忽略本次上传");
                return;
            }

            if (!Global.Instance.AllowUpload)
            {
                logger.Info("正在点单，暂不上传");
                return;
            }

            if (isRunning)
            {
                logger.Debug("上传中，请稍候...");
                return;
            }
            if (!Global.isHaveBurdenTicket) {
                logger.Debug("没有需要上传的耗料数据,isHaveBurdenTicket=false");
                return;
            }
            UploadOrderObject(3);
        }

        private List<OrderProductBurden> UploadOrderObject(int limit)
        {
            this.isRunning = true;

            var sw = new Stopwatch();

            var lists = new List<OrderProductBurden>();

            try
            {
                sw.Start();
                
                using (var db = Global.Instance.OpenDataBase)
                {
                    //主单数据
                    lists = db.Query<OrderProductBurden>("where uploadStatus = 0 order by uploadErrors limit @0;", limit).ToList();

                    if (lists.Count <= 0)
                    {
                        logger.Debug("没有需要上传的耗料数据,isHaveBurdenTicket=false");
                        Global.isHaveBurdenTicket = false;
                    }
                }
            }
            catch (Exception ex)
            {
                logger.Error(ex, "加载未上传订单异常");
            }
            finally
            {
                if (lists.Count > 0)
                {
                  
                    ProcessProductBurden(lists);

                    sw.Stop();
                    logger.Info("耗料数据上传<{0}>条数据耗时<{1}>", lists.Count, sw.ElapsedMilliseconds);
                }

                this.isRunning = false;
            }

            return lists;
        }

        private bool ProcessProductBurden(List<OrderProductBurden> orderBurdenList)
        {
            bool isSuccess = true;

            try
            {
                var uploadObject = BuilderUploadObject(orderBurdenList);
                string jsonString = JsonUtils.Serialize(uploadObject);
                var uploadResult = this.Uploading(jsonString);

                if (uploadResult.Item1)
                {
                    foreach (OrderProductBurden productBurden in orderBurdenList) {

                        productBurden.UploadTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
                    }
                    //上传失败
                    isSuccess = true;
                }
                else
                {
                    //上传失败
                    isSuccess = false;
                }
                foreach (OrderProductBurden productBurden in orderBurdenList)
                {
                    productBurden.UploadStatus = uploadResult.Item2.Status;
                    productBurden.UploadMessage = uploadResult.Item2.Message;
                    productBurden.UploadErrMessage = uploadResult.Item2.ErrMessage;
                }
                
            }

            catch (Exception ex)
            {
                isSuccess = false;

                logger.Error(ex, "耗料数据上传任务异常");

                Global.Instance.BugReport(ex, "耗料数据上传任务异常");
            }
            finally
            {
                if (!isSuccess)
                {
                    foreach (OrderProductBurden productBurden in orderBurdenList)
                    {
                        productBurden.UploadErrors += 1;
                    }
                }
                lock (Global.Instance.SyncLock)
                {
                    foreach (OrderProductBurden productBurden in orderBurdenList)
                    {
                        string sql = @"update pos_order_product_burden set uploadStatus = {0}, uploadMessage = '{1}', uploadErrors = {2}, uploadErrMessage = '{3}', uploadTime = '{4}'  where id = '{5}';";
                        SqliteUtils.Execute(string.Format(sql, productBurden.UploadStatus, productBurden.UploadMessage, productBurden.UploadErrors, productBurden.UploadErrMessage, productBurden.UploadTime, productBurden.Id));
                    }
                }
            }

            return isSuccess;
        }


        private List<Dictionary<string, object>> BuilderUploadObject(List<OrderProductBurden> orderBurdenList)
        {
            //耗料数据上传
            var ticket_info = new List<Dictionary<string, object>>();
            if(orderBurdenList != null)
            {
                foreach (var burden in orderBurdenList)
                {
                    var p = new Dictionary<string, object>();
                    //前台系统ID
                    p["id"] = burden.Id;
                    //优惠类型
                    p["tenantId"] = burden.TenantId;
                    //优惠说明
                    p["storeId"] = burden.StoreId;
                    //优惠金额
                    p["orderId"] = burden.OrderId;
                    //优惠金额
                    p["tradeNo"] = burden.TradeNo;
                    //优惠金额
                    p["burdenProductId"] = burden.BurdenProductId;
                    //优惠金额
                    p["burdenSpecId"] = burden.BurdenSpecId;
                    //优惠金额
                    p["salesUnitId"] = burden.SalesUnitId;
                    //优惠金额
                    p["salesAmount"] = burden.SalesAmount;
                    ticket_info.Add(p);
                }
            }
            return ticket_info;
        }


        private Tuple<bool, EntityResponse<UploadResult>> Uploading(string jsonString)
        {
            Tuple<bool, EntityResponse<UploadResult>> result = null;
            try
            {
                logger.Debug("开始上传数据......");

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

                parameters.Add("method", "upload.business.order.burden");
                parameters.Add("storeId", Global.Instance.Authc.StoreId);
                parameters.Add("jsonString", jsonString);

                var ignore = new List<string>();
                ignore.Add("jsonString");

                parameters.Add("sign", OpenApiUtils.Instance.Sign(api, parameters, ignore));

                string response = HttpClientUtils.PostAsync(api, api.Url, parameters);

                logger.Info("上传返回结果:{0}", response);

                if (Constant.IsSuccessful(response))
                {
                    var status = JsonUtils.Deserialize<EntityResponse<UploadResult>>(response);

                    if (status.Status == 1 )
                    {
                        logger.Info(status.Message);

                        result = new Tuple<bool, EntityResponse<UploadResult>>(true, status);
                    } else if (status.Status == 2) {

                        logger.Info(status.Message);

                        result = new Tuple<bool, EntityResponse<UploadResult>>(false, status);
                    }
                    else
                    {
                        string message = string.Format("<{0}>-{1}-{2}", status.ErrCode, status.ErrMessage, status.Message);

                        logger.Info(string.Format("上传出错:{0}", message));

                        result = new Tuple<bool, EntityResponse<UploadResult>>(false, status);
                    }
                }
                else
                {
                    string errorMessage = PaserErrors(response);

                    logger.Info(string.Format("报文解析出错:{0}", errorMessage));


                    //构建错误信息
                    var resp = new EntityResponse<UploadResult>();
                    resp.Status = 0;
                    resp.Message = errorMessage;
                    resp.ErrCode = string.Empty;
                    resp.ErrMessage = string.Empty;

                    resp.Data = null;

                    result = new Tuple<bool, EntityResponse<UploadResult>>(false, resp);

                }

            }
            catch (Exception ex)
            {
                string message = string.Format("上传发生异常");

                logger.Error(ex, message);

                //构建异常错误
                var resp = new EntityResponse<UploadResult>();
                resp.Status = 0;
                resp.Message = message;
                resp.ErrCode = string.Empty;
                resp.ErrMessage = string.Empty;

                resp.Data = null;

                result = new Tuple<bool, EntityResponse<UploadResult>>(false, resp);
            }

            return result;
        }
    }
}