package cms

import (
	"fmt"
	"git.rosy.net.cn/jx-callback/business/jxstore/event"
	"github.com/astaxie/beego/client/orm"
	"strings"
	"time"

	"git.rosy.net.cn/jx-callback/business/auth2"

	"git.rosy.net.cn/jx-callback/globals"

	"git.rosy.net.cn/baseapi/utils"

	"git.rosy.net.cn/jx-callback/business/jxstore/financial"
	"git.rosy.net.cn/jx-callback/business/jxutils"

	"git.rosy.net.cn/jx-callback/business/model/dao"

	"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"

	"git.rosy.net.cn/jx-callback/business/model"
)

func CreateOrder(ctx *jxcontext.Context, type1, orderType int, way string, price int, lng, lat float64) (orderID, errCode string, err error) {
	var (
		db                       = dao.GetDB()
		order                    *model.Order
		DayTimeBegin, DayTimeEnd = jxutils.GetDayTime()
	)
	if err = auth2.CheckWeixinminiAuthBind(ctx.GetUserID()); err != nil {
		return "", errCode, err
	}
	txDB, _ := dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db, txDB)
			panic(r)
		}
	}()
	if type1 == model.OrderTypeCash {
		//如果用户没有对应账单信息就给他生成一条
		userBill, err := dao.GetUserBill(db, ctx.GetUserID(), "")
		if userBill == nil {
			err = financial.AddUserBill(txDB, jxutils.GenBillID(), ctx.GetUserID())
		}
		if userBill.AccountBalance < price {
			return "", model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("用户余额不足！")
		}
		//用户一天只能提现一次
		billExpends, err := dao.GetBillExpend(db, ctx.GetUserID(), model.BillTypeCash, DayTimeBegin, DayTimeEnd)
		if err != nil {
			return "", "", err
		}
		if len(billExpends) > 0 {
			return "", "", fmt.Errorf("抱歉，一天只能提现一次！")
		}
	}
	address, dCode, cCode, err := getAddressInfoFromCoord(db, lng, lat)
	order = &model.Order{
		OrderID:      utils.Int64ToStr(jxutils.GenOrderNo()),
		UserID:       ctx.GetUserID(),
		Type:         type1,
		OrderType:    orderType,
		Way:          way,
		Status:       model.OrderStatusWait4Pay,
		PayPrice:     price,
		Lng:          lng,
		Lat:          lat,
		Address:      address,
		DistrictCode: dCode,
		CityCode:     cCode,
		PayMethod:    4,
	}
	dao.WrapAddIDCULEntity(order, ctx.GetUserName())
	if err = dao.CreateEntityTx(txDB, order); err != nil {
		dao.Rollback(db, txDB)
	}
	dao.Commit(db, txDB)
	return order.OrderID, errCode, err
}

func Pay(ctx *jxcontext.Context, orderID string, payType int, vendorPayType, appId string, payPrice int) (result *financial.WxPayParam, err error) {
	var (
		temp_PayPrice  int
		temp_PayMethod int
		txDB           orm.TxOrmer
		db             = dao.GetDB()
	)
	orderInfo, err := dao.GetOrderByID(dao.GetDB(), orderID)
	if err != nil {
		return nil, err
	}
	var (
		order = &model.Order{
			OrderID:  orderID,
			PayPrice: orderInfo.PayPrice,
			UserID:   orderInfo.UserID,
		}
		payHandler = &financial.PayHandler{
			PayType:       payType,
			Ctx:           ctx,
			VendorPayType: vendorPayType,
		}
	)
	globals.SugarLogger.Debug("payPrice before1111=========================", payPrice)
	//支付金额＜原金额
	globals.SugarLogger.Debug("order.PayPrice=========================", order.PayPrice)
	if payPrice < order.PayPrice {
		temp_PayPrice = payPrice
		temp_PayMethod = 5
	} else {
		temp_PayPrice = orderInfo.PayPrice
		temp_PayMethod = 2
	}
	globals.SugarLogger.Debug("检验初始数据情况", order.OrderID, order.PayMethod)
	globals.SugarLogger.Debug("检验初始数据情况", order.PayPrice)
	//微信支付实际金额更新到数据库
	if _, err := dao.SetOrderStatus(temp_PayPrice, temp_PayMethod, orderID); err != nil {
		return nil, err
	}
	if _, err := dao.UpdateEntityTx(txDB, order); err != nil {
		return nil, err
	}
	globals.SugarLogger.Debug("经过更新操作后的数据after=========================", order.OrderID, order.PayPrice, order.PayMethod)
	globals.SugarLogger.Debug("经过更新操作后的数据after=========================", order.PayPrice)
	globals.SugarLogger.Debugf("pay begin……")
	err = dao.GetEntity(db, order, "OrderID")
	if order.OrderID == "" {
		return result, fmt.Errorf("未找到此订单！")
	}
	payHandler.Order = order
	globals.SugarLogger.Debug("再次从数据库获得order详情", payHandler.Order.PayPrice, payHandler.Order.PayMethod)
	//如果用户没有对应账单信息就给他生成一条
	// 给用户创建一个银行卡账户
	globals.SugarLogger.Debug("create bill begin……")
	userBill, err := dao.GetUserBill(db, order.UserID, "")
	if userBill == nil {
		globals.SugarLogger.Debug("order.UserID，userBill=======================", order.UserID, userBill)
		err = financial.AddUserBill(txDB, jxutils.GenBillID(), order.UserID)
	}
	err = payHandler.CreatePay(txDB, appId)
	globals.SugarLogger.Debug("the last step of this program,return err……", err)
	globals.SugarLogger.Debugf("result : %v", utils.Format4Output(payHandler.WxPayParam, false))
	return payHandler.WxPayParam, err
}

var (
	NotPay     = 2  //订单待支付
	AlreadyPay = 1  //订单已支付
	Choose     = 1  //选中余额支付
	NotChoose  = -1 //未选中余额支付
)

//余额支付 微信补差值
func PayByBalance(ctx *jxcontext.Context, orderID string, isChoose, payType int, vendorPayType, appID string) (*financial.WxPayParam, string, error) {
	var (
		db = dao.GetDB()
		//txDB orm.TxOrmer
	)
	//获取订单信息
	globals.SugarLogger.Debug("begin get order_info")
	orderInfo, err := dao.GetOrderByID(db, orderID)
	if err != nil {
		return nil, "获取订单信息失败", err
	}
	globals.SugarLogger.Debug("orderInfo.OrderType===============", orderInfo.OrderType)
	//获取用户 会员账户信息
	globals.SugarLogger.Debug("开始获取会员信息")
	userBill, err := dao.GetUserBill(db, orderInfo.UserID, "")
	if err != nil {
		return nil, "获取用户会员账户余额失败", err
	}
	if orderInfo.Status == NotPay {
		globals.SugarLogger.Debug("进入账单未支付")
		globals.SugarLogger.Debug("user_bill.balance==================", userBill.AccountBalance)
		// (3)使用余额且 余额大于支付金额
		if userBill.AccountBalance > 0 && userBill.AccountBalance > orderInfo.PayPrice && isChoose == NotChoose {
			globals.SugarLogger.Debug("进入余额支付部分")
			var order = &model.Order{
				PayPrice:  orderInfo.PayPrice,
				PayMethod: 1, //余额支付
			}
			txDB, _ := dao.Begin(db)
			defer func() {
				if r := recover(); r != nil {
					panic(r)
				}
				dao.Commit(db, txDB)
			}()
			//增加账单 余额减去相应金额
			if err = financial.AddExpendUpdateAccount(txDB, userBill, model.BillTypePayByAccountBalance, order.PayPrice, 0); err != nil {
				dao.Rollback(db, txDB)
				return nil, "使用余额支付失败：", err
			}
			//更新订单状态
			order = &model.Order{
				Status: 110, //支付成功
			}
			if _, err := dao.UpdateEntityTx(txDB, order, "Status"); err != nil {
				dao.Rollback(db, txDB)
				return nil, "", err
			}
			dao.Commit(db, txDB)
		}
		if isChoose == Choose {
			//（1）用户不使用余额或者余额=0 即直接微信支付
			if userBill.AccountBalance == 0 {
				WxPayParam, err := Pay(ctx, orderInfo.OrderID, payType, vendorPayType, appID, orderInfo.PayPrice)
				if err != nil {
					globals.SugarLogger.Debug("err=================", err)
					return nil, "微信支付失败：", err
				}
				return WxPayParam, "", err
			}
			//（2）用户使用余额，剩余微信支付
			totalPrice := orderInfo.PayPrice //订单原价
			if userBill.AccountBalance > 0 && userBill.AccountBalance < orderInfo.PayPrice {
				globals.SugarLogger.Debug("进入混合支付部分")
				//orderInfo.PayMethod = 5                         //混合支付状态
				needPay := totalPrice - userBill.AccountBalance //需支付金额

				globals.SugarLogger.Debug("needPay=================", needPay)
				globals.SugarLogger.Debug("orderInfo.PayPrice=================", orderInfo.PayPrice)
				globals.SugarLogger.Debug("orderInfo.OrderID=================", orderInfo.OrderID)
				WxPayParam, err := Pay(ctx, orderInfo.OrderID, payType, vendorPayType, appID, needPay)
				if err != nil {
					globals.SugarLogger.Debug("err=================", err)
					return nil, "微信支付失败：", err
				}
				return WxPayParam, "", err
			}
		}
	}
	return nil, "", err
}

func Cash(ctx *jxcontext.Context, orderID string, payType int, vendorPayType string) (errCode string, err error) {
	var (
		db    = dao.GetDB()
		order = &model.Order{
			OrderID: orderID,
		}
		payHandler = &financial.PayHandler{
			PayType:       payType,
			Ctx:           ctx,
			VendorPayType: vendorPayType,
		}
	)
	err = dao.GetEntity(db, order, "OrderID")
	if err != nil {
		return errCode, err
	}
	if order.ID == 0 {
		return errCode, fmt.Errorf("未找到此订单！")
	}
	payHandler.Order = order
	err = payHandler.CreateRefund()
	return errCode, err
}

func GetOrders(ctx *jxcontext.Context, orderID, userID string, orderType int, cityCodes []int, fromTime, toTime, keyword string, offset, pageSize int) (pageInfo *model.PagedInfo, err error) {
	return dao.GetOrders(dao.GetDB(), orderID, userID, orderType, cityCodes, utils.Str2Time(fromTime), utils.Str2Time(toTime), keyword, offset, pageSize)
}

//id获取订单详情(单条查询)
//func GetOrderByID(ctx *jxcontext.Context, orderID int) (errMsg string, err error) {
//	//var db = dao.GetDB()
//	if _, err := dao.GetOrderByID(dao.GetDB(), orderID); err != nil {
//		return "id获取订单详情失败", err
//	}
//	return "", err
//}

func FinishedCashOrders(ctx *jxcontext.Context, orderIDs []string) (err error) {
	var (
		db = dao.GetDB()
	)
	for _, orderID := range orderIDs {
		order := &model.Order{
			OrderID: orderID,
		}
		dao.GetEntity(db, order, "OrderID")
		if order.ID != 0 && order.Status == model.OrderStatusWait4Pay {
			order.PayFinishedAt = time.Now()
			order.Comment = "手动转账"
			order.Status = model.OrderStatusFinished
			dao.UpdateEntity(db, order, "PayFinishedAt", "Comment", "Status")
		}
	}
	return err
}

func GetPayStatistics(ctx *jxcontext.Context, userID string, pop int, cityCodes []int, mobile, fromTime, toTime string, consumeTypes []int) (getPayStatisticsResult *dao.GetPayStatisticsResult, err error) {
	var (
		db = dao.GetDB()
	)
	return dao.GetPayStatistics(db, userID, pop, cityCodes, mobile, utils.Str2Time(fromTime), utils.Str2Time(toTime), consumeTypes)
}

func GetManageStatisticsImg(ctx *jxcontext.Context, cityCodes []int, fromTime, toTime string, jobIDs []int) (getManageStatistics []*dao.GetManageStatisticsResult, err error) {
	var (
		db        = dao.GetDB()
		fromTimeT = utils.Str2Time(fromTime)
		toTimeT   = utils.Str2Time(toTime)
	)
	for i := 1; i < utils.Float64TwoInt(toTimeT.Sub(fromTimeT).Hours()/24)+1; i++ {
		getManageStatisticsResult, _ := dao.GetManageStatistics(db, cityCodes, fromTimeT.AddDate(0, 0, i-1), jobIDs)
		getManageStatistics = append(getManageStatistics, getManageStatisticsResult)
	}
	return getManageStatistics, err
}

func GetManageStatisticsJob(ctx *jxcontext.Context, cityCodes []int, fromTime, toTime string, jobIDs []int, offset, pageSize int) (paged *model.PagedInfo, err error) {
	var (
		db = dao.GetDB()
	)
	return dao.GetManageStatisticsJob(db, cityCodes, utils.Str2Time(fromTime), utils.Str2Time(toTime), jobIDs, offset, pageSize)
}

func NewUnionOrder(unionOrder *model.UnionOrder, orderStatus *model.UnionOrderStatus) (err error) {
	var (
		db     = dao.GetDB()
		userID string
	)
	txDB, _ := dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db, txDB)
			panic(r)
		}
	}()
	userBinds, err := dao.GetUserUnionBind(db, "", unionOrder.VendorID, unionOrder.PID)
	if err != nil {
		dao.Rollback(db, txDB)
		return err
	}
	if len(userBinds) == 0 {
		userID = unionOrder.PID
	} else {
		userID = userBinds[0].UserID
	}
	unionOrder.UserID = userID
	dao.WrapAddIDCULEntity(unionOrder, jxcontext.AdminCtx.GetUserName())
	if err = dao.CreateEntityTx(txDB, unionOrder); err != nil {
		dao.Rollback(db, txDB)
		return err
	}
	dao.WrapAddIDCULEntity(orderStatus, jxcontext.AdminCtx.GetUserName())
	if err = dao.CreateEntityTx(txDB, orderStatus); err != nil {
		dao.Rollback(db, txDB)
		return err
	}
	dao.Commit(db, txDB)
	//发消息
	if err == nil {
		orderMessage(unionOrder)
	}
	return err
}

func ChangeUnionOrder(unionOrder *model.UnionOrder, orderStatus *model.UnionOrderStatus) (err error) {
	var (
		db = dao.GetDB()
	)
	globals.SugarLogger.Debugf("ChangeUnionOrder1, unionorder: %v", utils.Format4Output(unionOrder, true))
	txDB, _ := dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db, txDB)
			panic(r)
		}
	}()
	unionOrder.Status = orderStatus.Status
	globals.SugarLogger.Debugf("ChangeUnionOrder2, unionorder: %v", utils.Format4Output(unionOrder, true))
	if _, err = dao.UpdateEntityTx(txDB, unionOrder, "Status"); err != nil {
		dao.Rollback(db, txDB)
		fmt.Println("err1", err)
		return err
	}
	dao.WrapAddIDCULEntity(orderStatus, jxcontext.AdminCtx.GetUserName())
	if err = dao.CreateEntityTx(txDB, orderStatus); err != nil {
		dao.Rollback(db, txDB)
		fmt.Println("err2", err)
		return err
	}
	dao.Commit(db, txDB)
	//发消息
	if err == nil {
		orderMessage(unionOrder)
	}
	return err
}

func orderMessage(unionOrder *model.UnionOrder) {
	content := new(strings.Builder)
	content.WriteString("您有[")
	content.WriteString(model.VendorChineseNames[unionOrder.VendorID])
	content.WriteString("]平台的推广订单:")
	content.WriteString(unionOrder.VendorOrderID)
	content.WriteString("。")
	content.WriteString(model.UnionOrderStatusName[unionOrder.Status])
	content.WriteString("。预计返佣：")
	content.WriteString(jxutils.IntPrice2StandardString(int64(unionOrder.PromotionAmount)))
	content.WriteString("元。")
	event.SendSysMessageSimple(content.String(), unionOrder.UserID)
}

func GetMyUnionOrders(ctx *jxcontext.Context, statuss []int, vendorID, offset, pageSize int) (page *model.PagedInfo, err error) {
	return dao.GetMyUnionOrders(dao.GetDB(), ctx.GetUserID(), statuss, vendorID, offset, pageSize)
}

func GetUnionOrders(ctx *jxcontext.Context, vendorIDs, statuss []int, beginTime, endTime, keyword string, offset, pageSize int) (page *model.PagedInfo, err error) {
	return dao.GetUnionOrdersPage(dao.GetDB(), vendorIDs, statuss, utils.Str2Time(beginTime), utils.Str2Time(endTime), keyword, offset, pageSize)
}