package financial

import (
	"fmt"
	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/jx-callback/business/auth2"
	"git.rosy.net.cn/jx-callback/business/jxutils"
	"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
	"git.rosy.net.cn/jx-callback/business/model"
	"git.rosy.net.cn/jx-callback/business/model/dao"
	"github.com/astaxie/beego/client/orm"
	"time"
)

func AddBillIncome(txDB orm.TxOrmer, billID int64, billType, incomePrice, jobID int) (err error) {
	billIncome := &model.BillIncome{
		BillID:      billID,
		Type:        billType,
		IncomePrice: incomePrice,
		JobID:       jobID,
	}
	dao.WrapAddIDCULEntity(billIncome, jxcontext.AdminCtx.GetUserName())
	return dao.CreateEntityTx(txDB, billIncome)
}

func AddBillExpend(txDB orm.TxOrmer, billID int64, billType, expendPrice, jobID int) (err error) {
	billExpend := &model.BillExpend{
		BillID:      billID,
		Type:        billType,
		ExpendPrice: expendPrice,
		JobID:       jobID,
	}
	dao.WrapAddIDCULEntity(billExpend, jxcontext.AdminCtx.GetUserName())
	return dao.CreateEntityTx(txDB, billExpend)
}
func AddUserBill(txDB orm.TxOrmer, billID int64, userID string) (err error) {
	userBillInsert := &model.UserBill{
		BillID: billID,
		UserID: userID,
	}
	dao.WrapAddIDCULDEntity(userBillInsert, jxcontext.AdminCtx.GetUserName())
	return dao.CreateEntityTx(txDB, userBillInsert)
}

func AddUserBillDb(db *dao.DaoDB, billID int64, userID string) (err error) {
	userBillInsert := &model.UserBill{
		BillID: billID,
		UserID: userID,
	}
	dao.WrapAddIDCULDEntity(userBillInsert, jxcontext.AdminCtx.GetUserName())
	return dao.CreateEntity(db, userBillInsert)
}

func GetUserBillDetail(ctx *jxcontext.Context, userID, fromTime, toTime string, pageSize, offset int) (pagedInfo *model.PagedInfo, err error) {
	return dao.GetUserBillDetail(dao.GetDB(), userID, utils.Str2Time(fromTime), utils.Str2Time(toTime), pageSize, offset)
}

func AddExpendUpdateAccount(txDB orm.TxOrmer, userBill *model.UserBill, billType, price, jobID int) (err error) {
	//1、账户支出增加一条记录
	err = AddBillExpend(txDB, userBill.BillID, billType, price, jobID)
	if err != nil {
		return err
	}
	//2、账户表余额减少相应值
	userBill.AccountBalance -= price
	_, err = dao.UpdateEntityTx(txDB, userBill, "AccountBalance")
	return err
}

func AddIncomeUpdateAccount(txDB orm.TxOrmer, userBill *model.UserBill, billType, price, jobID int) (err error) {
	//2、账户收入增加一条记录
	err = AddBillIncome(txDB, userBill.BillID, billType, price, jobID)
	if err != nil {
		return err
	}
	//1、根据任务剩余数量退钱到账户余额中
	userBill.AccountBalance += price
	_, err = dao.UpdateEntityTx(txDB, userBill, "AccountBalance")
	return err
}

func SettleUnionOrders(ctx *jxcontext.Context, vendorIDs []int) (err error) {
	var (
		db                  = dao.GetDB()
		unionOrderVendorMap map[int][]*model.UnionOrder            //key 为平台ID
		unionOrderMap       map[string]map[int][]*model.UnionOrder //key为userID，整个map把每个User的不同平台的订单放一起
		settleOrders        []*model.UnionOrderSettle
	)
	unionOrderVendorMap = make(map[int][]*model.UnionOrder)
	unionOrderMap = make(map[string]map[int][]*model.UnionOrder)
	unionOrders, err := dao.GetUnionOrders(db, vendorIDs, []int{model.UnionOrderStatusFinish}, utils.ZeroTimeValue, utils.ZeroTimeValue, model.NO)
	if err != nil {
		return err
	}
	for _, v := range unionOrders {
		if _, ok := unionOrderMap[v.UserID]; ok {
			if _, ol := unionOrderVendorMap[v.VendorID]; ol {
				unionOrderMap[v.UserID][v.VendorID] = append(unionOrderMap[v.UserID][v.VendorID], v)
			} else {
				unionOrderMap[v.UserID][v.VendorID] = []*model.UnionOrder{v}
			}
		} else {
			unionOrderVendorMap[v.VendorID] = []*model.UnionOrder{v}
			unionOrderMap[v.UserID] = unionOrderVendorMap
		}
	}
	for userID, v := range unionOrderMap {
		var (
			billID int64
		)
		userBill, _ := dao.GetUserBill(db, userID, "")
		if userBill == nil {
			billID = jxutils.GenBillID()
			AddUserBillDb(db, billID, userID)
		} else {
			billID = userBill.BillID
		}
		for vendorID, vv := range v {
			var (
				sumPrice, count int
			)
			for _, unionOrder := range vv {
				count++
				sumPrice += unionOrder.PromotionAmount
			}
			unionOrderSettle := &model.UnionOrderSettle{
				BillID:       billID,
				VendorID:     vendorID,
				Issue:        jxutils.GetIssue(),
				EarningPrice: sumPrice,
				OrderCount:   count,
			}
			dao.WrapAddIDCULEntity(unionOrderSettle, ctx.GetUserName())
			settleOrders = append(settleOrders, unionOrderSettle)
			//err = dao.CreateEntity(db, unionOrderSettle)
		}
	}
	txDB, _ := dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db, txDB)
			panic(r)
		}
	}()
	for _, v := range settleOrders {
		//插入结算表
		if err = dao.CreateEntityTx(txDB, v); err != nil {
			dao.Rollback(db, txDB)
			return err
		}
		//更新用户账户
		userBill, _ := dao.GetUserBill(db, "", utils.Int64ToStr(v.BillID))
		if err = AddIncomeUpdateAccount(txDB, userBill, model.BillTypeUnionShare, v.EarningPrice, 0); err != nil {
			dao.Rollback(db, txDB)
			return err
		}
	}
	//修改订单结算标志
	for _, v := range unionOrders {
		v.IsEarning = model.YES
		v.UpdatedAt = time.Now()
		if _, err = dao.UpdateEntityTx(txDB, v, "IsEarning", "UpdatedAt"); err != nil {
			dao.Rollback(db, txDB)
			return err
		}
	}
	dao.Commit(db, txDB)
	return err
}

func WXInvestMember(ctx *jxcontext.Context, memberID int, userID string, isFree bool) (errCode string, err error) {
	var (
		db          = dao.GetDB()
		memberCards []*model.MemberCard
		memberCard  *model.MemberCard
		userIDReal  string
	)
	if !isFree {
		userIDReal = ctx.GetUserID()
	} else {
		userIDReal = userID
	}
	userMembers, err := dao.GetUserMember(db, userIDReal, model.MemberTypeNormal)
	configList, err := dao.QueryConfigs(db, model.ConfigTypeName[model.ConfigTypeMemberCard], model.ConfigTypeMemberCard, "")
	userBill, err := dao.GetUserBill(db, userIDReal, "")
	if len(configList) <= 0 {
		return "", fmt.Errorf("未找到会员卡配置！")
	}
	config := configList[0]
	err = jxutils.Strings2Objs(config.Value, &memberCards)
	if err != nil {
		return "", err
	}
	for _, v := range memberCards {
		if v.ID == memberID {
			memberCard = v
		}
	}
	if !isFree {
		//验证微信绑定
		if err = auth2.CheckWeixinminiAuthBind(userIDReal); err != nil {
			return "", err
		}
		if userBill.AccountBalance < memberCard.ActPrice {
			return model.ErrCodeAccountBalanceNotEnough, fmt.Errorf("用户余额不足，请充值！")
		}
	}
	txDB, _ := dao.Begin(db)
	defer func() {
		if r := recover(); r != nil {
			dao.Rollback(db, txDB)
			panic(r)
		}
	}()
	//证明已经开了会员了，相当于续费
	if len(userMembers) > 0 {
		userMember := userMembers[0]
		if memberID == model.MemberCardTypeMonth {
			userMember.EndAt = userMember.EndAt.AddDate(0, 1, 0)
		} else {
			userMember.EndAt = userMember.EndAt.AddDate(1, 0, 0)
		}
		if _, err = dao.UpdateEntity(db, userMember, "EndAt"); err != nil {
			dao.Rollback(db, txDB)
			return
		}
	} else {
		userMember2 := &model.UserMember{
			UserID:       userIDReal,
			MemberType:   model.MemberTypeNormal,
			MemberTypeID: memberID,
		}
		if memberID == model.MemberCardTypeMonth {
			userMember2.EndAt = time.Now().AddDate(0, 1, 0)
		} else {
			userMember2.EndAt = time.Now().AddDate(1, 0, 0)
		}
		dao.WrapAddIDCULDEntity(userMember2, ctx.GetUserName())
		if err = dao.CreateEntity(db, userMember2); err != nil {
			dao.Rollback(db, txDB)
			return
		}
	}
	if !isFree {

		//支出明细
		if err = AddExpendUpdateAccount(txDB, userBill, model.BillTypeMember, memberCard.ActPrice, 0); err != nil {
			dao.Rollback(db, txDB)
			return
		}
	}
	dao.Commit(db, txDB)
	return errCode, err
}