package repository

import (
	"code.30cm.net/digimon/app-cloudep-wallet-service/pkg/domain/entity"
	"code.30cm.net/digimon/app-cloudep-wallet-service/pkg/domain/repository"
	"context"
	"database/sql"
	"gorm.io/gorm"
)

type WalletRepositoryParam struct {
	DB *gorm.DB `name:"dbM"`
}

type WalletRepository struct {
	WalletRepositoryParam
}

func MustCategoryRepository(param WalletRepositoryParam) repository.WalletRepository {
	return &WalletRepository{
		param,
	}
}

func (repo *WalletRepository) NewDB() *gorm.DB {
	return repo.DB.Begin()
}

// Transaction 指 DB 事務，非記錄一筆交易
func (repo *WalletRepository) Transaction(fn func(db *gorm.DB) error) error {
	db := repo.DB.Begin(&sql.TxOptions{
		Isolation: sql.LevelReadCommitted,
		ReadOnly:  false,
	})
	defer db.Rollback()

	if err := fn(db); err != nil {
		return err
	}

	if err := db.Commit().Error; err != nil {
		return err
	}

	return nil
}

func (repo *WalletRepository) Session(uid, asset string) repository.UserWalletService {
	return NewWalletService(repo.DB, uid, asset)
}

func (repo *WalletRepository) SessionWithTx(db *gorm.DB, uid, asset string) repository.UserWalletService {
	return NewWalletService(db, uid, asset)
}

func (repo *WalletRepository) InitWallets(ctx context.Context, param []repository.Wallet) error {
	wallets := make([]entity.Wallet, 0, len(param))
	for _, t := range param {
		wallets = append(wallets, entity.Wallet{
			Brand:   t.Brand,
			UID:     t.UID,
			Asset:   t.Asset,
			Balance: t.Balance,
			Type:    t.Type,
		})
	}

	if err := repo.DB.Create(&wallets).WithContext(ctx).Error; err != nil {
		return err
	}

	return nil
}

func (repo *WalletRepository) QueryBalances(ctx context.Context, req repository.BalanceQuery) ([]entity.Wallet, error) {
	var data []entity.Wallet
	s := repo.DB.WithContext(ctx).
		Select("id, asset, balance, type, update_at").
		Where("uid = ?", req.UID)

	if req.Asset != "" {
		s = s.Where("asset = ?", req.Asset)
	}

	err := s.Find(&data).Error
	if err != nil {
		return nil, err
	}

	return data, nil
}

func (repo *WalletRepository) QueryBalancesByUIDs(ctx context.Context, uids []string, req repository.BalanceQuery) ([]entity.Wallet, error) {
	var data []entity.Wallet
	query := repo.DB.WithContext(ctx).
		Select("uid, asset, balance, type, update_at").
		Where("uid IN ?", uids)

	if req.Asset != "" {
		query = query.Where("asset = ?", req.Asset)
	}

	if len(req.Kinds) > 0 {
		query = query.Where("type IN ?", req.Kinds)
	}

	err := query.Find(&data).Error
	if err != nil {
		return nil, err
	}

	return data, nil
}