package blocstatdaily

import (
	"context"
	"fmt"
	"stat/common/log"
	"stat/common/utils"
	"stat/models/accessmod"
	"stat/models/blocDailystatmod"
	"stat/models/rechargemod"
	"stat/models/registermod"
	"stat/models/withdrawUserOrdermod"
	"strconv"
	"time"
)

const (
	DirectVisitCount   string = "directVisitCount"   // 直推访问数
	FissionVisitCount  string = "fissionVisitCount"  // 裂变访问数
	Day1RetainRate     string = "day1RetainRate"     // 次日留存率
	Day3RetainRate     string = "day3RetainRate"     // 3日留存率
	Day7RetainRate     string = "day7RetainRate"     // 7日留存率
	RechargeAmount     string = "rechargeAmount"     // 直推充值金额
	FissionAmount      string = "fissionAmount"      // 裂变充值金额
	NewDirectCount     string = "newDirectCount"     // 新增直推
	NewFissionCount    string = "newFissionCount"    // 新增裂变
	DaichongAmout      string = "daichongAmout"      // 代充金额
	OnlineAmount       string = "onlineAmount"       // 在线充值
	NewRechargeCount   string = "newRechargeCount"   // 新增充值数
	UserWithdrawAmount string = "userWithdrawAmount" // 用户提现
)

func defaultTimeMap(defaultStatDate time.Time) map[string]time.Time {
	return map[string]time.Time{
		DirectVisitCount:   defaultStatDate, // 直推访问用户数
		FissionVisitCount:  defaultStatDate, // 裂变访问数
		Day1RetainRate:     defaultStatDate, // 次日留存率
		Day3RetainRate:     defaultStatDate, // 3日留存率
		Day7RetainRate:     defaultStatDate, // 7日留存率
		RechargeAmount:     defaultStatDate, // 直推充值金额
		FissionAmount:      defaultStatDate, // 裂变充值金额
		NewDirectCount:     defaultStatDate, // 新增直推
		NewFissionCount:    defaultStatDate, // 新增裂变
		DaichongAmout:      defaultStatDate, // 代充金额
		OnlineAmount:       defaultStatDate, // 在线充值
		NewRechargeCount:   defaultStatDate, // 新增充值数
		UserWithdrawAmount: defaultStatDate, // 用户提现
	}
}

// 获取统计方法
type StatMethod = func(ctx context.Context, start time.Time, end time.Time, appIds []int32) error

// 统计方法汇总
var statMethodMap = map[string]StatMethod{
	DirectVisitCount:   DirectVisitCountMethod,   // 直推访问用户数
	FissionVisitCount:  FissionVisitCountMethod,  // 裂变访问数
	Day1RetainRate:     Day1RetainRateMethod,     // 次日留存率
	Day3RetainRate:     Day3RetainRateMethod,     // 3日留存率
	Day7RetainRate:     Day7RetainRateMethod,     // 7日留存率
	RechargeAmount:     DirectAmountMethod,       // 直推充值金额
	FissionAmount:      FissionAmountMethod,      // 裂变充值金额
	NewDirectCount:     NewDirectCountMethod,     // 新增直推
	NewFissionCount:    NewFissionCountMethod,    // 新增裂变
	DaichongAmout:      DaichongAmoutMethod,      // 代充金额
	OnlineAmount:       OnlineAmountMethod,       // 在线充值
	NewRechargeCount:   NewRechargeCountMethod,   // 新增充值数
	UserWithdrawAmount: UserWithdrawAmountMethod, // 用户提现
}

// DirectVisitCountMethod 访问用户数
func DirectVisitCountMethod(ctx context.Context, start time.Time, end time.Time, appIds []int32) error {
	for _, appid := range appIds {
		isDirect := true

		userCount, err := accessmod.BlocDailyStatCount(ctx, appid, &isDirect, nil, start, end)
		if err != nil {
			log.Error("DirectVisitCountMethod BlocDailyStatCount", log.E(err))
			return err
		}

		// 更新数据库
		doc := blocDailystatmod.BlocDailyStatDoc{
			DirectVisitCount: &userCount,
		}

		err = blocDailystatmod.UpsertBlocDailyStat(ctx, start, appid, doc)
		if err != nil {
			log.Error("DirectVisitCountMethod UpsertDailyStat ", log.E(err))
			return err
		}
	}

	return nil
}

// FissionVisitCountMethod 裂变访问数
func FissionVisitCountMethod(ctx context.Context, start time.Time, end time.Time, appIds []int32) error {
	for _, appid := range appIds {
		isDirect := false

		userCount, err := accessmod.BlocDailyStatCount(ctx, appid, &isDirect, nil, start, end)
		if err != nil {
			log.Error("DirectVisitCountMethod BlocDailyStatCount", log.E(err))
			return err
		}
		// 更新数据库
		doc := blocDailystatmod.BlocDailyStatDoc{
			FissionVisitCount: &userCount,
		}
		err = blocDailystatmod.UpsertBlocDailyStat(ctx, start, appid, doc)
		if err != nil {
			log.Error("FissionVisitCountMethod UpsertDailyStat ", log.E(err))
			return err
		}
	}

	return nil
}

// Day1RetainRateMethod 次日留存率
func Day1RetainRateMethod(ctx context.Context, start time.Time, end time.Time, appIds []int32) error {
	for _, appid := range appIds {
		rate := float64(0)

		registerStart := utils.BeginWithTime(start.AddDate(0, 0, -1))
		registerEnd := utils.EndWithTime(start.AddDate(0, 0, -1))

		registerCount, err := registermod.TotalAddUserCount(ctx, appid, registerStart, registerEnd)
		if err != nil {
			log.Error("Day1RetainRateMethod s", log.E(err))
			return err
		}
		VistitCount, err := accessmod.DailyUserVisitCountByRegister(ctx, appid, start, end, registerStart, registerEnd)
		if err != nil {
			log.Error("Day1RetainRateMethod DailyUserVisitCountByRegister", log.E(err))
			return err
		}

		if registerCount > 0 {
			rate, _ = strconv.ParseFloat(fmt.Sprintf("%.2f", 100*(float64(VistitCount)/float64(registerCount))), 64)

		}

		// 更新数据库
		doc := blocDailystatmod.BlocDailyStatDoc{
			Day1RetainRate: &rate,
		}
		err = blocDailystatmod.UpsertBlocDailyStat(ctx, start, appid, doc)
		if err != nil {
			log.Error("Day1RetainRateMethod UpsertDailyStat ", log.E(err))
			return err
		}
	}

	return nil
}

// Day3RetainRateMethod 3日留存率
func Day3RetainRateMethod(ctx context.Context, start time.Time, end time.Time, appIds []int32) error {
	for _, appid := range appIds {

		registerStart := utils.BeginWithTime(start.AddDate(0, 0, -2))
		registerEnd := utils.EndWithTime(start.AddDate(0, 0, -2))
		rate := float64(0)

		registerCount, err := registermod.TotalAddUserCount(ctx, appid, registerStart, registerEnd)
		if err != nil {
			log.Error("Day3RetainRateMethod DailyUserRegisterCount", log.E(err))
			return err
		}
		VistitCount, err := accessmod.DailyUserVisitCountByRegister(ctx, appid, start, end, registerStart, registerEnd)
		if err != nil {
			log.Error("Day3RetainRateMethod DailyUserVisitCountByRegister", log.E(err))
			return err
		}

		if registerCount > 0 {
			rate, _ = strconv.ParseFloat(fmt.Sprintf("%.2f", 100*(float64(VistitCount)/float64(registerCount))), 64)

		}

		// 更新数据库
		doc := blocDailystatmod.BlocDailyStatDoc{
			Day3RetainRate: &rate,
		}
		err = blocDailystatmod.UpsertBlocDailyStat(ctx, start, appid, doc)
		if err != nil {
			log.Error("Day3RetainRateMethod UpsertDailyStat ", log.E(err))
			return err
		}
	}

	return nil
}

// Day7RetainRateMethod 7日留存率
func Day7RetainRateMethod(ctx context.Context, start time.Time, end time.Time, appIds []int32) error {
	for _, appid := range appIds {
		registerStart := utils.BeginWithTime(start.AddDate(0, 0, -6))
		registerEnd := utils.EndWithTime(start.AddDate(0, 0, -6))
		rate := float64(0)

		registerCount, err := registermod.TotalAddUserCount(ctx, appid, registerStart, registerEnd)
		if err != nil {
			log.Error("Day3RetainRateMethod DailyUserRegisterCount", log.E(err))
			return err
		}
		VistitCount, err := accessmod.DailyUserVisitCountByRegister(ctx, appid, start, end, registerStart, registerEnd)
		if err != nil {
			log.Error("Day3RetainRateMethod DailyUserVisitCountByRegister", log.E(err))
			return err
		}

		if registerCount > 0 {
			rate, _ = strconv.ParseFloat(fmt.Sprintf("%.2f", 100*(float64(VistitCount)/float64(registerCount))), 64)

		}

		// 更新数据库
		doc := blocDailystatmod.BlocDailyStatDoc{
			Day7RetainRate: &rate,
		}
		err = blocDailystatmod.UpsertBlocDailyStat(ctx, start, appid, doc)
		if err != nil {
			log.Error("Day7RetainRateMethod UpsertDailyStat ", log.E(err))
			return err
		}
	}

	return nil
}

// DirectAmountMethod 直推充值金额
func DirectAmountMethod(ctx context.Context, start time.Time, end time.Time, appIds []int32) error {
	for _, appid := range appIds {
		// 获取充值金额
		count, amount, err := rechargemod.BlocDirectRechargeAmount(ctx, appid, start, end)
		if err != nil {
			log.Error("DirectAmountMethod BlocDirectRechargeAmount ", log.E(err))
			return err
		}
		// 更新数据库
		doc := blocDailystatmod.BlocDailyStatDoc{
			DirectAmount:      &amount,
			DirectAmountCount: &count,
		}
		err = blocDailystatmod.UpsertBlocDailyStat(ctx, start, appid, doc)
		if err != nil {
			log.Error("DirectAmountMethod UpsertDailyStat ", log.E(err))
			return err
		}
	}

	return nil
}

// FissionAmountMethod 裂变充值金额
func FissionAmountMethod(ctx context.Context, start time.Time, end time.Time, appIds []int32) error {
	for _, appid := range appIds {
		// 获取充值金额
		count, amount, err := rechargemod.BlocFissionRechargeAmount(ctx, appid, start, end)
		if err != nil {
			log.Error("FissionAmountMethod BlocFissionRechargeAmount ", log.E(err))
			return err
		}
		// 更新数据库
		doc := blocDailystatmod.BlocDailyStatDoc{
			FissionAmount:      &amount,
			FissionAmountCount: &count,
		}
		err = blocDailystatmod.UpsertBlocDailyStat(ctx, start, appid, doc)
		if err != nil {
			log.Error("FissionAmountMethod UpsertBlocDailyStat ", log.E(err))
			return err
		}
	}
	return nil
}

// NewDirectCountMethod 新增直推
func NewDirectCountMethod(ctx context.Context, start time.Time, end time.Time, appIds []int32) error {
	for _, appid := range appIds {

		count, err := registermod.BlocDirectAddUserCount(ctx, appid, start, end)
		if err != nil {
			log.Error("NewDirectCountMethod DeductionRechargeAmount ", log.E(err))
			return err
		}
		// 更新数据库
		doc := blocDailystatmod.BlocDailyStatDoc{
			NewDirectCount: &count,
		}
		err = blocDailystatmod.UpsertBlocDailyStat(ctx, start, appid, doc)
		if err != nil {
			log.Error("NewDirectCountMethod UpsertDailyStat ", log.E(err))
			return err
		}
	}
	return nil
}

// NewFissionCountMethod 新增裂变
func NewFissionCountMethod(ctx context.Context, start time.Time, end time.Time, appIds []int32) error {
	for _, appid := range appIds {

		count, err := registermod.BlocFissionAddUserCount(ctx, appid, start, end)
		if err != nil {
			log.Error("NewFissionCountMethod DeductionRechargeAmount ", log.E(err))
			return err
		}
		// 更新数据库
		doc := blocDailystatmod.BlocDailyStatDoc{
			NewFissionCount: &count,
		}
		err = blocDailystatmod.UpsertBlocDailyStat(ctx, start, appid, doc)
		if err != nil {
			log.Error("NewFissionCountMethod UpsertDailyStat ", log.E(err))
			return err
		}
	}
	return nil
}

// DaichongAmoutMethod 代充金额
func DaichongAmoutMethod(ctx context.Context, start time.Time, end time.Time, appIds []int32) error {
	for _, appid := range appIds {
		_, money, err := rechargemod.BlocGetDaichongAmout(ctx, appid, start, end)
		if err != nil {
			log.Error("DaichongAmoutMethod BlocGetDaichongAmout ", log.E(err))
			return err
		}
		// 更新数据库
		doc := blocDailystatmod.BlocDailyStatDoc{
			DaichongAmout: &money,
		}
		err = blocDailystatmod.UpsertBlocDailyStat(ctx, start, appid, doc)
		if err != nil {
			log.Error("NewDeductionCountMethod UpsertBlocDailyStat ", log.E(err))
			return err
		}
	}
	return nil
}

// OnlineAmountMethod 在线充值
func OnlineAmountMethod(ctx context.Context, start time.Time, end time.Time, appIds []int32) error {
	for _, appid := range appIds {
		_, money, err := rechargemod.BlocGetOnlineAmount(ctx, appid, start, end)
		if err != nil {
			log.Error("DaichongAmoutMethod BlocGetOnlineAmount ", log.E(err))
			return err
		}
		// 更新数据库
		doc := blocDailystatmod.BlocDailyStatDoc{
			OnlineAmount: &money,
		}
		err = blocDailystatmod.UpsertBlocDailyStat(ctx, start, appid, doc)
		if err != nil {
			log.Error("NewDeductionCountMethod UpsertBlocDailyStat ", log.E(err))
			return err
		}
	}
	return nil
}

// NewRechargeCountMethod 新增充值
func NewRechargeCountMethod(ctx context.Context, start time.Time, end time.Time, appIds []int32) error {

	for _, appid := range appIds {
		// 获取充值金额
		result, err := rechargemod.BlocTotalDistricRechargeAmount(ctx, appid, start, end)
		if err != nil {
			log.Error("NewRechargeCountMethod BlocTotalDistricRechargeAmount ", log.E(err))
			return err
		}
		totalRechargeCount := int64(len(result))
		amountMap := make(map[uint64]int64)
		userIds := make([]uint64, 0)
		for _, value := range result {
			userIds = append(userIds, value.UserId)
			if key, ok := amountMap[value.UserId]; ok {
				//存在
				amountMap[value.UserId] = value.PayMoney + key
			} else {
				amountMap[value.UserId] = value.PayMoney
			}
		}

		// 获取注册信息
		userList, err := registermod.TimeVisitUsersInfoByTime(ctx, appid, userIds, start, end)
		if err != nil {
			log.Error("NewRechargeCountMethod TotalDistricRechargeAmount ", log.E(err))
			return err
		}
		amount := int64(0)
		count := int64(0)
		for _, user := range userList {
			count += 1
			if key, ok := amountMap[user.UserId]; ok {
				amount += key
			}
		}

		// 更新数据库
		doc := blocDailystatmod.BlocDailyStatDoc{
			NewRechargeCount:   &count,
			NewRechargeAmount:  &amount,
			TotalRechargeCount: &totalRechargeCount,
		}
		err = blocDailystatmod.UpsertBlocDailyStat(ctx, start, appid, doc)
		if err != nil {
			log.Error("DeductionAmountMethod UpsertDailyStat ", log.E(err))
			return err
		}

	}
	return nil
}

// UserWithdrawAmountMethod 用户提现
func UserWithdrawAmountMethod(ctx context.Context, start time.Time, end time.Time, appIds []int32) error {
	for _, appid := range appIds {
		// 获取充值金额
		result, err := withdrawUserOrdermod.GetBlocUserWithdrawOrder(ctx, appid, start, end)
		if err != nil {
			log.Error("NewRechargeCountMethod BlocTotalDistricRechargeAmount ", log.E(err))
			return err
		}

		payMoney := int64(0)
		money := int64(0)
		for _, withdrawInfo := range result {
			payMoney += withdrawInfo.PayMoney
			money += withdrawInfo.Money
		}

		// 更新数据库
		doc := blocDailystatmod.BlocDailyStatDoc{
			UserWithDrawAmount:         &money,
			UserWithDrawPaymoneyAmount: &payMoney,
		}
		err = blocDailystatmod.UpsertBlocDailyStat(ctx, start, appid, doc)
		if err != nil {
			log.Error("DeductionAmountMethod UpsertDailyStat ", log.E(err))
			return err
		}
	}
	return nil
}