package model

import (
	"backend/util"
	"fmt"
	"sort"
	"strconv"
)

type Statistics struct {
	AppId      int   `json:"AppId"`
	ServerList []int `json:"ServerList"`
}

func (s *Statistics) StatisticsLevel() (interface{}, error) {
	AppConfig, err := util.GetAppConfig(s.AppId)
	if err != nil {
		return nil, err
	}
	res := make([]map[string]interface{}, 0)
	res1 := make(map[int]int)
	type dbres struct {
		Sum   int `db:"sum"`
		Level int `db:"level"`
	}
	for _, v := range s.ServerList {
		Db := util.MPool.GetMysqlDB(AppConfig.ServerName, AppConfig.MysqlName, v)
		if Db == nil {
			return nil, fmt.Errorf("failed to get mysql database")
		}
		var result []dbres
		err = Db.Select(&result, "select count(*) as sum , `level` from t_player_baseinfo group by `level`")
		if err != nil {
			return nil, fmt.Errorf("failed to get level count: %v", err)
		}
		for r := range result {
			res1[result[r].Level] += result[r].Sum
		}
		Db.Close()
	}
	keys := make([]int, 0, len(res1))
	for k := range res1 {
		keys = append(keys, k)
	}
	sort.Ints(keys)
	for _, k := range keys {
		res = append(res, map[string]interface{}{
			"Level": k,
			"Sum":   res1[k],
		})
	}
	return map[string]interface{}{
		"data":  res,
		"total": len(res),
	}, nil
}

func (s *Statistics) StatisticsInfo() (interface{}, error) {
	AppConfig, err := util.GetAppConfig(s.AppId)
	if err != nil {
		return nil, err
	}
	LogDb := util.MPool.GetTopicDB(AppConfig.Topic)
	defer LogDb.Close()
	if LogDb == nil {
		return nil, fmt.Errorf("failed to get mysql database")
	}
	StartTime := util.ZeroTimestampByTz(AppConfig.Tz)
	EndTime := StartTime + 86400
	var Register int
	var TotalRegistger int
	var Recharge float64
	var TotalRecharge float64
	var RechargeUser int
	err = LogDb.Get(&Register, "select count(*) as sum from log_login where Event = 'register' and Timestamp >= ? and Timestamp <= ?", StartTime, EndTime)
	if err != nil {
		return nil, fmt.Errorf("failed to get register count: %v", err)
	}

	err = LogDb.Get(&TotalRegistger, "select count(*) as sum from log_login where Event = 'register'")
	if err != nil {
		return nil, fmt.Errorf("failed to get total register count: %v", err)
	}

	err = LogDb.Get(&Recharge, "select IFNULL(SUM(Price), 0) as sum from log_order where Timestamp >= ? and Timestamp <= ?", StartTime, EndTime)
	if err != nil {
		return nil, fmt.Errorf("failed to get recharge count: %v", err)
	}

	err = LogDb.Get(&TotalRecharge, "select IFNULL(SUM(Price), 0) as sum from log_order")
	if err != nil {
		return nil, fmt.Errorf("failed to get total recharge count: %v", err)
	}
	// 充值人数统计
	err = LogDb.Get(&RechargeUser, "select count(distinct Uid) as sum from log_order where Timestamp >= ? and Timestamp <= ?", StartTime, EndTime)
	if err != nil {
		return nil, fmt.Errorf("failed to get recharge count: %v", err)
	}

	var TotalRechargeUser int
	// 充值总人数统计
	err = LogDb.Get(&TotalRechargeUser, "select count(distinct Uid) as sum from log_order")
	if err != nil {
		return nil, fmt.Errorf("failed to get total recharge count: %v", err)
	}

	type RemainCount struct {
		Register     int `db:"register"`
		SecondRemain int `db:"SecondRemain"`
	}
	var rc RemainCount
	err = LogDb.Get(&rc, "select sum(`Register`) as register, sum(`SecondRemain`) as SecondRemain from remain")
	if err != nil {
		return nil, fmt.Errorf("failed to get recharge count: %v", err)
	}

	rechargeFloat, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", Recharge), 64)
	totalRechargeFloat, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", TotalRecharge), 64)
	return map[string]interface{}{
		"register":          Register,
		"totalRegister":     TotalRegistger,
		"recharge":          rechargeFloat,
		"totalRecharge":     totalRechargeFloat,
		"rechargeUser":      RechargeUser,
		"totalRechargeUser": TotalRechargeUser,
		"remain":            util.FloatDecimals(100*float64(rc.SecondRemain)/float64(rc.Register), 2),
	}, nil
}

func (s *Statistics) StatisticsHeat() (interface{}, error) {
	AppConfig, err := util.GetAppConfig(s.AppId)
	if err != nil {
		return nil, err
	}
	LogDb := util.MPool.GetTopicDB(AppConfig.Topic)
	defer LogDb.Close()
	if LogDb == nil {
		return nil, fmt.Errorf("failed to get mysql database")
	}
	now := util.Now()
	value := make([]int, 0, 24)
	value2 := make([]int, 0, 24)
	key := make([]string, 0, 24)
	for i := 0; i < 24; i++ {
		key = append(key, fmt.Sprintf("%02d:00", i))
	}
	type r struct {
		Sum1 int `db:"sum1"`
		Sum2 int `db:"sum2"`
	}
	var result r
	for i := 0; i < 24; i++ {
		err := LogDb.Get(&result, "select count(*) as sum1, count(distinct Uid) as sum2 from log_event where Timestamp >= ? and Timestamp <= ?", now-int64(i)*3600-3600, now-int64(i)*3600)
		if err != nil {
			return nil, fmt.Errorf("failed to get heat count: %v", err)
		}

		value = append(value, result.Sum1)
		value2 = append(value2, result.Sum2)
		key[i] = fmt.Sprintf("%02d:00", util.GetHour(now-int64(i)*3600, AppConfig.Tz))
	}
	if len(value) < 2 {
		return value, nil
	}
	// 反转key和value
	for i, j := 0, len(value)-1; i < j; i, j = i+1, j-1 {
		key[i], key[j] = key[j], key[i]
		value2[i], value2[j] = value2[j], value2[i]
		value[i], value[j] = value[j], value[i]
	}

	return map[string]interface{}{
		"key":    key,
		"value":  value,
		"value2": value2,
	}, nil
}