package prize_grant_activity

import (
	"bindbox-game/internal/pkg/logger"
	"bindbox-game/internal/repository/mysql"
	"bindbox-game/internal/repository/mysql/dao"
	"bindbox-game/internal/repository/mysql/model"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"math/rand"
	"strings"
	"time"

	"gorm.io/gorm"
	"gorm.io/gorm/clause"
)

type Service interface {
	CreateActivity(ctx context.Context, req SaveActivityRequest) (*Activity, error)
	UpdateActivity(ctx context.Context, id int64, req SaveActivityRequest) error
	DeleteActivity(ctx context.Context, id int64) error
	GetActivity(ctx context.Context, id int64) (*ActivityDetail, error)
	ListActivities(ctx context.Context, req ListActivitiesRequest) (*ListActivitiesResponse, error)
	GetPendingActivity(ctx context.Context, userID int64) (*PendingActivityResponse, error)
	ClaimActivity(ctx context.Context, activityID int64, userID int64) (*ClaimResponse, error)
	MarkUsersProcessed(ctx context.Context, activityID int64, adminID int64, userIDs []int64) error
	MarkAllUsersProcessed(ctx context.Context, activityID int64, adminID int64) (int64, error)
	DeleteUserRecord(ctx context.Context, activityID int64, recordID int64) error
	GetCostSummary(ctx context.Context) (*CostSummary, error)
	ListUserRecords(ctx context.Context, activityID int64, status string, keyword string, page int, pageSize int) (map[string]any, error)
}

type service struct {
	logger  logger.CustomLogger
	repo    mysql.Repo
	writeDB *dao.Query
	readDB  *dao.Query
}

func New(log logger.CustomLogger, repo mysql.Repo) Service {
	return &service{
		logger:  log,
		repo:    repo,
		writeDB: dao.Use(repo.GetDbW()),
		readDB:  dao.Use(repo.GetDbR()),
	}
}

func (s *service) CreateActivity(ctx context.Context, req SaveActivityRequest) (*Activity, error) {
	if err := validateSaveRequest(req); err != nil {
		return nil, err
	}
	item := &Activity{Reason: strings.TrimSpace(req.Reason), Status: normalizeStatus(req.Status)}
	err := s.repo.GetDbW().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		if err := tx.Create(item).Error; err != nil {
			return err
		}
		return s.replaceRewards(ctx, tx, item.ID, req.Rewards)
	})
	return item, err
}

func (s *service) UpdateActivity(ctx context.Context, id int64, req SaveActivityRequest) error {
	if id <= 0 {
		return errors.New("活动ID无效")
	}
	if err := validateSaveRequest(req); err != nil {
		return err
	}
	return s.repo.GetDbW().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		if err := tx.Model(&Activity{}).Where("id = ?", id).Updates(map[string]any{
			"reason": strings.TrimSpace(req.Reason),
			"status": normalizeStatus(req.Status),
		}).Error; err != nil {
			return err
		}
		return s.replaceRewards(ctx, tx, id, req.Rewards)
	})
}

func (s *service) DeleteActivity(ctx context.Context, id int64) error {
	if id <= 0 {
		return errors.New("活动ID无效")
	}
	return s.repo.GetDbW().WithContext(ctx).Where("id = ?", id).Delete(&Activity{}).Error
}

func (s *service) ListActivities(ctx context.Context, req ListActivitiesRequest) (*ListActivitiesResponse, error) {
	if req.Page <= 0 {
		req.Page = 1
	}
	if req.PageSize <= 0 {
		req.PageSize = 20
	}
	if req.PageSize > 100 {
		req.PageSize = 100
	}
	db := s.repo.GetDbR().WithContext(ctx).Model(&Activity{})
	if strings.TrimSpace(req.Reason) != "" {
		db = db.Where("reason LIKE ?", "%"+strings.TrimSpace(req.Reason)+"%")
	}
	if strings.TrimSpace(req.Status) != "" {
		db = db.Where("status = ?", strings.TrimSpace(req.Status))
	}
	var total int64
	if err := db.Count(&total).Error; err != nil {
		return nil, err
	}
	var rows []Activity
	if err := db.Order("id DESC").Offset((req.Page-1)*req.PageSize).Limit(req.PageSize).Find(&rows).Error; err != nil {
		return nil, err
	}
	list := make([]ActivityListItem, 0, len(rows))
	for _, row := range rows {
		item := ActivityListItem{Activity: row}
		s.repo.GetDbR().WithContext(ctx).Table("prize_grant_activity_rewards").Where("activity_id = ?", row.ID).Count(&item.RewardCount)
		s.repo.GetDbR().WithContext(ctx).Table("prize_grant_activity_user_records").Where("activity_id = ? AND status = ?", row.ID, RecordStatusClaimed).Count(&item.ClaimedCount)
		s.repo.GetDbR().WithContext(ctx).Table("prize_grant_activity_user_records").Where("activity_id = ? AND status = ?", row.ID, RecordStatusProcessed).Count(&item.ProcessedCount)
		cost, err := s.calculateClaimedCost(ctx, row.ID)
		if err != nil {
			return nil, err
		}
		item.CostCents = cost
		list = append(list, item)
	}
	return &ListActivitiesResponse{Page: req.Page, PageSize: req.PageSize, Total: total, List: list}, nil
}

func (s *service) GetActivity(ctx context.Context, id int64) (*ActivityDetail, error) {
	var item Activity
	if err := s.repo.GetDbR().WithContext(ctx).Where("id = ?", id).First(&item).Error; err != nil {
		return nil, err
	}
	rewards, err := s.loadRewardViews(ctx, id)
	if err != nil {
		return nil, err
	}
	detail := &ActivityDetail{Activity: item, Rewards: rewards}
	s.repo.GetDbR().WithContext(ctx).Table("prize_grant_activity_user_records").Where("activity_id = ? AND status = ?", id, RecordStatusClaimed).Count(&detail.ClaimedCount)
	s.repo.GetDbR().WithContext(ctx).Table("prize_grant_activity_user_records").Where("activity_id = ? AND status = ?", id, RecordStatusProcessed).Count(&detail.ProcessedCount)
	var totalUsers int64
	s.repo.GetDbR().WithContext(ctx).Model(&model.Users{}).Count(&totalUsers)
	detail.PendingCount = totalUsers - detail.ClaimedCount - detail.ProcessedCount
	if detail.PendingCount < 0 {
		detail.PendingCount = 0
	}
	cost, err := s.calculateClaimedCost(ctx, id)
	if err != nil {
		return nil, err
	}
	detail.CostCents = cost
	return detail, nil
}

func (s *service) GetPendingActivity(ctx context.Context, userID int64) (*PendingActivityResponse, error) {
	if userID <= 0 {
		return &PendingActivityResponse{HasPending: false}, nil
	}
	var item Activity
	if err := s.repo.GetDbR().WithContext(ctx).
		Where("status = ?", "active").
		Where("NOT EXISTS (SELECT 1 FROM prize_grant_activity_user_records r WHERE r.activity_id = prize_grant_activities.id AND r.user_id = ?)", userID).
		Order("id DESC").
		First(&item).Error; err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return &PendingActivityResponse{HasPending: false}, nil
		}
		return nil, err
	}
	rewards, err := s.loadRewardViews(ctx, item.ID)
	if err != nil {
		return nil, err
	}
	return &PendingActivityResponse{HasPending: true, Activity: &PendingActivity{ID: item.ID, Reason: item.Reason, Rewards: rewards}}, nil
}

func (s *service) ClaimActivity(ctx context.Context, activityID int64, userID int64) (*ClaimResponse, error) {
	if activityID <= 0 || userID <= 0 {
		return nil, errors.New("参数无效")
	}
	var recordID int64
	err := s.repo.GetDbW().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		var item Activity
		if err := tx.WithContext(ctx).Where("id = ? AND status = ?", activityID, "active").First(&item).Error; err != nil {
			return err
		}
		var existing UserRecord
		err := tx.WithContext(ctx).Where("activity_id = ? AND user_id = ?", activityID, userID).First(&existing).Error
		if err == nil {
			return errors.New("该活动已处理")
		}
		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
			return err
		}
		var rewards []Reward
		if err := tx.WithContext(ctx).Where("activity_id = ?", activityID).Order("sort ASC, id ASC").Find(&rewards).Error; err != nil {
			return err
		}
		if len(rewards) == 0 {
			return errors.New("活动未配置奖品")
		}
		for _, reward := range rewards {
			for i := int32(0); i < reward.QuantityPerClaim; i++ {
				if err := s.grantReward(ctx, tx, activityID, userID, reward); err != nil {
					return err
				}
			}
		}
		now := time.Now()
		record := &UserRecord{ActivityID: activityID, UserID: userID, Status: RecordStatusClaimed, ClaimedAt: &now, OperatorAdminID: 0}
		if err := tx.WithContext(ctx).Create(record).Error; err != nil {
			return err
		}
		recordID = record.ID
		return nil
	})
	if err != nil {
		return nil, err
	}
	return &ClaimResponse{ActivityID: activityID, RecordID: recordID, Status: RecordStatusClaimed}, nil
}

func (s *service) MarkUsersProcessed(ctx context.Context, activityID int64, adminID int64, userIDs []int64) error {
	if activityID <= 0 {
		return errors.New("活动ID无效")
	}
	if len(userIDs) == 0 {
		return errors.New("用户不能为空")
	}
	now := time.Now()
	return s.repo.GetDbW().WithContext(ctx).Transaction(func(tx *gorm.DB) error {
		for _, userID := range userIDs {
			if userID <= 0 {
				continue
			}
			record := &UserRecord{ActivityID: activityID, UserID: userID, Status: RecordStatusProcessed, ProcessedAt: &now, OperatorAdminID: adminID}
			if err := tx.WithContext(ctx).Clauses(clauseOnConflictUpdateProcessed()).Create(record).Error; err != nil {
				return err
			}
		}
		return nil
	})
}

func (s *service) MarkAllUsersProcessed(ctx context.Context, activityID int64, adminID int64) (int64, error) {
	var users []model.Users
	if err := s.repo.GetDbR().WithContext(ctx).Find(&users).Error; err != nil {
		return 0, err
	}
	ids := make([]int64, 0, len(users))
	for _, user := range users {
		ids = append(ids, user.ID)
	}
	if err := s.MarkUsersProcessed(ctx, activityID, adminID, ids); err != nil {
		return 0, err
	}
	return int64(len(ids)), nil
}

func (s *service) DeleteUserRecord(ctx context.Context, activityID int64, recordID int64) error {
	if activityID <= 0 || recordID <= 0 {
		return errors.New("参数无效")
	}
	return s.repo.GetDbW().WithContext(ctx).Where("id = ? AND activity_id = ?", recordID, activityID).Delete(&UserRecord{}).Error
}

func (s *service) GetCostSummary(ctx context.Context) (*CostSummary, error) {
	var activities []Activity
	if err := s.repo.GetDbR().WithContext(ctx).Find(&activities).Error; err != nil {
		return nil, err
	}
	var total int64
	for _, activity := range activities {
		cost, err := s.calculateClaimedCost(ctx, activity.ID)
		if err != nil {
			return nil, err
		}
		total += cost
	}
	var count int64
	if err := s.repo.GetDbR().WithContext(ctx).Table("prize_grant_activity_user_records").Where("status = ?", RecordStatusClaimed).Count(&count).Error; err != nil {
		return nil, err
	}
	return &CostSummary{CostCents: total, Count: count}, nil
}

func (s *service) ListUserRecords(ctx context.Context, activityID int64, status string, keyword string, page int, pageSize int) (map[string]any, error) {
	if page <= 0 {
		page = 1
	}
	if pageSize <= 0 {
		pageSize = 20
	}
	if pageSize > 100 {
		pageSize = 100
	}
	db := s.repo.GetDbR().WithContext(ctx).Table("prize_grant_activity_user_records r").
		Select("r.id, r.activity_id, r.user_id, r.status, r.claimed_at, r.processed_at, r.operator_admin_id, r.created_at, r.updated_at, u.nickname, u.mobile").
		Joins("LEFT JOIN users u ON u.id = r.user_id").
		Where("r.activity_id = ?", activityID)
	if strings.TrimSpace(status) != "" {
		db = db.Where("r.status = ?", strings.TrimSpace(status))
	}
	if strings.TrimSpace(keyword) != "" {
		kw := "%" + strings.TrimSpace(keyword) + "%"
		db = db.Where("CAST(r.user_id AS CHAR) LIKE ? OR u.nickname LIKE ? OR u.mobile LIKE ?", kw, kw, kw)
	}
	var total int64
	if err := db.Count(&total).Error; err != nil {
		return nil, err
	}
	var rows []map[string]any
	if err := db.Order("r.id DESC").Offset((page-1)*pageSize).Limit(pageSize).Scan(&rows).Error; err != nil {
		return nil, err
	}
	return map[string]any{"page": page, "page_size": pageSize, "total": total, "list": rows}, nil
}

func validateSaveRequest(req SaveActivityRequest) error {
	if strings.TrimSpace(req.Reason) == "" {
		return errors.New("发奖原因不能为空")
	}
	if len(req.Rewards) == 0 {
		return errors.New("至少配置一个奖品")
	}
	for _, reward := range req.Rewards {
		if reward.RewardRefID <= 0 {
			return errors.New("奖品资源ID无效")
		}
		if reward.QuantityPerClaim <= 0 {
			return errors.New("领取数量必须大于0")
		}
		if reward.RewardType != RewardTypeProduct && reward.RewardType != RewardTypeCoupon && reward.RewardType != RewardTypeItemCard {
			return fmt.Errorf("不支持的奖品类型: %s", reward.RewardType)
		}
	}
	return nil
}

func normalizeStatus(status string) string {
	if strings.TrimSpace(status) == "active" {
		return "active"
	}
	return "inactive"
}

func (s *service) replaceRewards(ctx context.Context, tx *gorm.DB, activityID int64, inputs []RewardInput) error {
	if err := tx.WithContext(ctx).Where("activity_id = ?", activityID).Delete(&Reward{}).Error; err != nil {
		return err
	}
	items := make([]Reward, 0, len(inputs))
	for idx, input := range inputs {
		sort := input.Sort
		if sort == 0 {
			sort = int32(idx + 1)
		}
		items = append(items, Reward{ActivityID: activityID, RewardType: input.RewardType, RewardRefID: input.RewardRefID, QuantityPerClaim: input.QuantityPerClaim, Sort: sort})
	}
	return tx.WithContext(ctx).Create(&items).Error
}

func (s *service) loadRewardViews(ctx context.Context, activityID int64) ([]RewardView, error) {
	var rewards []Reward
	if err := s.repo.GetDbR().WithContext(ctx).Where("activity_id = ?", activityID).Order("sort ASC, id ASC").Find(&rewards).Error; err != nil {
		return nil, err
	}
	views := make([]RewardView, 0, len(rewards))
	for _, reward := range rewards {
		view := RewardView{RewardType: reward.RewardType, RewardRefID: reward.RewardRefID, Quantity: reward.QuantityPerClaim}
		switch reward.RewardType {
		case RewardTypeProduct:
			var product model.Products
			if err := s.repo.GetDbR().WithContext(ctx).Where("id = ?", reward.RewardRefID).First(&product).Error; err == nil {
				view.Name = product.Name
				view.ValueCents = product.Price
				images := parseProductImages(product.ImagesJSON)
				if len(images) > 0 {
					view.Image = images[0]
				}
			}
		case RewardTypeCoupon:
			var coupon model.SystemCoupons
			if err := s.repo.GetDbR().WithContext(ctx).Where("id = ?", reward.RewardRefID).First(&coupon).Error; err == nil {
				view.Name = coupon.Name
				view.ValueCents = coupon.DiscountValue
			}
		case RewardTypeItemCard:
			var card model.SystemItemCards
			if err := s.repo.GetDbR().WithContext(ctx).Where("id = ?", reward.RewardRefID).First(&card).Error; err == nil {
				view.Name = card.Name
				view.ValueCents = card.Price
			}
		}
		views = append(views, view)
	}
	return views, nil
}

func (s *service) calculateClaimedCost(ctx context.Context, activityID int64) (int64, error) {
	var rewards []Reward
	if err := s.repo.GetDbR().WithContext(ctx).Where("activity_id = ?", activityID).Find(&rewards).Error; err != nil {
		return 0, err
	}
	var claimedCount int64
	if err := s.repo.GetDbR().WithContext(ctx).Table("prize_grant_activity_user_records").Where("activity_id = ? AND status = ?", activityID, RecordStatusClaimed).Count(&claimedCount).Error; err != nil {
		return 0, err
	}
	var costPerClaim int64
	for _, reward := range rewards {
		switch reward.RewardType {
		case RewardTypeProduct:
			var product model.Products
			if err := s.repo.GetDbR().WithContext(ctx).Where("id = ?", reward.RewardRefID).First(&product).Error; err == nil {
				unit := product.CostPrice
				if unit <= 0 {
					unit = product.Price
				}
				costPerClaim += unit * int64(reward.QuantityPerClaim)
			}
		case RewardTypeCoupon:
			var coupon model.SystemCoupons
			if err := s.repo.GetDbR().WithContext(ctx).Where("id = ?", reward.RewardRefID).First(&coupon).Error; err == nil {
				costPerClaim += coupon.DiscountValue * int64(reward.QuantityPerClaim)
			}
		case RewardTypeItemCard:
			var card model.SystemItemCards
			if err := s.repo.GetDbR().WithContext(ctx).Where("id = ?", reward.RewardRefID).First(&card).Error; err == nil {
				costPerClaim += card.Price * int64(reward.QuantityPerClaim)
			}
		}
	}
	return costPerClaim * claimedCount, nil
}

func (s *service) grantReward(ctx context.Context, tx *gorm.DB, activityID int64, userID int64, reward Reward) error {
	switch reward.RewardType {
	case RewardTypeCoupon:
		var tpl model.SystemCoupons
		if err := tx.WithContext(ctx).Where("id = ? AND status = 1", reward.RewardRefID).First(&tpl).Error; err != nil {
			return err
		}
		item := &model.UserCoupons{UserID: userID, CouponID: tpl.ID, Status: 1}
		if !tpl.ValidStart.IsZero() {
			item.ValidStart = tpl.ValidStart
		} else {
			item.ValidStart = time.Now()
		}
		if !tpl.ValidEnd.IsZero() {
			item.ValidEnd = tpl.ValidEnd
		}
		do := tx.WithContext(ctx).Omit("used_at", "used_order_id")
		if tpl.ValidEnd.IsZero() {
			do = do.Omit("valid_end")
		}
		if err := do.Create(item).Error; err != nil {
			return err
		}
		balance := int64(0)
		if tpl.DiscountType == 1 && tpl.DiscountValue > 0 {
			balance = tpl.DiscountValue
		}
		return tx.WithContext(ctx).Model(&model.UserCoupons{}).Where("id = ?", item.ID).Update("balance_amount", balance).Error
	case RewardTypeItemCard:
		var card model.SystemItemCards
		if err := tx.WithContext(ctx).Where("id = ? AND status = 1", reward.RewardRefID).First(&card).Error; err != nil {
			return err
		}
		now := time.Now()
		item := &model.UserItemCards{UserID: userID, CardID: card.ID, Status: 1, Remark: "奖品发放活动领取"}
		if !card.ValidStart.IsZero() {
			item.ValidStart = card.ValidStart
		} else {
			item.ValidStart = now
		}
		if !card.ValidEnd.IsZero() {
			item.ValidEnd = card.ValidEnd
		}
		do := tx.WithContext(ctx).Omit("used_at", "used_draw_log_id", "used_activity_id", "used_issue_id")
		if card.ValidEnd.IsZero() {
			do = do.Omit("valid_end")
		}
		return do.Create(item).Error
	default:
		var product model.Products
		if err := tx.WithContext(ctx).Where("id = ?", reward.RewardRefID).First(&product).Error; err != nil {
			return err
		}
		if product.Stock <= 0 {
			return fmt.Errorf("商品库存不足: %s", product.Name)
		}
		result := tx.WithContext(ctx).Model(&model.Products{}).Where("id = ? AND stock > 0", product.ID).Update("stock", gorm.Expr("stock - 1"))
		if result.Error != nil {
			return result.Error
		}
		if result.RowsAffected == 0 {
			return fmt.Errorf("商品库存不足: %s", product.Name)
		}
		now := time.Now()
		minValidTime := time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC)
		order := &model.Orders{OrderNo: fmt.Sprintf("PG%d%d%04d", activityID, now.Unix(), rand.Intn(10000)), UserID: userID, SourceType: 6, Status: 2, PaidAt: now, CancelledAt: minValidTime, Remark: "奖品发放活动领取", CreatedAt: now, UpdatedAt: now}
		if err := tx.WithContext(ctx).Create(order).Error; err != nil {
			return err
		}
		orderItem := &model.OrderItems{OrderID: order.ID, ProductID: product.ID, Title: product.Name, Quantity: 1, ProductImages: product.ImagesJSON, Status: 1}
		if err := tx.WithContext(ctx).Create(orderItem).Error; err != nil {
			return err
		}
		value := product.CostPrice
		if value <= 0 {
			value = product.Price
		}
		inventory := &model.UserInventory{UserID: userID, ProductID: product.ID, ValueCents: value, ValueSource: 2, ValueSnapshotAt: now, OrderID: order.ID, ActivityID: activityID, Status: 1, Remark: "奖品发放活动领取"}
		return tx.WithContext(ctx).Create(inventory).Error
	}
}

func clauseOnConflictUpdateProcessed() clause.OnConflict {
	return clause.OnConflict{
		Columns: []clause.Column{{Name: "activity_id"}, {Name: "user_id"}},
		DoUpdates: clause.Assignments(map[string]any{
			"status":            RecordStatusProcessed,
			"processed_at":      gorm.Expr("VALUES(processed_at)"),
			"operator_admin_id": gorm.Expr("VALUES(operator_admin_id)"),
			"updated_at":        gorm.Expr("CURRENT_TIMESTAMP(3)"),
		}),
	}
}

func parseProductImages(raw string) []string {
	if strings.TrimSpace(raw) == "" {
		return nil
	}
	var arr []string
	if err := json.Unmarshal([]byte(raw), &arr); err == nil {
		result := make([]string, 0, len(arr))
		for _, item := range arr {
			item = strings.TrimSpace(item)
			if item != "" {
				result = append(result, item)
			}
		}
		return result
	}
	return nil
}