package order

import (
	"encoding/json"
	"errors"
	"mongodb"
	qutil "qfw/util"
	"strings"
	"time"
	"util"

	"github.com/baiy/Cadmin-server-go/admin"
)

func AddUpdateRecord(context *admin.Context) (interface{}, error) {
	param := new(struct {
		OrderCode  string `form:"orderCode"`
		OrderMoney int    `form:"orderMoney"`
		PayMoney   int    `form:"payMoney"` //支付金额
		//BigSubMoney      int    `form:"bigSubMoney"` //大会员子账号金额
		//SupplyMoney      int    `form:"supplyMoney"` //补充包金额
		Commission       int    `form:"commission"`
		ProceduresMoney  int    `form:"proceduresMoney"` //手续费
		CorrectionReason string `form:"correctionReason"`
		RedType          string `form:"redType"`
		SigningSubject   string `form:"signingSubject"`
	})
	err := context.Form(param)
	if err != nil {
		return nil, err
	}
	orderData := util.JysqlDB.FindOne("dataexport_order", map[string]interface{}{"order_code": param.OrderCode}, "", "")
	if orderData == nil {
		return nil, errors.New("未找到订单")
	}
	updateData := map[string]interface{}{}
	insertData := map[string]interface{}{
		"orderCode":        param.OrderCode,
		"correctionReason": param.CorrectionReason,
		"createTime":       qutil.NowFormat(qutil.Date_Full_Layout),
		"createPerson":     context.User.Username,
		"redType":          param.RedType,
	}
	if param.OrderMoney == 0 { //红冲金额删除，从数据库查询
		param.OrderMoney = qutil.IntAll((*orderData)["order_money"])
	}
	if strings.Contains(param.RedType, "签约主体") {
		if param.SigningSubject == "北京剑鱼信息技术有限公司" {
			updateData["signing_subject"] = "h01"
			insertData["signingSubject"] = "北京拓普丰联信息科技股份有限公司"
		} else {
			updateData["signing_subject"] = "h02"
			insertData["signingSubject"] = "北京剑鱼信息技术有限公司"
		}
	}
	if strings.Contains(param.RedType, "金额") {
		filterMap := map[string]interface{}{}
		if err := json.Unmarshal([]byte(qutil.ObjToString((*orderData)["filter"])), &filterMap); err != nil {
			return nil, errors.New("修正失败")
		}
		//if param.PayMoney != 0 {
		//ct, _ := time.Parse("2006-01-02 15:04:05", qutil.ObjToString((*orderData)["create_time"]))
		//if ct.Unix() > config.SysConfigs.ReleaseTime {
		if qutil.ObjToString((*orderData)["product_type"]) == "大会员" {
			filterMap["bigPayMoneyUpdate"] = param.PayMoney - qutil.IntAll((*orderData)["pay_money"])
			updateData["pay_money"] = param.PayMoney
			//insertData["payMoney"] = param.PayMoney
			insertData["payMoney"] = param.PayMoney - qutil.IntAll((*orderData)["pay_money"])
			//filterMap["bigPayMoney"] = param.PayMoney
			util.JysqlDB.Update("contract", map[string]interface{}{"order_code": param.OrderCode}, map[string]interface{}{"contract_money": param.PayMoney})
		} else {
			filterMap["payMoneyUpdate"] = param.PayMoney
			updateData["pay_money"] = param.PayMoney
			insertData["payMoney"] = param.PayMoney - qutil.IntAll((*orderData)["pay_money"])
			util.JysqlDB.Update("contract", map[string]interface{}{"order_code": param.OrderCode}, map[string]interface{}{"contract_money": param.PayMoney})
		}
		//}

		//}
		//大会员子账号金额修改
		//filterMap["subPayMoneyUpdate"] = param.BigSubMoney
		/*insertData["bigSubMoney"] = param.BigSubMoney - qutil.IntAll(filterMap["subPayMoney"])
		filterMap["subPayMoney"] = param.BigSubMoney

		filterMap["supplyPayMoneyUpdate"] = param.SupplyMoney
		insertData["supplyMoney"] = param.SupplyMoney - qutil.IntAll(filterMap["supplyPayMoney"])
		filterMap["supplyPayMoney"] = param.SupplyMoney*/

		//updateData["order_money"] = param.OrderMoney
		insertData["orderMoney"] = param.OrderMoney - qutil.IntAll((*orderData)["order_money"])
		filterMap["orderMoneyUpdate"] = param.OrderMoney

		updateData["commission"] = param.Commission
		insertData["commission"] = param.Commission - qutil.IntAll((*orderData)["commission"])
		filterMap["commissionUpdate"] = param.Commission

		updateData["procedures_money"] = param.ProceduresMoney
		insertData["proceduresMoney"] = param.ProceduresMoney - qutil.IntAll((*orderData)["procedures_money"])
		filterMap["proceduresMoneyUpdate"] = param.ProceduresMoney - qutil.IntAll((*orderData)["procedures_money"])

		filterByte, _ := json.Marshal(filterMap)
		updateData["filter"] = string(filterByte)
		returnData := util.JysqlDB.SelectBySql(`select IFNULL(sum(return_money),0) as return_money from return_money_record where order_code=? and state=1`, param.OrderCode)
		refundData := util.JysqlDB.SelectBySql(`select IFNULL(sum(refund_money),0) as refund_money from refund_record where order_code=?`, param.OrderCode)
		return_money := qutil.IntAll((*returnData)[0]["return_money"])
		refund_money := qutil.IntAll((*refundData)[0]["refund_money"])
		if param.PayMoney-param.Commission-param.ProceduresMoney == return_money-refund_money {
			updateData["return_status"] = 1
		} else if param.PayMoney-param.Commission-param.ProceduresMoney > return_money-refund_money && return_money-refund_money > 0 {
			updateData["return_status"] = 2
		}
		if return_money == refund_money && return_money > 0 {
			updateData["refund_status"] = 1
		} else if return_money > refund_money && refund_money > 0 {
			updateData["refund_status"] = 2
		}
	}
	util.JysqlDB.Update("dataexport_order", map[string]interface{}{"order_code": param.OrderCode}, updateData)
	util.JysqlDB.Insert("moneyCorrection", insertData)
	return map[string]interface{}{"status": 1}, nil
}

func FindUserAccount(context *admin.Context) (interface{}, error) {
	param := new(struct {
		Phone string `form:"phone"`
	})
	err := context.Form(param)
	if err != nil {
		return nil, err
	}
	// var userData, ok, userId = &map[string]interface{}{}, false, ""
	userData, ok := util.MQFW.Find("user", map[string]interface{}{
		"i_appid": 2,
		"$or": []map[string]interface{}{
			{"s_phone": param.Phone},
			{"s_m_phone": param.Phone}},
	}, `{"s_phone":-1}`, `{"s_phone":1,"s_m_phone":1,"_id":1,"s_nickname":1}`, false, -1, -1)
	if ok && userData != nil && len(*userData) > 0 {
		for _, v := range *userData {
			s_m_phone := qutil.ObjToString(v["s_m_phone"])
			s_phone := qutil.ObjToString(v["s_phone"])
			regTypeArr := []string{}
			if s_phone != "" {
				regTypeArr = append(regTypeArr, "APP")
			}
			if s_m_phone != "" {
				regTypeArr = append(regTypeArr, "微信")
			}
			v["regType"] = strings.Join(regTypeArr, ",")
			v["_id"] = mongodb.BsonIdToSId(v["_id"])
		}
	}
	return map[string]interface{}{"data": userData}, nil
}

func HelpVipInfo(context *admin.Context) (interface{}, error) {
	param := new(struct {
		Phone   string `form:"phone"`
		RegType string `form:"regType"`
	})
	err := context.Form(param)
	if err != nil {
		return nil, err
	}
	willEffect, regType := false, "s_phone"
	//先判断用户是否有即将生效的超级订阅订单
	if strings.Contains(param.RegType, "微信") && !strings.Contains(param.RegType, "APP") {
		regType = "s_m_phone"
	}
	query := map[string]interface{}{
		regType: param.Phone,
		"l_vip_starttime": map[string]interface{}{
			"$gt": time.Now().Unix(),
		},
	}
	count1 := util.MQFW.Count("user", query)
	if count1 > 0 {
		willEffect = true
	}
	// 增加如若存在订单审核状态为“待一审”、“待二审”、“已退回”的超级订阅订单的则不允许创建
	if ExistProcessOrder(param.Phone, SUPERSUB, "") {
		willEffect = true
	}
	if willEffect {
		return map[string]interface{}{
			"willEffect": true,
		}, nil
	}
	//判断用户购买过超级订阅并且在有效期内   i_vip_status 开启状态：0-暂不使用vip订阅 1-试用 2-正式 -1-试用到期 -2-正式到期
	userInfo := map[string]interface{}{}
	userData, ok := util.MQFW.FindOneByField("user", map[string]interface{}{regType: param.Phone, "i_vip_status": 2}, `{"_id":1,"i_vip_expire_tip":1,"i_vip_status":1,"l_vip_endtime":1,"l_vip_starttime":1,"o_vipjy":1}`)
	if ok && userData != nil && len(*userData) > 0 {
		userInfo = *userData
	} else {
		return map[string]interface{}{
			"willEffect": false,
			"userData":   nil,
			"vipExist":   false,
		}, nil
	}
	if userInfo != nil && len(userInfo) > 0 {
		userId := mongodb.BsonIdToSId(userInfo["_id"])
		//查询订单信息获取客户名称
		orderInfo := util.JysqlDB.SelectBySql("SELECT c.customer_name,d.company_name FROM dataexport_order d LEFT JOIN contract c ON c.order_code = d.order_code WHERE product_type = 'VIP订阅' and user_id = ? ORDER BY d.id DESC", userId)
		if len(*orderInfo) == 0 {
			return nil, errors.New("查询订单表没有查到订单信息")
		}
		vipInfo := qutil.ObjToMap(userInfo["o_vipjy"])
		buySet := qutil.ObjToMap((*vipInfo)["o_buyset"])
		areaCount := qutil.IntAll((*buySet)["areacount"])
		//判断购买区域是否是全国
		nationwide := false
		if areaCount == -1 {
			nationwide = true
		}
		if areaCount == -1 {
			areaCount = 0
		}
		//area := qutil.ObjToMap((*vipInfo)["o_area"])
		userInfo["areaCount"] = areaCount
		//判断是新版超级订阅还是老版超级订阅
		newVip := false
		if qutil.IntAll((*buySet)["upgrade"]) == 1 {
			newVip = true
		}
		t := qutil.Int64All(userInfo["l_vip_endtime"])
		_t := time.Unix(t, 0)
		userInfo["vipStartTime"] = (_t.AddDate(0, 0, 1)).Format(qutil.Date_Short_Layout)
		data := map[string]interface{}{
			"willEffect": false,
			"vipExist":   true,
			"nationwide": nationwide,
			"userData":   userInfo,
			"newVip":     newVip,
		}
		if len((*orderInfo)) > 0 {
			data["orderInfo"] = (*orderInfo)[0]
		}
		return data, nil
	}
	return map[string]interface{}{
		"willEffect": false,
		"userData":   nil,
		"vipExist":   false,
		"nationwide": false,
		"new":        false,
	}, nil
}