package service

import (
	"errors"
	"fmt"
	"os"
	"pure-admin/global"
	"pure-admin/model"
	"pure-admin/model/request"
	"pure-admin/model/response"
	"pure-admin/utils"
	"sync/atomic"
	"time"
)

func GetOrderList(info *request.SearchOrderList) (error, interface{}, int64) {
	var (
		err       error
		result    []model.OrderList
		total     int64
		orderIds  []string
		customers []string
	)
	limit := info.PageSize
	offset := info.PageSize * (info.Page - 1)
	db := global.MG_DB.Model(&model.Order{})
	if info.Status != 0 {
		db = db.Where("`order`.status = ?", info.Status)
	}
	if info.OrderID != "" {
		db = db.Where("`order`.order_id = ?", info.OrderID)
	}
	if info.GoodsID != 0 {
		db = db.Where("`order`.commod_id=?", info.GoodsID)
	}
	if info.SpuNo != "" {
		db = db.Joins("LEFT JOIN order_goods ON order_goods.order_id = `order`.order_id").Where("order_goods.spu_no = ?", info.SpuNo)
	}
	if info.Name != "" {
		db = db.Joins("INNER JOIN order_address on order_address.order_id=`order`.order_id").Where("CONCAT(order_address.first_name,order_address.last_name) LIKE ? OR CONCAT(order_address.first_name,' ',order_address.last_name) LIKE ?", "%"+info.Name+"%", "%"+info.Name+"%")
	}
	if info.Phone != "" {
		db = db.Joins("inner join order_address b on b.phone=? and b.order_id=`order`.order_id", info.Phone)
	}
	if info.CreatedAtStart != "" {
		db.Where("`order`.created_at >= ?", info.CreatedAtStart)
	}
	if info.CreatedAtEnd != "" {
		db.Where("`order`.created_at < ?", info.CreatedAtEnd)
	}
	if info.Code != "" {
		db = db.Where("`order`.code=?", info.Code)
	}
	if info.CreatedAt != "" {
		db = db.Where("`order`.created_at>=?", info.CreatedAt)
	}
	if info.UserId != "" {
		db = db.Where("`order`.user_id = ?", info.UserId)
	}
	if info.InfluenceId != "" || info.MissionTitle != "" {
		db = db.Joins("INNER JOIN mission_claim ON mission_claim.claim_no = `order`.`code`")
		if info.InfluenceId != "" {
			db = db.Where("mission_claim.create_by = ?", info.InfluenceId)
		}
		if info.MissionTitle != "" {
			db = db.Joins("INNER JOIN mission ON mission.id = mission_claim.mission_id").Where("mission.title LIKE ?", "%"+info.MissionTitle+"%")
		}
	}
	if info.StoreNo != "" {
		db = db.Where("`order`.store_no = ?", info.StoreNo)
	}
	_ = db.Count(&total).Error
	err = db.Order("`order`.id desc").Offset(offset).Limit(limit).Find(&result).Error
	if err != nil {
		return errors.New("获取订单失败"), result, total
	}
	if len(result) == 0 {
		return nil, result, total
	}
	for v := range result {
		orderIds = append(orderIds, result[v].OrderID)
	}
	var (
		orderGoodsList []model.OrderGoodsDetail
		goodsMap       = make(map[string]model.OrderGoodsDetail)
	)
	err = global.MG_DB.Model(&model.OrderGoods{}).Where("order_id IN (?)", orderIds).Find(&orderGoodsList).Error
	if err != nil {
		return errors.New("获取订单商品信息失败"), result, total
	}
	for _, goods := range orderGoodsList {
		goodsMap[goods.OrderID] = goods
	}
	var (
		addressList []model.OrderAddress
		addressMap  = make(map[string]model.OrderAddress)
	)
	err = global.MG_DB.Model(&model.OrderAddress{}).Where("order_id in (?)", orderIds).Find(&addressList).Error
	if err != nil {
		return errors.New("获取订单地址信息失败"), result, total
	}
	for _, address := range addressList {
		addressMap[address.OrderID] = address
	}
	var (
		delivers   []model.OrderDeliver
		deliverMap = make(map[string]model.OrderDeliver)
	)
	err = global.MG_DB.Model(&model.OrderDeliver{}).Where("order_id in (?)", orderIds).Find(&delivers).Error
	if err != nil {
		return errors.New("获取订单发货信息失败"), result, total
	}
	for _, deliver := range delivers {
		deliverMap[deliver.OrderID] = deliver
	}
	var codes []string
	for v := range result {
		if val, ok := goodsMap[result[v].OrderID]; ok {
			result[v].Goods = val
		}
		if val, ok := addressMap[result[v].OrderID]; ok {
			result[v].Address = val
		}

		if val, ok := deliverMap[result[v].OrderID]; ok {
			result[v].Deliver = val
		}
		if result[v].Code != "" {
			codes = append(codes, result[v].Code)
		}
		customers = append(customers, result[v].UserID)
	}
	var (
		missionMap    = make(map[string]model.MissionClaimInfo)
		influencerMap = make(map[string]model.InfluencerUserClaimView)
	)
	if len(codes) > 0 {
		var (
			missions       []model.MissionClaimInfo
			influencerList []model.InfluencerUserClaimView
		)
		err = global.MG_DB.Select("mission_claim.claim_no,mission_claim.mission_id,b.hire_type,b.hire_money,b.hire_ratio").Model(&model.MissionClaim{}).Joins("inner join mission b on mission_claim.mission_id=b.id").Where("claim_no in (?)", codes).Scan(&missions).Error
		if err != nil {
			return errors.New("获取任务详情失败"), result, total
		}
		for _, mission := range missions {
			missionMap[mission.ClaimNo] = mission
		}
		err = global.MG_DB.Select("`user`.uuid,`user`.nick_name,`user`.phone,mission_claim.claim_no").Model(&model.MissionClaim{}).Joins("inner join `user` on mission_claim.create_by=`user`.uuid").Where("mission_claim.claim_no in (?)", codes).Scan(&influencerList).Error
		if err != nil {
			return errors.New("获取任务网红失败"), result, total
		}
		for _, influencer := range influencerList {
			influencerMap[influencer.ClaimNo] = influencer
		}
	}
	var customerMap = make(map[string]model.UserSimple)
	if len(customers) > 0 {
		var customerList []model.UserSimple
		customerList, err = getUserSimpleList("customer", customers)
		if err != nil {
			return errors.New("获取买家详情失败"), result, total
		}
		for _, user := range customerList {
			customerMap[user.UUID.String()] = user
		}
	}
	for v := range result {
		if result[v].Code != "" {
			if val, ok := missionMap[result[v].Code]; ok {
				if val.HireType == 1 {
					amount := val.HireMoney * float64(result[v].Number)
					result[v].InfluencerAmount = utils.FormatFloatToString(amount)
					result[v].SellerAmount = utils.FormatFloatToString(result[v].PaidPrice - amount)
				} else {
					amount := result[v].PaidPrice * val.HireRatio / 100
					result[v].InfluencerAmount = utils.FormatFloatToString(amount)
					result[v].SellerAmount = utils.FormatFloatToString(result[v].PaidPrice - amount)
				}
			}
			if val, ok := influencerMap[result[v].Code]; ok {
				result[v].InfluencerUser = val
			}
		} else {
			result[v].SellerAmount = utils.FormatFloatToString(result[v].PaidPrice)
		}
		if val, ok := customerMap[result[v].UserID]; ok {
			result[v].CustomerPhone = utils.HideStar(val.Phone)
		}
	}
	return nil, result, total
}

func GetOrderDetail(info *request.SearchOrderDetail) (error, interface{}) {
	var (
		err      error
		result   model.OrderDetail
		missions model.MissionClaimInfo
	)
	db := global.MG_DB.Model(&model.Order{}).Where("`order`.order_id = ?", info.OrderID)
	err = db.Find(&result).Error
	if err != nil {
		return errors.New("获取订单失败"), result
	}
	err = global.MG_DB.Model(&model.OrderAddress{}).Where("order_id = ?", info.OrderID).Find(&result.Address).Error
	if err != nil {
		return errors.New("获取订单地址失败"), result
	}
	err = global.MG_DB.Model(&model.OrderGoods{}).Where("order_id = ?", info.OrderID).Find(&result.Goods).Error
	if err != nil {
		return errors.New("获取订单商品信息失败"), result
	}
	err = global.MG_DB.Model(&model.OrderDeliver{}).Where("order_id = ?", info.OrderID).Find(&result.Deliver).Error
	if err != nil {
		return errors.New("获取发货信息失败"), result
	}
	if result.Code != "" {
		err = global.MG_DB.Select("mission_claim.claim_no,mission_claim.mission_id,b.hire_type,b.hire_money,b.hire_ratio").Model(&model.MissionClaim{}).Joins("inner join mission b on mission_claim.mission_id=b.id").Where("claim_no=?", result.Code).Scan(&missions).Error
		if err != nil {
			fmt.Println(err)
			return errors.New("获取任务详情失败"), result
		}
		if missions.HireType == 1 {
			amount := missions.HireMoney * float64(result.Number)
			result.InfluencerAmount = utils.FormatFloatToString(amount)
			result.SellerAmount = utils.FormatFloatToString((result.PaidPrice - amount))
		} else {
			amount := result.PaidPrice * missions.HireRatio / 100
			result.InfluencerAmount = utils.FormatFloatToString(amount)
			result.SellerAmount = utils.FormatFloatToString(result.PaidPrice - amount)
		}
	}
	result.Chain = model.Chain{Address: "b714e5508531a7b50d0696abdc83d2333bd896db24f68eb1470bb9529390ef3e"}
	return nil, result
}

func getStatisticsOrderList(values []string, unit, relationId string) ([]model.DtStatisticOrder, error) {
	var (
		err    error
		result []model.DtStatisticOrder
	)
	db := global.MG_DB.Model(&model.DtStatisticOrder{}).Where("`value` IN (?) AND `unit` = ?", values, unit)
	if relationId != "" {
		db = db.Where("`relation_id` = ?", relationId)
	}
	err = db.Find(&result).Error
	return result, err
}

func getStatisticsOrderByValues(values []string, unit, t, relationId string) (model.DtStatisticOrder, error) {
	var (
		err    error
		result model.DtStatisticOrder
	)
	db := global.MG_DB.Model(&model.DtStatisticOrder{}).Where("`unit` = ?", unit).
		Select("SUM(order_num) as order_num,SUM(order_done_num) as order_done_num,SUM(order_money) as order_money,SUM(sale_volume) as sale_volume,SUM(settle_reward) as settle_reward,SUM(order_cancel_num) as order_cancel_num,SUM(order_cancel_money) as order_cancel_money")
	if len(values) != 0 {
		db = db.Where("`value` IN (?) ", values)
	}
	if t != "" {
		db = db.Where("`type` = ?", t)
	}
	if relationId != "" {
		db = db.Where("`relation_id` = ?", relationId)
	}
	err = db.First(&result).Error
	return result, err
}

func getStatisticsOrderByValuesRelationIds(values []string, unit, t string, relationIds []string) (model.DtStatisticOrder, error) {
	var (
		err    error
		result model.DtStatisticOrder
	)
	db := global.MG_DB.Model(&model.DtStatisticOrder{}).Where("`unit` = ?", unit).
		Select("SUM(order_num) as order_num,SUM(order_done_num) as order_done_num,SUM(order_money) as order_money,SUM(sale_volume) as sale_volume,SUM(settle_reward) as settle_reward,SUM(order_cancel_num) as order_cancel_num,SUM(order_cancel_money) as order_cancel_money")
	if len(values) != 0 {
		db = db.Where("`value` IN (?) ", values)
	}
	if t != "" {
		db = db.Where("`type` = ?", t)
	}
	if len(relationIds) != 0 {
		db = db.Where("`relation_id` IN (?)", relationIds)
	}
	err = db.First(&result).Error
	return result, err
}

// 获取退款数据
func getOrderPostSaleCount(info *request.SearchOrderPostSale) (int64, error) {
	var (
		err    error
		result int64
	)
	db := global.MG_DB.Model(&model.OrderPostSale{}).Where("`status` != 4")
	if info.OrderId != "" {
		db = db.Where("order_id = ?", info.OrderId)
	}
	if info.Status != 0 {
		db = db.Where("`status` = ?", info.Status)
	}
	if info.UserId != "" {
		db = db.Where("user_id = ?", info.UserId)
	}
	if info.CreatedAtStart != "" {
		db = db.Where("created_at >= ?", info.CreatedAtStart)
	}
	if info.CreatedAtEnd != "" {
		db = db.Where("created_at < ?", info.CreatedAtEnd)
	}
	err = db.Count(&result).Error
	return result, err
}

func getOrderPostSaleCountList(info *request.SearchOrderPostSale) (map[string]int64, error) {
	var (
		err    error
		list   []model.CountMap
		result = make(map[string]int64)
	)
	db := global.MG_DB.Model(&model.OrderPostSale{}).Where("`status` != 4")
	if info.OrderId != "" {
		db = db.Where("order_id = ?", info.OrderId)
	}
	if info.Status != 0 {
		db = db.Where("`status` = ?", info.Status)
	}
	if len(info.UserIds) != 0 {
		db = db.Where("user_id IN (?)", info.UserIds)
	}
	if info.CreatedAtStart != "" {
		db = db.Where("created_at >= ?", info.CreatedAtStart)
	}
	if info.CreatedAtEnd != "" {
		db = db.Where("created_at < ?", info.CreatedAtEnd)
	}
	err = db.Group("user_id").Select("user_id as `key`,COUNT(1) as value").Scan(&list).Error
	if err != nil {
		return result, err
	}
	for _, countMap := range list {
		result[countMap.Key] = countMap.Value
	}
	return result, err
}

func GetStatisticData() (response.DataStatistics, error) {
	var (
		err    error
		result response.DataStatistics
	)
	now := time.Now()
	{
		// 用户数据
		statistic, _ := getStatisticOrderSum(&request.Statistic{T: 0, RelationId: "bkb"}, "order_num", "order_money", "new_order_num")
		// 总销售额
		result.User.Money.Value1 = fmt.Sprintf("%.2f", statistic.OrderMoney)
		// 人均支付金额
		result.User.Money.Value2 = fmt.Sprintf("%.2f", statistic.OrderMoney/float64(statistic.OrderNum))
		// 访问量
		goods, yesterdayGoods := GetGoodsVisitCount()
		result.User.Visit.Value1 = fmt.Sprintf("%v", goods)
		// 昨天访问量
		result.User.Visit.Value2 = fmt.Sprintf("%v", yesterdayGoods)
		// 支付笔数
		result.User.PayNum.Value1 = fmt.Sprintf("%v", statistic.OrderNum)
		// 昨日支付笔数
		yesterday, _ := getStatisticOrderSum(&request.Statistic{Values: []string{now.AddDate(0, 0, -1).Format("060102") + "0000"}, Unit: "", T: 0, RelationId: "bkb"}, "order_num", "new_order_num")
		result.User.PayNum.Value2 = fmt.Sprintf("%v", yesterday.OrderNum)
		// 订单数
		result.User.OrderNum.Value1 = fmt.Sprintf("%v", statistic.NewOrderNum)
		// 昨日订单数
		result.User.OrderNum.Value2 = fmt.Sprintf("%v", yesterday.NewOrderNum)
	}
	_, missionData := GetMissionStatisticData("", "total")
	_, yesterdayMissionData := GetMissionStatisticData(now.AddDate(0, 0, -1).Format(utils.DateFormat), "daily")
	{
		// 网红数据
		// 接任务数
		result.Influence.MissionNum.Value1 = fmt.Sprintf("%v", missionData.ClaimNum)
		// 昨日接任务数
		result.Influence.MissionNum.Value2 = fmt.Sprintf("%v", yesterdayMissionData.ClaimNum)
		// 发布第三方平台数
		result.Influence.PlatformNum.Value1 = fmt.Sprintf("%v", missionData.WorksNum)
		// 昨日发布数
		result.Influence.PlatformNum.Value2 = fmt.Sprintf("%v", yesterdayMissionData.WorksNum)
		// 在途佣金额
		statistic, _ := getStatisticOrderSum(&request.Statistic{T: 2}, "transit_reward")
		result.Influence.TransitReward.Value1 = fmt.Sprintf("%.2f", statistic.TransitReward)
		// 昨日在途佣金
		yesterday, _ := getStatisticOrderSum(&request.Statistic{Values: []string{now.AddDate(0, 0, -1).Format("060102") + "0000"}, Unit: "", T: 2}, "transit_reward")
		result.Influence.TransitReward.Value2 = fmt.Sprintf("%.2f", yesterday.TransitReward)
		// 可用佣金额
		result.Influence.UsedReward.Value1 = ""
		// 昨天可用佣金数
		result.Influence.UsedReward.Value2 = ""
	}
	{
		// 商家数据

		// 发布任务数
		result.Store.MissionNum.Value1 = fmt.Sprintf("%v", missionData.ReleaseNum)
		// 昨日发布任务数
		result.Store.MissionNum.Value2 = fmt.Sprintf("%v", yesterdayMissionData.ReleaseNum)

		goods, yesterdayGoods := GetGoodsCount()
		// 发布商品数
		result.Store.GoodsNum.Value1 = fmt.Sprintf("%v", goods)
		// 昨日发布商品数
		result.Store.GoodsNum.Value2 = fmt.Sprintf("%v", yesterdayGoods)
		// 在途金额
		statistic, _ := getStatisticOrderSum(&request.Statistic{T: 3}, "transit_reward")
		result.Store.TransitReward.Value1 = fmt.Sprintf("%.2f", statistic.TransitReward)
		// 昨日在订单金额
		yesterday, _ := getStatisticOrderSum(&request.Statistic{Values: []string{now.AddDate(0, 0, -1).Format("060102") + "0000"}, Unit: "", T: 3}, "transit_reward")
		result.Store.TransitReward.Value2 = fmt.Sprintf("%.2f", yesterday.TransitReward)
		// 可提金额
		result.Store.UsedCash.Value1 = ""
		// 昨天可用佣金额
		result.Store.UsedCash.Value2 = ""
	}
	return result, err
}

// 生成24位订单号
// 前面17位代表时间精确到毫秒，中间3位代表进程id，最后4位代表序号
var num int64

func generate() string {
	t := time.Now()
	s := t.Format(utils.Continuity)
	m := t.UnixNano()/1e6 - t.UnixNano()/1e9*1e3
	ms := sup(m, 3)
	p := os.Getpid() % 1000
	ps := sup(int64(p), 3)
	i := atomic.AddInt64(&num, 1)
	r := i % 10000
	rs := sup(r, 4)
	n := fmt.Sprintf("%s%s%s%s", s, ms, ps, rs)
	return n
}

// 对长度不足n的数字前面补0
func sup(i int64, n int) string {
	m := fmt.Sprintf("%d", i)
	for len(m) < n {
		m = fmt.Sprintf("0%s", m)
	}
	return m
}