package statser

import (
	"91porn-server/common/maths"
	"91porn-server/common/pageopt"
	"91porn-server/common/timeutil/timerange"
	"91porn-server/models/l/payvidlgmod"
	"91porn-server/models/s/statordermod"
	"91porn-server/models/v/prdcthsomod"
	"91porn-server/models/v/productmod"
	"91porn-server/models/v/rchgordmod"
	"91porn-server/models/v/txnmod"
	"91porn-server/models/v/usermod"
	"91porn-server/models/v/vidmod"
	"time"

	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo/options"
)

type OrderData struct {
	CompleteRate        string  `json:"completeRate"`        //完成率 = 完成订单数 / 总订单数
	OrderCount          int64   `json:"orderCount"`          //生产订单数
	CompleteOrderCount  int64   `json:"completeOrderCount"`  //完成订单数
	OrderAmount         float64 `json:"orderAmount"`         //生产订单金额
	CompleteOrderAmount float64 `json:"completeOrderAmount"` //完成订单的实际支付金额
	PaidOrderCount      int64   `json:"paidOrderCount"`      //用户已支付金额/三方已出款金额
	PaidAmount          float64 `json:"paidAmount"`          //用户已支付订单数/三方已出款订单数
}

func (o *OrderData) From(items statordermod.Items) {
	o.CompleteRate = Percentage(Divide(items.CompleteOrderCount, items.OrderCount))
	o.OrderCount = items.OrderCount
	o.CompleteOrderCount = items.CompleteOrderCount
	o.OrderAmount = float64(items.OrderAmount)
	o.CompleteOrderAmount = float64(items.CompleteOrderAmount)
	o.PaidOrderCount = items.PaidOrderCount
	o.PaidAmount = float64(items.PaidAmount)
}

func (o *OrderData) BaiYuan() *OrderData {
	o.OrderAmount = maths.ToFloat64_b2(o.OrderAmount / 100)
	o.CompleteOrderAmount = maths.ToFloat64_b2(o.CompleteOrderAmount / 100)
	o.PaidAmount = maths.ToFloat64_b2(o.PaidAmount / 100)
	return o
}

type OrderRecord struct {
	ID      primitive.ObjectID     `json:"id"`      // ID
	SumDate time.Time              `json:"sumDate"` //日期
	Type    statordermod.OrderType `json:"type"`    //订单类型
	Channel string                 `json:"channel"` //渠道
	OrderData
	CreatedAt time.Time `json:"createdAt"` //文档创建时间
}

type OrderPage struct {
	Total int64         `json:"total"`
	List  []OrderRecord `json:"list"`
}

type OrderChannelMatch = statordermod.ChannelMatch

type OrderTypeMatch = statordermod.TypeMatch

type OrderSumDateGTEAndLTMatch = statordermod.SumDateGTEAndLTMatch

var Order_Sort_SumDate_n1 = statordermod.Sort_SumDate_n1

func OrderPages(skip, limit int64,
	channelMatch OrderChannelMatch,
	typeMatch OrderTypeMatch,
	sumDateGTEAndLTMatch OrderSumDateGTEAndLTMatch,
) (OrderPage, error) {
	matList := []pageopt.Matcher{
		channelMatch.New(),
		typeMatch.New(),
		sumDateGTEAndLTMatch.New(),
	}
	list, err := statordermod.List(Order_Sort_SumDate_n1, &skip, &limit, matList...)
	if err != nil {
		return OrderPage{}, err
	}
	recordList := make([]OrderRecord, 0, len(list))
	for _, v := range list {
		record := OrderRecord{
			ID:        v.ID,
			SumDate:   v.SumDate,
			Type:      v.Type,
			Channel:   v.Channel,
			CreatedAt: v.CreatedAt,
		}
		record.From(v.Items)
		record.BaiYuan()
		recordList = append(recordList, record)
	}
	count, err := statordermod.Count(matList...)
	if err != nil {
		return OrderPage{}, err
	}
	return OrderPage{
		Total: count,
		List:  recordList,
	}, nil
}

type RchgordChannelMatch = rchgordmod.ChannelMatch

type RchgordCreatedAtGTEAndLTMatch = rchgordmod.CreatedAtGTEAndLTMatch

func RechargeSucRateMap(sumDate time.Time, channel string) (map[int64]float64, error) {
	locDayRange := timerange.LocDayRange(sumDate)
	return rchgordmod.SuccessRateMap(channel, locDayRange.Head, locDayRange.Tail, 15)
}

type DataStruct struct {
	SumData      string                `json:"sumData"`      //统计日期
	VIPRecharge  int64                 `json:"vipRecharge"`  //会员卡充值
	CoinRecharge int64                 `json:"coinRecharge"` //金币充值
	LoufengTrade int64                 `json:"loufengTrade"` //楼凤交易充值
	VipTrande    map[string]*VipTrande `json:"vipTrande"`
	NewUser      int64                 `json:"newCount"` //新增用户
}
type VipTrande struct {
	ID     primitive.ObjectID `json:"id"`
	Name   string             `json:"name"`
	Count  int64              `json:"count"`  //购买次数
	Amount int64              `json:"amount"` //购买金额
}

func getDateString(t time.Time) string {
	return t.Format("20060102")
}
func DataStat(start, end time.Time) (res []*DataStruct, err error, vipTitle []string) {
	m := make(map[string]*DataStruct)
	productMap := make(map[primitive.ObjectID]productmod.ProductWeb)
	products, err := productmod.FindMany()
	if err != nil {
		return
	}
	vipTitle = make([]string, 0)
	for i := range products {
		productMap[products[i].ID] = products[i]
		vipTitle = append(vipTitle, products[i].Name)

	}
	vipTitle = append(vipTitle, "未知")
	data, err := prdcthsomod.FindMany(start, end, options.Find())
	if err != nil {
		return
	}
	for _, v := range data {
		key := getDateString(v.CreatedAt)
		name := productMap[v.ProductID].Name
		if name == "" {
			name = "未知"
		}
		if _, ok := m[key]; ok {
			if _, ok2 := m[key].VipTrande[name]; ok2 {
				m[key].VipTrande[name].Count += 1
				m[key].VipTrande[name].Amount += v.Amount
			} else {
				m[key].VipTrande[name] = &VipTrande{
					Name:   name,
					Count:  1,
					Amount: v.Income + v.Amount,
				}
			}
		} else {
			vipTrandeM := make(map[string]*VipTrande)
			m[key] = &DataStruct{
				SumData:   key,
				VipTrande: vipTrandeM,
			}
			m[key].VipTrande[name] = &VipTrande{
				Name:   name,
				Count:  1,
				Amount: v.Income + v.Amount,
			}
		}
	}
	orders, err := rchgordmod.GetOrderByTime(start, end)
	if err != nil {
		return
	}
	for _, v := range orders {
		key := getDateString(v.CreatedAt)
		if _, ok := m[key]; ok {
		} else {
			m[key] = &DataStruct{
				SumData: key,
			}
		}
		if v.VipID.IsZero() {
			m[key].CoinRecharge += v.PayMoney
		} else {
			m[key].VIPRecharge += v.PayMoney
		}
	}
	trans, err := txnmod.TransStat(start, end)
	if err != nil {
		return
	}
	for _, v := range trans {
		key := getDateString(v.CreatedAt)
		if _, ok := m[key]; ok {
		} else {
			m[key] = &DataStruct{
				SumData: key,
			}
		}
		m[key].LoufengTrade += int64(v.ActualAmount)
	}
	userStat, err := usermod.FindByCreateTime(start, end)
	if err != nil {
		return
	}
	for _, v := range userStat {
		key := getDateString(v.CreatedAt)
		if _, ok := m[key]; ok {
		} else {
			m[key] = &DataStruct{
				SumData: key,
			}
		}
		m[key].NewUser += 1
	}
	res = make([]*DataStruct, 0)
	for start.Before(end) {
		key := getDateString(start)
		if _, ok := m[key]; ok {
		} else {
			m[key] = &DataStruct{
				SumData: key,
			}
		}
		res = append(res, m[key])
		start = start.Add(time.Hour * 24)
	}
	return
}

type PayVidStatInfo struct {
	SumData        string `json:"sumData"`        //统计日期
	ShortVidAmount int64  `json:"shortVidAmount"` //短视频销售额
	ShortVidCount  int64  `json:"ShortVidCount"`  //短视频销售数量
	LongVidAmount  int64  `json:"longVidAmount"`  //短视频销售额
	LongVidCount   int64  `json:"longVidCount"`   //短视频销售数量
}

func PayVidStat(start, end time.Time) (res []*PayVidStatInfo, err error) {
	m := make(map[string]*PayVidStatInfo)
	payVidLogs, err := payvidlgmod.GetPayVidLogsByTime(start, end)
	if err != nil {
		return
	}
	vids := make([]primitive.ObjectID, 0)
	for i := range payVidLogs {
		vids = append(vids, payVidLogs[i].VideoID)
	}
	longVid, err := vidmod.FindShortVidByIDs(vids)
	if err != nil {
		return
	}
	longVidMap := make(map[primitive.ObjectID]int)
	for i := range longVid {
		longVidMap[longVid[i]] = 1
	}
	for _, v := range payVidLogs {
		key := getDateString(v.CreatedAt)
		if _, ok := m[key]; ok {
		} else {
			m[key] = &PayVidStatInfo{
				SumData: key,
			}
		}
		_, ok := longVidMap[v.VideoID]
		if ok {
			m[key].LongVidAmount += v.PayMoney
			m[key].LongVidCount += 1

		} else {
			m[key].ShortVidAmount += v.PayMoney
			m[key].ShortVidCount += 1
		}
	}

	res = make([]*PayVidStatInfo, 0)
	for start.Before(end) {
		key := getDateString(start)
		if _, ok := m[key]; ok {
		} else {
			m[key] = &PayVidStatInfo{
				SumData: key,
			}
		}
		res = append(res, m[key])
		start = start.Add(time.Hour * 24)
	}
	return
}