package main

import (
	"fmt"
	"log"
	"time"

	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

type UserItemCards struct {
	ID             int64     `gorm:"column:id"`
	UserID         int64     `gorm:"column:user_id"`
	CardID         int64     `gorm:"column:card_id"`
	Status         int32     `gorm:"column:status"`
	ValidStart     time.Time `gorm:"column:valid_start"`
	ValidEnd       time.Time `gorm:"column:valid_end"`
	UsedAt         time.Time `gorm:"column:used_at"`
	UsedActivityID int64     `gorm:"column:used_activity_id"`
	UsedIssueID    int64     `gorm:"column:used_issue_id"`
}

func (UserItemCards) TableName() string { return "user_item_cards" }

type SystemItemCards struct {
	ID                    int64  `gorm:"column:id"`
	Name                  string `gorm:"column:name"`
	EffectType            int32  `gorm:"column:effect_type"`
	RewardMultiplierX1000 int32  `gorm:"column:reward_multiplier_x1000"`
	BoostRateX1000        int32  `gorm:"column:boost_rate_x1000"`
}

func (SystemItemCards) TableName() string { return "system_item_cards" }

type ActivityDrawLogs struct {
	ID        int64     `gorm:"column:id"`
	UserID    int64     `gorm:"column:user_id"`
	OrderID   int64     `gorm:"column:order_id"`
	IsWinner  int32     `gorm:"column:is_winner"`
	RewardID  int64     `gorm:"column:reward_id"`
	CreatedAt time.Time `gorm:"column:created_at"`
}

func (ActivityDrawLogs) TableName() string { return "activity_draw_logs" }

type Activities struct {
	ID   int64  `gorm:"column:id"`
	Name string `gorm:"column:name"`
	Type int32  `gorm:"column:type"` // 1: Ichiban, 2: Time-limited, 3: Matching?
}

func (Activities) TableName() string { return "activities" }

func main() {
	dsn := "root:bindbox2025kdy@tcp(150.158.78.154:3306)/dev_game?charset=utf8mb4&parseTime=True&loc=Local"
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		log.Fatalf("failed to connect database: %v", err)
	}

	var cards []UserItemCards
	result := db.Where("user_id = ? AND used_activity_id = ?", 9090, 94).Find(&cards)
	if result.Error != nil {
		log.Fatalf("failed to query user cards: %v", result.Error)
	}

	fmt.Printf("Found %d user item cards for user 9090, activity 94:\n", len(cards))
	for _, c := range cards {
		fmt.Printf("- ID: %d, CardID: %d, Status: %d, UsedAt: %v\n", c.ID, c.CardID, c.Status, c.UsedAt)

		var sysCard SystemItemCards
		if err := db.First(&sysCard, c.CardID).Error; err == nil {
			fmt.Printf("  -> SystemCard: %s, EffectType: %d, Multiplier: %d, BoostRate: %d\n",
				sysCard.Name, sysCard.EffectType, sysCard.RewardMultiplierX1000, sysCard.BoostRateX1000)
		} else {
			fmt.Printf("  -> SystemCard lookup failed: %v\n", err)
		}
	}

	fmt.Println("\nChecking Activity Draw Logs:")
	var drawLogs []ActivityDrawLogs
	startTime := time.Date(2026, 1, 21, 3, 0, 0, 0, time.Local)
	endTime := time.Date(2026, 1, 21, 3, 5, 0, 0, time.Local)

	db.Where("user_id = ? AND created_at BETWEEN ? AND ?", 9090, startTime, endTime).Find(&drawLogs)
	for _, log := range drawLogs {
		fmt.Printf("- DrawLogID: %d, OrderID: %d, IsWinner: %d, RewardID: %d, Created: %v\n",
			log.ID, log.OrderID, log.IsWinner, log.RewardID, log.CreatedAt)

		var remark string
		db.Table("orders").Select("remark").Where("id = ?", log.OrderID).Scan(&remark)
		fmt.Printf("  -> Order Remark: %s\n", remark)
	}

	var act Activities
	if err := db.First(&act, 94).Error; err == nil {
		fmt.Printf("\nActivity 94: Name=%s, Type=%d\n", act.Name, act.Type)
	} else {
		fmt.Printf("\nActivity 94 lookup failed: %v\n", err)
	}
}