package model

import (
	"backend/Type"
	util "backend/util"
	"fmt"
)

type Log struct {
	Uid         int    `json:"Id"`
	PageSize    int    `json:"PageSize"`
	CurrentPage int    `json:"CurrentPage"`
	AppId       int    `json:"AppId"`
	Month       string `json:"Month"`
	EventParam  string `json:"Event"`
	StartTime   int64  `json:"StartTime"`
	EndTime     int64  `json:"EndTime"`
	ItemId      int    `json:"ItemId"`
}

type ResAsset struct {
	Total int               `json:"total"`
	Data  []*Type.AssetData `json:"data"`
	Sum   int               `json:"sum"`  // 总和
	NSum  int               `json:"nsum"` // 负数和
	PSum  int               `json:"psum"` // 正数和
}

type ResEvent struct {
	Total int               `json:"total"`
	Data  []*Type.EventData `json:"data"`
}

type ResLoginCount struct {
	Month string                  `json:"month"`
	Total int                     `json:"total"`
	Data  []*Type.LoginDailyCount `json:"data"`
}

type ResOrder struct {
	Total int      `json:"total"`
	Data  []*Order `json:"data"`
}

type Order struct {
	Id                int     `db:"id"`
	Uid               int     `db:"Uid"`
	AppId             int     `db:"AppId"`
	ServerId          int     `db:"ServerId"`
	OrderId           string  `db:"OrderId"`
	Price             float64 `db:"Price"`
	PayChannelOrderId string  `db:"PayChannelOrderId"`
	ProductId         int     `db:"ProductId"`
	CreateTime        int     `db:"CreateTime"`
	PayTime           int     `db:"PayTime"`
	PayType           int     `db:"PayType"`
	Param             string  `db:"PayChannelExtra"`
	PayStatus         int     `db:"PayStatus"`
	CreateTimeStr     string
	PayTimeStr        string
	ReissueAuditId    int    `json:"ReissueAuditId"`
	ReissueStatus     int    `json:"ReissueStatus"`
	ReissueReason     string `json:"ReissueReason"`
	ReissueApplicant  string `json:"ReissueApplicant"`
	ReissueReviewer   string `json:"ReissueReviewer"`
	ReissueReviewTime int64  `json:"ReissueReviewTime"`
	ReissueRemark     string `json:"ReissueRemark"`
	ReissueThirdOrder string `json:"ReissueThirdOrder"`
}

type ResAssetDetail struct {
	Uid         int    `json:"Uid"`
	ChangeType  string `json:"change_type"`
	ChangeNum   int    `json:"change_num"`
	ChangeAfter int    `json:"change_after"`
	ItemId      int    `json:"item_id"`
	Timestamp   int    `json:"timestamp"`
}

type Event struct {
	Id        int    `db:"id"`
	Uid       int    `db:"Uid"`
	AppId     int    `db:"AppId"`
	ServerId  int    `db:"ServerId"`
	Event     string `db:"Event"`
	Label     string
	Param     string `db:"Param"`
	Timestamp int    `db:"Timestamp"`
}

func (m *Log) Asset() (*ResAsset, error) {
	resutl, total, err := util.SearchAssetByUid(m.AppId, m.Uid, (m.CurrentPage-1)*m.PageSize, m.CurrentPage*m.PageSize, m.StartTime, m.EndTime, m.ItemId, m.EventParam)
	if err != nil {
		return nil, err
	}
	Sum := 0
	NSum := 0
	PSum := 0
	for _, asset := range resutl {
		Sum += asset.ChangeNum
		if asset.ChangeType == "gain" {
			PSum += asset.ChangeNum
		} else {
			NSum += asset.ChangeNum
		}
		asset.ItemName = util.GetItemName(asset.ItemId)

	}
	return &ResAsset{
		Total: int(total),
		Data:  resutl,
		Sum:   Sum,
		NSum:  NSum,
		PSum:  PSum,
	}, nil
}

func (m *Log) Event() (*ResEvent, error) {
	event, total, err := util.SearchEventByUid(m.AppId, m.Uid, (m.CurrentPage-1)*m.PageSize, m.PageSize, m.StartTime, m.EndTime, m.EventParam)
	if err != nil {
		return nil, err
	}
	return &ResEvent{
		Total: int(total),
		Data:  event,
	}, nil
}

func (m *Log) LoginCountByMonth() (*ResLoginCount, error) {
	data, total, err := util.SearchLoginCountByUidMonth(m.AppId, m.Uid, m.Month)
	if err != nil {
		return nil, err
	}
	return &ResLoginCount{
		Month: m.Month,
		Total: int(total),
		Data:  data,
	}, nil
}

func (m *Log) Order() (*ResOrder, error) {
	m.AppId = m.Uid / 100000000
	AppConfig, err := util.GetAppConfig(m.AppId)
	if err != nil {
		return nil, err
	}
	Db := util.MPool.GetMysqlDB(AppConfig, 1)
	defer Db.Close()
	if Db == nil {
		return nil, fmt.Errorf("failed to get mysql database")
	}
	assets := []*Order{}
	err = Db.Select(&assets, "SELECT `id`, `Uid`, `ProductId`, `Price`, `PayTime`, `PayStatus`, `PayChannelOrderId`, `OrderId`, `PayChannelExtra` FROM t_player_charge WHERE Uid = ?  ORDER BY PayTime DESC LIMIT ?, ?", m.Uid, (m.CurrentPage-1)*m.PageSize, m.PageSize)

	if err != nil {
		return nil, fmt.Errorf("failed to get asset list: %v", err)
	}
	reissueMap, err := loadOrderReissueAuditMap(m.Uid)
	if err != nil {
		return nil, err
	}
	var total int
	err = Db.QueryRow("SELECT COUNT(*) FROM t_player_charge WHERE Uid = ?", m.Uid).Scan(&total)
	for _, asset := range assets {
		asset.AppId = m.AppId
		asset.ServerId = 1
		asset.CreateTimeStr = util.TimestampToDateTime(int64(asset.CreateTime), AppConfig.Tz)
		asset.PayTimeStr = util.TimestampToDateTime(int64(asset.PayTime), AppConfig.Tz)
		if auditOrder, ok := reissueMap[asset.OrderId]; ok {
			asset.ReissueAuditId = auditOrder.AuditId
			asset.ReissueStatus = auditOrder.Status
			asset.ReissueReason = auditOrder.Reason
			asset.ReissueApplicant = auditOrder.Applicant
			asset.ReissueReviewer = auditOrder.Reviewer
			asset.ReissueReviewTime = auditOrder.ReviewTime
			asset.ReissueRemark = auditOrder.ReviewRemark
			asset.ReissueThirdOrder = auditOrder.ThirdPartyOrderId
		}
	}
	if err != nil {
		return nil, fmt.Errorf("failed to get asset count: %v", err)
	}
	return &ResOrder{
		Total: total,
		Data:  assets,
	}, nil
}

type ResHeat struct {
	Date  string `json:"date"`
	Value int    `json:"value"`
}

func (m *Log) Heat() ([]*ResHeat, error) {
	m.AppId = m.Uid / 100000000
	AppConfig, err := util.GetAppConfig(m.AppId)
	if err != nil {
		return nil, err
	}
	Db := util.MPool.GetTopicDB(AppConfig.Topic)
	defer Db.Close()
	if Db == nil {
		return nil, fmt.Errorf("failed to get mysql database")
	}
	assets := []*ResHeat{}
	year := util.Year()
	startDate := fmt.Sprintf("%d-01-01T00:00:00Z", year)
	endDate := fmt.Sprintf("%d-12-31T23:59:59Z", year)
	startTimestamp, err := util.ParseTimeToTimestamp(startDate, AppConfig.Tz)
	if err != nil {
		return nil, err
	}
	endTimestamp, err := util.ParseTimeToTimestamp(endDate, AppConfig.Tz)
	if err != nil {
		return nil, err
	}

	// 使用一次查询获取整年的数据，然后在Go中按日期分组
	type LogRecord struct {
		Timestamp int64 `db:"Timestamp"`
	}

	var records []LogRecord
	simpleSQL := "SELECT Timestamp FROM log_event WHERE Uid= ? And Timestamp >= ? AND Timestamp <= ? AND Timestamp IS NOT NULL AND Timestamp > 0 "
	err = Db.Select(&records, simpleSQL, m.Uid, startTimestamp, endTimestamp)
	if err != nil {
		return nil, fmt.Errorf("failed to get log records: %v", err)
	}

	// 在Go中按日期分组统计
	dateCountMap := make(map[string]int)
	for _, record := range records {
		date := util.TimestampToDate(record.Timestamp, AppConfig.Tz)
		if date != "" {
			dateCountMap[date]++
		}
	}

	// 生成完整的日期范围，包括没有数据的日期
	for i := startTimestamp; i <= endTimestamp; i += 24 * 3600 {
		date := util.TimestampToDate(i, AppConfig.Tz)
		if date == "" {
			continue // 跳过无效的日期
		}

		count := dateCountMap[date] // 如果没有数据，默认为0

		assets = append(assets, &ResHeat{
			Date:  date,
			Value: count,
		})
	}

	return assets, nil
}