using Ant.Data;
using Ant.ORM;
using Ant.SuperSocket.Common;
using Ant.Service.Common;
using Ant.Service.Common.Enums;
using Central.Control.Domain;
using MES.Production.Entity;
using MES.Production.Entity.Entity;
using MES.Production.Entity.Enum;
using MES.Production.Entity.Extensions;
using MES.Production.Entity.Model;
using MES.Production.Entity.Model.OrderList;
using Ant.Service.Mongodb;
using MES.Production.Service.IService;
using MES.Production.Service.ServiceImp;
using Ant.Service.Utility;
using ChangFa.Machinery.WebPage.App_Start;
using ChangFa.Machinery.WebPage.Areas.SysManage.Models;
using ChangFa.Machinery.WebPage.Controllers;
using ChangFa.Machinery.WebPage.Models;
using MongoDB.Driver.Builders;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Web;
using System.Web.Mvc;
using JsonHelper = Ant.Service.Common.JsonHelper;

namespace ChangFa.Machinery.WebPage.Areas.SysManage.Controllers
{
    public class OrderListController : BaseController
    {
        /// <summary>
        /// 订单列表
        /// </summary>
        /// <returns></returns>
        [UserAuthorize(ModuleAlias = "OrderList", OperaAction = "View")]
        public ActionResult List()
        {
            try
            {
                PageInfo pageInfo = new PageInfo(base.page, base.pagesize, 0, JsonConverter.JsonClass(new List<YW_Order>()));

                #region 处理查询参数
                var orderId = Request.QueryString["orderId"];
                var os = Request.QueryString["orderStatus"];
                var deviceId = Request.QueryString["deviceId"]; 
                if (string.IsNullOrWhiteSpace(os))
                {
                    os = "-1";
                }
                var orderStatus = ConvertHelper.ObjToInt(os);
                #endregion

                #region 加载列表

                using (AntORM orm = new AntORM())
                {
                    orm.db = DataAccessFactory.CreateDataConnection("CyclingItem");
                    RequestModel res = new RequestModel();
                    res.newSt = new SqlNote() { Author = "smj", NewSt = new System.Diagnostics.StackTrace(true), SqlDesc = "获取订单列表" };

                    var query = orm.Queryable<YW_Order>();

                    int pageno = (base.page - 1) * base.pagesize;
                    // 订单id查询
                    query = query.WhereIf(!string.IsNullOrEmpty(orderId), p => p.Id == orderId);
                    // 订单状态
                    query = query.WhereIf(orderStatus > -1, p => p.OrderStatus == (OrderStatusEnum)orderStatus);
                    // 所属设备查询
                    query = query.WhereIf(!string.IsNullOrWhiteSpace(deviceId), p => p.DeviceId == deviceId);

                    var reslut = query.OrderByDesc(p => p.CreateDT).Skip(pageno).Top(pagesize).ToList(res);
                    if (reslut.IsSuccess)
                    {
                        reslut.RecordNum = query.Count();

                        #region 替换deviceid成设备名称
                        var result = reslut.ResultModel as List<YW_Order>;
                        var deviceIds = result.Select(p => p.DeviceId).ToList();
                        var devices = orm.Queryable<SYS_Device>().Where(p => deviceIds.Contains(p.Id)).ToList(res).ResultModel as List<SYS_Device>;

                        result.ForEach(item => {
                            var deviceName = devices.FirstOrDefault(p => p.Id == item.DeviceId)?.Name;
                            item.DeviceId = deviceName ?? item.DeviceId;
                        });

                        #endregion
                        pageInfo = new PageInfo(base.page, base.pagesize, reslut.RecordNum, result);

                    }


                    // 查询所以设备数据，下拉框用

                    List<SYS_Device> devicesData = orm.Queryable<SYS_Device>().Where(p => p.IsDelete == 0).ToList().ResultModel;
                    ViewData["devicesData"] = devicesData;
                }

                ViewData["orderId"] = orderId;
                ViewData["orderStatus"] = orderStatus;
                ViewData["deviceId"] = deviceId ?? string.Empty;

                return View(pageInfo);
                #endregion

            }
            catch (Exception e)
            {
                WriteLog(enumOperator.Select, "获取参赛列表：", e);
                throw e.InnerException;
            }
        }

        /// <summary>
        /// 支付信息
        /// </summary>
        /// <returns></returns>
        [UserAuthorize(ModuleAlias = "OrderList", OperaAction = "payInfo")]
        public ActionResult PayInfo(string id)
        {
            PayCallDto result = new PayCallDto();

            using (AntORM orm = new AntORM())
            {
                orm.db = DataAccessFactory.CreateDataConnection("CyclingItem");
                RequestModel res = new RequestModel();
                res.newSt = new SqlNote() { Author = "smj", NewSt = new System.Diagnostics.StackTrace(true), SqlDesc = "支付信息" };

                var payList = orm.Queryable<YW_PayCall>().Where(p => p.IsDelete == 0 && p.OrderId == id).ToList(res).ResultModel as List<YW_PayCall>;

                payList?.ForEach(payItem => {
                    result.OrderPayInfos.Add(new OrderPayInfoDto()
                    {
                        Id = payItem.Id,
                        PayStatus = payItem.PayStatus,
                        PaySerialId = payItem.PaySerialId,
                        BuyAccount = payItem.BuyAccount,
                        CreateDT = payItem.CreateDT
                    });
                });
            }
            return View(result);
        }

        /// <summary>
        /// 订单流程信息
        /// </summary>
        /// <returns></returns>
        [UserAuthorize(ModuleAlias = "OrderList", OperaAction = "processInfo")]
        public ActionResult ProcessInfo(string id)
        {
            ProcessInfoDto result = new ProcessInfoDto();

            using (AntORM orm = new AntORM())
            {
                orm.db = DataAccessFactory.CreateDataConnection("CyclingItem");
                RequestModel res = new RequestModel();
                res.newSt = new SqlNote() { Author = "smj", NewSt = new System.Diagnostics.StackTrace(true), SqlDesc = "流程信息" };
                var processList = orm.Queryable<YW_OrderProcess>().Where(p => p.IsDelete == 0 && p.OrderId == id).ToList(res).ResultModel as List<YW_OrderProcess>;

                var devices = new List<SYS_Device>();
                var deviceIds = processList?.Select(p => p.DeviceId).ToList();
                if (deviceIds != null && deviceIds.Count() > 0)
                {
                    devices = orm.Queryable<SYS_Device>().Where(p => p.IsDelete == 0 && deviceIds.Contains(p.Id)).ToList(res).ResultModel as List<SYS_Device>;
                }

                processList?.ForEach(processItem => {
                    result.OrderProcessInfos.Add(new OrderProcessDto()
                    {
                        Id = processItem.Id,
                        DeviceName = devices.FirstOrDefault(p => p.Id == processItem.DeviceId)?.Name ?? processItem.DeviceId,
                        CurrentOrderStatus = processItem.CurrentOrderStatus,
                        Message = processItem.Message,
                        CreateDT = processItem.CreateDT
                    });
                });
            }
            return View(result);
        }

        /// <summary>
        /// 订单日志信息
        /// </summary>
        /// <returns></returns>
        [UserAuthorize(ModuleAlias = "OrderList", OperaAction = "orderLog")]
        public ActionResult OrderLog(string id)
        {
            OrderLogDto result = new OrderLogDto();

            using (AntORM orm = new AntORM())
            {
                orm.db = DataAccessFactory.CreateDataConnection("CyclingItem");
                RequestModel res = new RequestModel();
                res.newSt = new SqlNote() { Author = "smj", NewSt = new System.Diagnostics.StackTrace(true), SqlDesc = "订单日志" };
                var orderLogs = orm.Queryable<YW_OrderLog>().Where(p => p.OrderId == id).ToList(res).ResultModel as List<YW_OrderLog>;
                result.OrderLogInfos = orderLogs.Select(p => new OrderLogInfoDto()
                {
                    Id = p.Id,
                    Title = p.Title,
                    Content = p.Content,
                    CreateDT = p.CreateDT,
                    CreateBY = p.CreateBY
                }).ToList();
            }
            return View(result);
        }
        
        /// <summary>
        /// 订单详情
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [UserAuthorize(ModuleAlias = "OrderList", OperaAction = "Detail")]
        public ActionResult Detail(string id)
        {
            OrderInfoDto entity = new OrderInfoDto();
            using (AntORM orm = new AntORM())
            {
                try
                {
                    orm.db = DataAccessFactory.CreateDataConnection("CyclingItem");
                    RequestModel request = new RequestModel
                    {
                        newSt = new SqlNote() { Author = "smj", NewSt = new System.Diagnostics.StackTrace(true), SqlDesc = "订单详情" },
                        Oid = id.ToString()
                    };
                    var reslut = orm.GetEntity<YW_Order>(request);
                    if (reslut.IsSuccess)
                    {
                        YW_Order order = reslut.ResultModel;

                        string payAccount = string.Empty;
                        if (!string.IsNullOrWhiteSpace(order.PaySerialId))
                        {
                            // 若有支付流水号，则查询出事谁支付的
                            var payCall = orm.Queryable<YW_PayCall>().Where(p=>p.PaySerialId == order.PaySerialId).FirstOrDefault().ResultModel as YW_PayCall;
                            if (payCall != null)
                            {
                                payAccount = $"（{payCall.BuyAccount}）";
                            }
                        }

                        // 查询订单所属的设备
                        request.Oid = order.DeviceId;
                        var device = orm.GetEntity<SYS_Device>(request).ResultModel as SYS_Device;

                        // 查询订单详情
                        var orderDetails = orm.Queryable<YW_OrderDetails>().Where(p => p.IsDelete == 0 && p.OrderId == order.Id).ToList(request).ResultModel as List<YW_OrderDetails>;


                        List<OrderDetailsDto> od = new List<OrderDetailsDto>();
                        decimal totalBuyPrice = 0;
                        orderDetails?.ForEach(orderDetail =>
                        {
                            od.Add(new OrderDetailsDto()
                            {
                                Id = orderDetail.Id,
                                ProductId = orderDetail.ProductId,
                                Name = orderDetail.Name,
                                Code = orderDetail.Code,
                                Img = orderDetail.Img,
                                Price = orderDetail.Price,
                                BuyingPrice = orderDetail.BuyingPrice,
                                Count = orderDetail.Count,
                                CreateDT = orderDetail.CreateDT
                            });
                            totalBuyPrice += orderDetail.BuyingPrice * orderDetail.Count;
                        });

                        // 返回实体赋值
                        entity.Id = order.Id;
                        entity.DeviceName = device.Name;
                        entity.Price = order.Price;
                        entity.BuyingPrice = totalBuyPrice;
                        entity.Profit = order.Price - totalBuyPrice;
                        entity.OrderStatus = order.OrderStatus;
                        entity.PaySerialId = order.PaySerialId;
                        entity.BuyAccount = payAccount;
                        entity.CreateDT = order.CreateDT;
                        entity.OrderDetails = od;
                    }
                }
                catch (Exception e)
                {

                }
            }
            return View(entity);
        }

        /// <summary>
        /// 订单退款
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [UserAuthorize(ModuleAlias = "OrderList", OperaAction = "orderRefund")]
        public ActionResult OrderRefundDetails(string id)
        {
            OrderRefundDto entity = new OrderRefundDto();
            using (AntORM orm = new AntORM())
            {
                try
                {
                    orm.db = DataAccessFactory.CreateDataConnection("CyclingItem");
                    RequestModel request = new RequestModel
                    {
                        newSt = new SqlNote() { Author = "smj", NewSt = new System.Diagnostics.StackTrace(true), SqlDesc = "订单详情" },
                        Oid = id.ToString()
                    };
                    var reslut = orm.GetEntity<YW_Order>(request);
                    if (reslut.IsSuccess)
                    {
                        YW_Order order = reslut.ResultModel;

                        string payAccount = string.Empty;
                        if (!string.IsNullOrWhiteSpace(order.PaySerialId))
                        {
                            // 若有支付流水号，则查询出事谁支付的
                            var payCall = orm.Queryable<YW_PayCall>().Where(p => p.PaySerialId == order.PaySerialId).FirstOrDefault().ResultModel as YW_PayCall;
                            if (payCall != null)
                            {
                                payAccount = $"（{payCall.BuyAccount}）";
                            }
                        }

                        // 查询订单所属的设备
                        request.Oid = order.DeviceId;
                        var device = orm.GetEntity<SYS_Device>(request).ResultModel as SYS_Device;

                        // 返回实体赋值
                        entity.Id = order.Id;
                        entity.DeviceName = device.Name;
                        entity.Price = order.Price;
                        entity.PaySerialId = order.PaySerialId;
                        entity.BuyAccount = payAccount;
                        entity.PayStatus = order.PayStatus;
                        entity.CreateDT = order.CreateDT;
                    }
                }
                catch (Exception e)
                {

                }
            }
            return View(entity);
        }


        /// <summary>
        /// 订单退款
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [UserAuthorize(ModuleAlias = "OrderList", OperaAction = "orderRefund")]
        public ActionResult OrderRefund(OrderRefundDto entity)
        {
            Ant.ORM.RequestModel sqlQueryReq = new Ant.ORM.RequestModel();
            sqlQueryReq.newSt = new Ant.ORM.SqlNote() { Author = "smj", NewSt = new System.Diagnostics.StackTrace(true), SqlDesc = "OrderListController-OrderRefund" };

            JsonHelper json = new JsonHelper() { Msg = "订单退款", Status = "n", ReUrl = "/OrderList/List" };

            // WebClient webClient = new WebClient();
            using (HttpClient client = new HttpClient())
            {
                // 参数设置
                string stringForHash = $"{entity.Id}|{WebSystemAccessConfig.Sign}";
                string token = MD5Helper.MD5Hash(stringForHash);
                string url = $"http://api.rgtech.ltd/api/order/orderrefund/{entity.Id}?token={token}";

                var method = new HttpMethod("PUT");
                var request = new HttpRequestMessage(method, url);
                var response = client.SendAsync(request).Result;

                if (response.IsSuccessStatusCode)
                {
                    var stream = response.Content.ReadAsStringAsync().Result;
                    ApiResult result = Newtonsoft.Json.JsonConvert.DeserializeObject<ApiResult>(stream);
                    if (result.IsSuccess)
                    {
                        // 退款成功
                        json.Status = "y";
                    }
                    else
                    {
                        json.Msg = result.Message;
                    }
                }
                else
                {
                    json.Msg = "退款失败";
                    WriteLog(enumOperator.Audit, $"订单退款：{Newtonsoft.Json.JsonConvert.SerializeObject(response)}", enumLog4net.ERROR);
                }
            }
            return Json(json);
        }
        

    }
}