package walletser

import (
	"fmt"
	"strconv"
	"sync"
	"time"

	"91porn-server/common"
	"91porn-server/common/log"
	"91porn-server/common/stderr"
	"91porn-server/common/timeutil"
	"91porn-server/models/v/proxymod"
	"91porn-server/models/v/txnmod"
	"91porn-server/models/v/usermod"
	"91porn-server/models/v/walletmod"

	"github.com/shopspring/decimal"
)

func GetBills(uid uint64, t int64) (data []txnmod.BillsRes, hasNext bool, timeline int64, err error) {
	data = make([]txnmod.BillsRes, 0)
	if t == 0 {
		trans, queryErr := txnmod.LastLedgerTime(uid, time.Now())
		if queryErr != nil {
			return nil, false, 0, queryErr
		}
		if trans.ID.IsZero() {
			return
		}
		t = trans.CreatedAt.Unix()
	}
	start, end := timeutil.EarlyLastMonth(time.Unix(t, 0))
	var navErr error
	var wg sync.WaitGroup
	wg.Add(2)
	common.Go(func() {
		defer wg.Done()
		br := txnmod.BillsRes{
			Month: start.Format("2006-01"),
		}
		br.List, err = txnmod.FindLedgerByTime(uid, start, end)
		if err != nil {
			return
		}
		if len(br.List) > 0 {
			for _, v := range br.List {
				switch v.TranTypeInt {
				case int64(txnmod.WithdrawTransfer):
					br.Withdraw += -v.Amount
					br.WithdrawStr = strconv.Itoa(int(br.Withdraw))
					if br.WithdrawStr == "" {
						br.WithdrawStr = "0"
					}
				case int64(txnmod.WorksIncome), int64(txnmod.ProxyIncome):
					br.Income += v.Amount
					if br.IncomeStr == "" {
						br.IncomeStr = "0"
					}
					incomeDeci, _ := decimal.NewFromString(br.IncomeStr)
					actualIncomeDeci := decimal.NewFromFloat(v.ActualAmount)
					br.IncomeStr = incomeDeci.Add(actualIncomeDeci).String()
				}
			}
		}
		if len(br.List) > 0 {
			data = append(data, br)
		}
	})
	common.Go(func() {
		defer wg.Done()
		trans, queryErr := txnmod.LastLedgerTime(uid, start)
		if queryErr != nil {
			navErr = queryErr
			return
		}
		if !trans.ID.IsZero() {
			timeline = trans.CreatedAt.Unix()
			hasNext = true
		}

	})
	wg.Wait()
	if err == nil {
		err = navErr
	}
	return
}

type rechargeLevel struct {
	Min   int
	Max   int
	Level int
}

var rchgLevel = []rechargeLevel{
	{Min: 0, Max: 4900, Level: 0},
	{Min: 5000, Max: 9900, Level: 1},
	{Min: 10000, Max: 19900, Level: 2},
	{Min: 20000, Max: 29900, Level: 3},
	{Min: 30000, Max: 49900, Level: 4},
	{Min: 50000, Max: 99900, Level: 5},
	{Min: 100000, Max: 199900, Level: 6},
	{Min: 200000, Max: 499900, Level: 7},
	{Min: 500000, Max: 1000000, Level: 8},
}

func calRchgLevel(amount int) (level int, cur int, limit int) {
	l := len(rchgLevel)
	if l == 0 {
		return
	}
	min := rchgLevel[0].Min
	max := rchgLevel[l-1].Max
	if amount < min {
		return rchgLevel[0].Level, 0, (rchgLevel[0].Max - rchgLevel[0].Min)
	}
	if amount > max {
		return rchgLevel[l-1].Level, (rchgLevel[l-1].Max - rchgLevel[l-1].Min), (rchgLevel[l-1].Max - rchgLevel[l-1].Min)
	}
	for _, v := range rchgLevel {
		if amount >= v.Min && amount <= v.Max {
			return v.Level, (amount - v.Min), (v.Max - v.Min)
		}
	}
	return
}

// GetRchgLevel 获取用户充值等级
func GetRchgLevel(uid uint64) (usermod.RechargeLevel, error) {
	wallet, err := walletmod.GetWallet(uid)
	if err != nil {
		return usermod.RechargeLevel{}, err
	}
	level, cur, limit := calRchgLevel(int(wallet.Consumption))
	info := usermod.RechargeLevel{
		Level:   level,
		Current: cur / 10,
		Limit:   limit / 10,
	}
	return info, err
}

// GetUidsRchgLevel 获取用户充值等级
func GetUidsRchgLevel(uids []uint64) (map[uint64]usermod.RechargeLevel, error) {
	mInfo := make(map[uint64]usermod.RechargeLevel)
	mWallet, err := walletmod.GetWalletMap(uids)
	if err != nil {
		return mInfo, err
	}
	for _, v := range mWallet {
		level, cur, limit := calRchgLevel(int(v.Consumption))
		info := usermod.RechargeLevel{
			Level:   level,
			Current: cur / 10,
			Limit:   limit / 10,
		}
		mInfo[v.UID] = info
	}
	return mInfo, err
}

func GetIncome(uid uint64) (interface{}, error) {
	var income string
	var vidIncomeToday float64
	var vidIncomeMonth float64
	var vidTotalIncome float64
	var proxyIncomeToday float64
	var proxyIncomeMonth float64
	var InviteeTotalCount int64
	var proxyTotalIncome float64
	var proxyTotalPer int64
	var InviteedTodayCount int64
	var InviteedMonthCount int64
	var proxyPerMonth int64
	var proxyPerToday int64
	var data []txnmod.AgentIncomeRes
	now := time.Now()
	startM, endM := timeutil.EarlyLastMonth(now)
	startD, endD := timeutil.EarlyLastDay(now)
	var wg sync.WaitGroup
	wg.Add(8)
	common.Go(func() { //1
		defer wg.Done()
		w, _ := walletmod.GetWallet(uid)
		if w == nil {
			return
		}
		income = decimal.NewFromInt(w.Income).Add(decimal.NewFromFloat(w.IncomePot)).String()
		vidTotalIncome = w.VidIncome
		proxyTotalIncome = w.ProxyIncome
		proxyTotalPer = w.Performance
	})
	common.Go(func() { //2
		defer wg.Done()
		InviteeTotalCount, _ = proxymod.NextProxyCount(uid, time.Unix(0, 0), now)
	})
	common.Go(func() { //3
		defer wg.Done()
		InviteedMonthCount, _ = proxymod.NextProxyCount(uid, startM, endM)
	})
	common.Go(func() { //4
		defer wg.Done()
		InviteedTodayCount, _ = proxymod.NextProxyCount(uid, startD, endD)

	})
	common.Go(func() { //5
		defer wg.Done()
		vidIncomeToday, _, _ = txnmod.GetIncomeByType(uid, txnmod.WorksIncome, startD, endD)
	})
	common.Go(func() { //6
		defer wg.Done()
		vidIncomeMonth, _, _ = txnmod.GetIncomeByType(uid, txnmod.WorksIncome, startM, endM)

	})
	common.Go(func() { //7
		defer wg.Done()
		proxyIncomeMonth, proxyPerMonth, _ = txnmod.GetIncomeByType(uid, txnmod.ProxyIncome, startM, endM)
	})
	common.Go(func() { //8
		defer wg.Done()
		data, _ = txnmod.GetProxyIncomeForToday(uid, startD, endD)
	})
	wg.Wait()
	m := make(map[string]interface{})
	m["income"] = income
	m["vidIncomeToday"] = strconv.FormatFloat(vidIncomeToday, 'f', 2, 64)
	m["vidIncomeMonth"] = strconv.FormatFloat(vidIncomeMonth, 'f', 2, 64)
	m["vidIncomeTotal"] = strconv.FormatFloat(vidTotalIncome, 'f', 2, 64)
	m["proxyIncomeTotal"] = strconv.FormatFloat(proxyTotalIncome, 'f', 2, 64)
	m["proxyPer"] = strconv.FormatInt(proxyTotalPer, 10)
	m["inviteeCountTotal"] = strconv.FormatInt(InviteeTotalCount, 10)
	m["proxyIncomeLv1"] = "0"
	m["proxyIncomeLv2"] = "0"
	m["proxyIncomeLv3"] = "0"
	m["proxyIncomeLv4"] = "0"
	m["proxyIncomeLv5"] = "0"
	for _, v := range data {
		proxyIncomeToday += v.TotalMoney
		proxyPerToday += v.TotalPerformance
		m["proxyIncomeLv"+strconv.Itoa(v.AgentLevel)] = strconv.FormatFloat(v.TotalMoney, 'f', 2, 64)
	}
	m["proxyPerMonth"] = strconv.FormatInt(proxyPerMonth, 10)
	m["proxyIncomeMonth"] = strconv.FormatFloat(proxyIncomeMonth, 'f', 2, 64)
	m["inviteeCountMonth"] = strconv.FormatInt(InviteedMonthCount, 10)
	m["proxyPerToday"] = strconv.FormatInt(proxyPerToday, 10)
	m["proxyIncomeToday"] = strconv.FormatFloat(proxyIncomeToday, 'f', 2, 64)
	m["inviteeCountToday"] = strconv.FormatInt(InviteedTodayCount, 10)
	return m, nil
}

func GetBills1(uid uint64, year int, month int, pageNumber, pageSize uint64) (res txnmod.Bills1Res, err error) {
	start, end := timeutil.GetTimeByMonthAndYear(month, year)
	if pageNumber > 1 {
		res.List, res.HasNext, err = txnmod.Ibills(uid, pageNumber, pageSize, start, end)
		return
	}
	var incomeErr, expenditureErr, listErr, navigationErr error
	var wg sync.WaitGroup
	wg.Add(4)
	common.Go(func() { //1
		defer wg.Done()
		i, queryErr := txnmod.Income(uid, start, end)
		incomeErr = queryErr
		res.Income = strconv.FormatFloat(i, 'f', 2, 64)
	})
	common.Go(func() { //2
		defer wg.Done()
		e, queryErr := txnmod.Expenditure(uid, start, end)
		expenditureErr = queryErr
		res.Expenditure = strconv.FormatFloat(e, 'f', 2, 64)
	})
	common.Go(func() { //3
		defer wg.Done()
		start, end := timeutil.GetTimeByMonthAndYear(month, year)
		res.List, res.HasNext, listErr = txnmod.Ibills(uid, pageNumber, pageSize, start, end)
	})
	common.Go(func() { //4
		defer wg.Done()
		t, queryErr := txnmod.LastLedgerTime(uid, start)
		navigationErr = queryErr
		if !t.ID.IsZero() {
			res.HasNextMonth = true
			res.Year = t.CreatedAt.Year()
			res.Month = int(t.CreatedAt.Month())
		}
	})
	wg.Wait()
	for _, queryErr := range []error{incomeErr, expenditureErr, listErr, navigationErr} {
		if queryErr != nil {
			return txnmod.Bills1Res{}, queryErr
		}
	}
	if len(res.List) > 0 {
		for i, tlog := range res.List {
			if tlog.TranTypeInt == int64(txnmod.GoldCouplePayVID) {
				res.List[i].ActualAmount = 0
				res.List[i].Amount = 0
			}
		}
	}
	return
}

// FruitCoinBill 果币账单
func FruitCoinBill(uid uint64, in *FruitCoinBillCond) (interface{}, stderr.Code) {
	var data = map[string]interface{}{
		"list": []interface{}{},
	}
	list, err := txnmod.QueryAll(in.Query(uid), in.Options())
	if err != nil {
		log.Error(fmt.Sprintf("查询果币账单列表异常[%v]", err))
		return data, stderr.ErrDbQueryError
	}
	data["list"] = list
	return data, stderr.Success
}