package report

import (
	"context"
	"encoding/csv"
	"errors"
	"fmt"
	"log/slog"
	"os"
	"sort"
	"strconv"
	"strings"
	"time"

	"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/repository"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/services/bet"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/services/branch"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/services/company"

	// notificationservice "github.com/SamuelTariku/FortuneBet-Backend/internal/services/notfication"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/services/transaction"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/services/user"

	// virtualgameservice "github.com/SamuelTariku/FortuneBet-Backend/internal/services/virtualGame"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/services/wallet"
)

var (
	ErrInvalidTimeRange      = errors.New("invalid time range - start time must be before end time")
	ErrInvalidReportCriteria = errors.New("invalid report criteria")
)

type Service struct {
	betStore          bet.BetStore
	walletStore       wallet.WalletStore
	transactionStore  transaction.TransactionStore
	branchStore       branch.BranchStore
	userStore         user.UserStore
	repo              repository.ReportRepository
	companyStore      company.CompanyStore
	virtulaGamesStore repository.VirtualGameRepository
	notificationStore repository.NotificationRepository
	logger            *slog.Logger
}

func NewService(
	betStore bet.BetStore,
	walletStore wallet.WalletStore,
	transactionStore transaction.TransactionStore,
	branchStore branch.BranchStore,
	userStore user.UserStore,
	repo repository.ReportRepository,
	companyStore company.CompanyStore,
	virtulaGamesStore repository.VirtualGameRepository,
	notificationStore repository.NotificationRepository,
	logger *slog.Logger,
) *Service {
	return &Service{
		betStore:          betStore,
		walletStore:       walletStore,
		transactionStore:  transactionStore,
		branchStore:       branchStore,
		userStore:         userStore,
		repo:              repo,
		companyStore:      companyStore,
		virtulaGamesStore: virtulaGamesStore,
		notificationStore: notificationStore,
		logger:            logger,
	}
}

// GetDashboardSummary returns comprehensive dashboard metrics
func (s *Service) GetDashboardSummary(ctx context.Context, filter domain.ReportFilter) (domain.DashboardSummary, error) {
	if err := validateTimeRange(filter); err != nil {
		return domain.DashboardSummary{}, err
	}

	var summary domain.DashboardSummary
	var err error

	// Get bets summary
	summary.TotalStakes, summary.TotalBets, summary.ActiveBets, summary.TotalWins, summary.TotalLosses, summary.WinBalance, err =
		s.betStore.GetBetSummary(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get bet summary", "error", err)
		return domain.DashboardSummary{}, err
	}

	// Get customer metrics
	summary.CustomerCount, summary.ActiveCustomers, summary.InactiveCustomers, err = s.userStore.GetCustomerCounts(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get customer counts", "error", err)
		return domain.DashboardSummary{}, err
	}

	// Get branch metrics
	summary.BranchesCount, summary.ActiveBranches, summary.InactiveBranches, err = s.branchStore.GetBranchCounts(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get branch counts", "error", err)
		return domain.DashboardSummary{}, err
	}

	// Get transaction metrics
	summary.TotalDeposits, summary.TotalWithdrawals, err = s.transactionStore.GetTransactionTotals(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get transaction totals", "error", err)
		return domain.DashboardSummary{}, err
	}

	// Get user role metrics
	summary.TotalCashiers, summary.ActiveCashiers, summary.InactiveCashiers, err = s.userStore.GetRoleCounts(ctx, string(domain.RoleCashier), filter)
	if err != nil {
		s.logger.Error("failed to get cashier counts", "error", err)
		return domain.DashboardSummary{}, err
	}

	summary.TotalManagers, summary.ActiveManagers, summary.InactiveManagers, err = s.userStore.GetRoleCounts(ctx, string(domain.RoleBranchManager), filter)
	if err != nil {
		s.logger.Error("failed to get manager counts", "error", err)
		return domain.DashboardSummary{}, err
	}

	summary.TotalAdmins, summary.ActiveAdmins, summary.InactiveAdmins, err = s.userStore.GetRoleCounts(ctx, string(domain.RoleAdmin), filter)
	if err != nil {
		s.logger.Error("failed to get admin counts", "error", err)
		return domain.DashboardSummary{}, err
	}

	// Get wallet metrics
	summary.TotalWallets, err = s.walletStore.GetTotalWallets(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get wallet counts", "error", err)
		return domain.DashboardSummary{}, err
	}

	// Get sport/game metrics
	// summary.TotalGames, summary.ActiveGames, summary.InactiveGames, err = s.virtulaGamesStore.GetGameCounts(ctx, filter)
	// if err != nil {
	// 	s.logger.Error("failed to get game counts", "error", err)
	// 	return domain.DashboardSummary{}, err
	// }

	// Get company metrics
	summary.TotalCompanies, summary.ActiveCompanies, summary.InactiveCompanies, err = s.companyStore.GetCompanyCounts(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get company counts", "error", err)
		return domain.DashboardSummary{}, err
	}

	// Get notification metrics
	summary.TotalNotifications, summary.ReadNotifications, summary.UnreadNotifications, err = s.notificationStore.GetNotificationCounts(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get notification counts", "error", err)
		return domain.DashboardSummary{}, err
	}

	// Calculate derived metrics
	if summary.TotalBets > 0 {
		summary.AverageStake = summary.TotalStakes / domain.Currency(summary.TotalBets)
		summary.WinRate = float64(summary.TotalWins) / float64(summary.TotalBets) * 100
		summary.Profit = summary.TotalStakes - summary.WinBalance
	}

	return summary, nil
}

// Getdomain.BetAnalysis returns detailed bet analysis
func (s *Service) GetBetAnalysis(ctx context.Context, filter domain.ReportFilter) ([]domain.BetAnalysis, error) {
	if err := validateTimeRange(filter); err != nil {
		return nil, err
	}

	// Get basic bet stats
	betStats, err := s.betStore.GetBetStats(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get bet stats", "error", err)
		return nil, err
	}

	// Get sport popularity
	sportPopularity, err := s.betStore.GetSportPopularity(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get sport popularity", "error", err)
		return nil, err
	}

	// Get market popularity
	marketPopularity, err := s.betStore.GetMarketPopularity(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get market popularity", "error", err)
		return nil, err
	}

	// Get extreme values
	extremeValues, err := s.betStore.GetExtremeValues(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get extreme values", "error", err)
		return nil, err
	}

	// Combine data into analysis
	var analysis []domain.BetAnalysis
	for _, stat := range betStats {
		a := domain.BetAnalysis{
			Date:         stat.Date,
			TotalBets:    stat.TotalBets,
			TotalStakes:  stat.TotalStakes,
			TotalWins:    stat.TotalWins,
			TotalPayouts: stat.TotalPayouts,
			Profit:       stat.TotalStakes - stat.TotalPayouts,
			AverageOdds:  stat.AverageOdds,
		}

		// Add sport popularity
		if sport, ok := sportPopularity[stat.Date]; ok {
			a.MostPopularSport = sport
		}

		// Add market popularity
		if market, ok := marketPopularity[stat.Date]; ok {
			a.MostPopularMarket = market
		}

		// Add extreme values
		if extremes, ok := extremeValues[stat.Date]; ok {
			a.HighestStake = extremes.HighestStake
			a.HighestPayout = extremes.HighestPayout
		}

		analysis = append(analysis, a)
	}

	// Sort by date
	sort.Slice(analysis, func(i, j int) bool {
		return analysis[i].Date.Before(analysis[j].Date)
	})

	return analysis, nil
}

// Getdomain.CustomerActivity returns customer activity report
func (s *Service) GetCustomerActivity(ctx context.Context, filter domain.ReportFilter) ([]domain.CustomerActivity, error) {
	if err := validateTimeRange(filter); err != nil {
		return nil, err
	}

	// Get customer bet activity
	customerBets, err := s.betStore.GetCustomerBetActivity(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get customer bet activity", "error", err)
		return nil, err
	}

	// Get customer details
	customerDetails, err := s.userStore.GetCustomerDetails(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get customer details", "error", err)
		return nil, err
	}

	// Get customer preferences
	customerPrefs, err := s.betStore.GetCustomerPreferences(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get customer preferences", "error", err)
		return nil, err
	}

	// Combine data into activity report
	var activities []domain.CustomerActivity
	for _, bet := range customerBets {
		activity := domain.CustomerActivity{
			CustomerID:   bet.CustomerID,
			TotalBets:    bet.TotalBets,
			TotalStakes:  bet.TotalStakes,
			TotalWins:    bet.TotalWins,
			TotalPayouts: bet.TotalPayouts,
			Profit:       bet.TotalStakes - bet.TotalPayouts,
			FirstBetDate: bet.FirstBetDate,
			LastBetDate:  bet.LastBetDate,
			AverageStake: bet.TotalStakes / domain.Currency(bet.TotalBets),
			AverageOdds:  bet.AverageOdds,
		}

		// Add customer details
		if details, ok := customerDetails[bet.CustomerID]; ok {
			activity.CustomerName = details.Name
		}

		// Add preferences
		if prefs, ok := customerPrefs[bet.CustomerID]; ok {
			activity.FavoriteSport = prefs.FavoriteSport
			activity.FavoriteMarket = prefs.FavoriteMarket
		}

		// Calculate win rate
		if bet.TotalBets > 0 {
			activity.WinRate = float64(bet.TotalWins) / float64(bet.TotalBets) * 100
		}

		// Determine activity level
		activity.ActivityLevel = calculateActivityLevel(bet.TotalBets, bet.TotalStakes)

		activities = append(activities, activity)
	}

	// Sort by total stakes (descending)
	sort.Slice(activities, func(i, j int) bool {
		return activities[i].TotalStakes > activities[j].TotalStakes
	})

	return activities, nil
}

// Getdomain.BranchPerformance returns branch performance report
func (s *Service) GetBranchPerformance(ctx context.Context, filter domain.ReportFilter) ([]domain.BranchPerformance, error) {
	// Get branch bet activity
	branchBets, err := s.betStore.GetBranchBetActivity(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get branch bet activity", "error", err)
		return nil, err
	}

	// Get branch details
	branchDetails, err := s.branchStore.GetBranchDetails(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get branch details", "error", err)
		return nil, err
	}

	// Get branch transactions
	branchTransactions, err := s.transactionStore.GetBranchTransactionTotals(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get branch transactions", "error", err)
		return nil, err
	}

	// Get branch customer counts
	branchCustomers, err := s.userStore.GetBranchCustomerCounts(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get branch customer counts", "error", err)
		return nil, err
	}

	// Combine data into performance report
	var performances []domain.BranchPerformance
	for _, bet := range branchBets {
		performance := domain.BranchPerformance{
			BranchID:     bet.BranchID,
			TotalBets:    bet.TotalBets,
			TotalStakes:  bet.TotalStakes,
			TotalWins:    bet.TotalWins,
			TotalPayouts: bet.TotalPayouts,
			Profit:       bet.TotalStakes - bet.TotalPayouts,
		}

		// Add branch details
		if details, ok := branchDetails[bet.BranchID]; ok {
			performance.BranchName = details.Name
			performance.Location = details.Location
			performance.ManagerName = details.ManagerName
		}

		// Add transactions
		if transactions, ok := branchTransactions[bet.BranchID]; ok {
			performance.Deposits = transactions.Deposits
			performance.Withdrawals = transactions.Withdrawals
		}

		// Add customer counts
		if customers, ok := branchCustomers[bet.BranchID]; ok {
			performance.CustomerCount = customers
		}

		// Calculate metrics
		if bet.TotalBets > 0 {
			performance.WinRate = float64(bet.TotalWins) / float64(bet.TotalBets) * 100
			performance.AverageStake = bet.TotalStakes / domain.Currency(bet.TotalBets)
		}

		// Calculate performance score
		performance.PerformanceScore = calculatePerformanceScore(performance)

		performances = append(performances, performance)
	}

	// Sort by performance score (descending)
	sort.Slice(performances, func(i, j int) bool {
		return performances[i].PerformanceScore > performances[j].PerformanceScore
	})

	return performances, nil
}

// Getdomain.SportPerformance returns sport performance report
func (s *Service) GetSportPerformance(ctx context.Context, filter domain.ReportFilter) ([]domain.SportPerformance, error) {
	// Get sport bet activity
	sportBets, err := s.betStore.GetSportBetActivity(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get sport bet activity", "error", err)
		return nil, err
	}

	// Get sport details (names)
	sportDetails, err := s.betStore.GetSportDetails(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get sport details", "error", err)
		return nil, err
	}

	// Get sport market popularity
	sportMarkets, err := s.betStore.GetSportMarketPopularity(ctx, filter)
	if err != nil {
		s.logger.Error("failed to get sport market popularity", "error", err)
		return nil, err
	}

	// Combine data into performance report
	var performances []domain.SportPerformance
	for _, bet := range sportBets {
		performance := domain.SportPerformance{
			SportID:      bet.SportID,
			TotalBets:    bet.TotalBets,
			TotalStakes:  bet.TotalStakes,
			TotalWins:    bet.TotalWins,
			TotalPayouts: bet.TotalPayouts,
			Profit:       bet.TotalStakes - bet.TotalPayouts,
			AverageOdds:  bet.AverageOdds,
		}

		// Add sport details
		if details, ok := sportDetails[bet.SportID]; ok {
			performance.SportName = details
		}

		// Add market popularity
		if market, ok := sportMarkets[bet.SportID]; ok {
			performance.MostPopularMarket = market
		}

		// Calculate metrics
		if bet.TotalBets > 0 {
			performance.WinRate = float64(bet.TotalWins) / float64(bet.TotalBets) * 100
			performance.AverageStake = bet.TotalStakes / domain.Currency(bet.TotalBets)
		}

		performances = append(performances, performance)
	}

	// Sort by total stakes (descending) and assign popularity rank
	sort.Slice(performances, func(i, j int) bool {
		return performances[i].TotalStakes > performances[j].TotalStakes
	})

	for i := range performances {
		performances[i].PopularityRank = i + 1
	}

	return performances, nil
}

func (s *Service) GenerateReport(ctx context.Context, from, to time.Time) error {
	// Hardcoded output directory
	outputDir := "reports"

	// Ensure directory exists
	if err := os.MkdirAll(outputDir, os.ModePerm); err != nil {
		return fmt.Errorf("failed to create report directory: %w", err)
	}

	companies, branchMap, err := s.fetchReportData(ctx, from, to)
	if err != nil {
		return err
	}

	// per-company reports
	for _, company := range companies {
		branches := branchMap[company.CompanyID]
		if err := writeCompanyCSV(company, branches, from, to, outputDir); err != nil {
			return fmt.Errorf("company %d CSV: %w", company.CompanyID, err)
		}
	}

	// summary report
	if err := writeSummaryCSV(companies, from, to, outputDir); err != nil {
		return fmt.Errorf("summary CSV: %w", err)
	}

	return nil
}

// writeCompanyCSV writes the company report to CSV in the hardcoded folder
func writeCompanyCSV(company domain.CompanyReport, branches []domain.BranchReport, from, to time.Time, outputDir string) error {
	period := fmt.Sprintf("%s to %s", from.Format("2006-01-02"), to.Format("2006-01-02"))

	filePath := fmt.Sprintf("%s/company_%d_%s_%s_%s.csv",
		outputDir,
		company.CompanyID,
		from.Format("2006-01-02"),
		to.Format("2006-01-02"),
		time.Now().Format("2006-01-02_15-04"),
	)

	file, err := os.Create(filePath)
	if err != nil {
		return fmt.Errorf("create company csv: %w", err)
	}
	defer file.Close()

	writer := csv.NewWriter(file)
	defer writer.Flush()

	// Company summary section
	writer.Write([]string{"Company Betting Report"})
	writer.Write([]string{"Period", "Company ID", "Company Name", "Total Bets", "Total Cash In", "Total Cash Out", "Total Cash Backs"})
	writer.Write([]string{
		period,
		fmt.Sprintf("%d", company.CompanyID),
		company.CompanyName,
		fmt.Sprintf("%d", company.TotalBets),
		fmt.Sprintf("%.2f", company.TotalCashIn),
		fmt.Sprintf("%.2f", company.TotalCashOut),
		fmt.Sprintf("%.2f", company.TotalCashBacks),
	})
	writer.Write([]string{}) // Empty line

	// Branch reports
	writer.Write([]string{"Branch Reports"})
	writer.Write([]string{"Branch ID", "Branch Name", "Company ID", "Total Bets", "Total Cash In", "Total Cash Out", "Total Cash Backs"})
	for _, br := range branches {
		writer.Write([]string{
			fmt.Sprintf("%d", br.BranchID),
			br.BranchName,
			fmt.Sprintf("%d", br.CompanyID),
			fmt.Sprintf("%d", br.TotalBets),
			fmt.Sprintf("%.2f", br.TotalCashIn),
			fmt.Sprintf("%.2f", br.TotalCashOut),
			fmt.Sprintf("%.2f", br.TotalCashBacks),
		})
	}

	if err := writer.Error(); err != nil {
		return fmt.Errorf("flush error: %w", err)
	}

	return nil
}

// writeSummaryCSV writes the summary report to CSV in the hardcoded folder
func writeSummaryCSV(companies []domain.CompanyReport, from, to time.Time, outputDir string) error {
	period := fmt.Sprintf("%s to %s", from.Format("2006-01-02"), to.Format("2006-01-02"))

	filePath := fmt.Sprintf("%s/summary_%s_%s_%s.csv",
		outputDir,
		from.Format("2006-01-02"),
		to.Format("2006-01-02"),
		time.Now().Format("2006-01-02_15-04"),
	)

	file, err := os.Create(filePath)
	if err != nil {
		return fmt.Errorf("create summary csv: %w", err)
	}
	defer file.Close()

	writer := csv.NewWriter(file)
	defer writer.Flush()

	// Global summary
	writer.Write([]string{"Global Betting Summary"})
	writer.Write([]string{"Period", "Total Bets", "Total Cash In", "Total Cash Out", "Total Cash Backs"})

	var totalBets int64
	var totalIn, totalOut, totalBack float64
	for _, c := range companies {
		totalBets += c.TotalBets
		totalIn += c.TotalCashIn
		totalOut += c.TotalCashOut
		totalBack += c.TotalCashBacks
	}

	writer.Write([]string{
		period,
		fmt.Sprintf("%d", totalBets),
		fmt.Sprintf("%.2f", totalIn),
		fmt.Sprintf("%.2f", totalOut),
		fmt.Sprintf("%.2f", totalBack),
	})
	writer.Write([]string{}) // Empty line

	// Company breakdown
	writer.Write([]string{"Company Reports"})
	writer.Write([]string{"Company ID", "Company Name", "Total Bets", "Total Cash In", "Total Cash Out", "Total Cash Backs"})
	for _, cr := range companies {
		writer.Write([]string{
			fmt.Sprintf("%d", cr.CompanyID),
			cr.CompanyName,
			fmt.Sprintf("%d", cr.TotalBets),
			fmt.Sprintf("%.2f", cr.TotalCashIn),
			fmt.Sprintf("%.2f", cr.TotalCashOut),
			fmt.Sprintf("%.2f", cr.TotalCashBacks),
		})
	}

	if err := writer.Error(); err != nil {
		return fmt.Errorf("flush error: %w", err)
	}

	return nil
}

func (s *Service) fetchReportData(ctx context.Context, from, to time.Time) (
	[]domain.CompanyReport, map[int64][]domain.BranchReport, error,
) {
	// --- company level ---
	companyRows, err := s.repo.GetCompanyWiseReport(ctx, from, to)
	if err != nil {
		return nil, nil, fmt.Errorf("company-wise report: %w", err)
	}

	companies := make([]domain.CompanyReport, 0, len(companyRows))
	for _, row := range companyRows {
		companies = append(companies, domain.CompanyReport{
			CompanyID:      row.CompanyID,
			CompanyName:    row.CompanyName,
			TotalBets:      row.TotalBets,
			TotalCashIn:    toFloat(row.TotalCashMade),
			TotalCashOut:   toFloat(row.TotalCashOut),
			TotalCashBacks: toFloat(row.TotalCashBacks),
		})
	}

	// --- branch level ---
	branchRows, err := s.repo.GetBranchWiseReport(ctx, from, to)
	if err != nil {
		return nil, nil, fmt.Errorf("branch-wise report: %w", err)
	}

	branchMap := make(map[int64][]domain.BranchReport)
	for _, row := range branchRows {
		branch := domain.BranchReport{
			BranchID:       row.BranchID,
			BranchName:     row.BranchName,
			CompanyID:      row.CompanyID,
			TotalBets:      row.TotalBets,
			TotalCashIn:    toFloat(row.TotalCashMade),
			TotalCashOut:   toFloat(row.TotalCashOut),
			TotalCashBacks: toFloat(row.TotalCashBacks),
		}
		branchMap[row.CompanyID] = append(branchMap[row.CompanyID], branch)
	}

	return companies, branchMap, nil
}

// helper to unify float conversions
func toFloat(val interface{}) float64 {
	switch v := val.(type) {
	case string:
		if f, err := strconv.ParseFloat(v, 64); err == nil {
			return f
		}
	case float64:
		return v
	case int:
		return float64(v)
	case int64:
		return float64(v)
	}
	return 0
}

func GetTimeRange(period string) (time.Time, time.Time) {
	now := time.Now()
	switch strings.ToLower(period) {
	case "daily":
		start := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
		end := start.Add(5 * time.Minute)
		return start, end
	case "weekly":
		weekday := int(now.Weekday())
		if weekday == 0 {
			weekday = 7
		}
		start := now.AddDate(0, 0, -weekday+1)
		start = time.Date(start.Year(), start.Month(), start.Day(), 0, 0, 0, 0, now.Location())
		end := start.AddDate(0, 0, 7)
		return start, end
	case "monthly":
		start := time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, now.Location())
		end := start.AddDate(0, 1, 0)
		return start, end
	default:
		// Default to daily
		start := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
		end := start.Add(24 * time.Hour)
		return start, end
	}
}

// Helper functions
func validateTimeRange(filter domain.ReportFilter) error {
	if filter.StartTime.Valid && filter.EndTime.Valid {
		if filter.StartTime.Value.After(filter.EndTime.Value) {
			return ErrInvalidTimeRange
		}
	}
	return nil
}

func calculateActivityLevel(totalBets int64, totalStakes domain.Currency) string {
	switch {
	case totalBets > 100 || totalStakes > 10000:
		return "High"
	case totalBets > 50 || totalStakes > 5000:
		return "Medium"
	default:
		return "Low"
	}
}

func calculatePerformanceScore(perf domain.BranchPerformance) float64 {
	// Simple scoring algorithm - can be enhanced based on business rules
	profitScore := float64(perf.Profit) / 1000
	customerScore := float64(perf.CustomerCount) * 0.1
	betScore := float64(perf.TotalBets) * 0.01
	winRateScore := perf.WinRate * 0.1

	return profitScore + customerScore + betScore + winRateScore
}

// toCompanyReport converts grouped data into []CompanyReport
// func toCompanyReport(grouped map[int64]map[int64][]interface{}) []domain.CompanyReport {
// 	companyReports := []domain.CompanyReport{}
// 	for companyID, branches := range grouped {
// 		companyReport := domain.CompanyReport{
// 			CompanyID: companyID,
// 			Branches:  []domain.BranchReport{},
// 		}
// 		for branchID, rows := range branches {
// 			branchReport := domain.BranchReport{
// 				BranchID: branchID,
// 				Rows:     rows,
// 			}
// 			companyReport.Branches = append(companyReport.Branches, branchReport)
// 		}
// 		companyReports = append(companyReports, companyReport)
// 	}
// 	return companyReports
// }

// // toBranchReport converts []interface{} to []BranchReport
// func toBranchReport(rows []interface{}, branchID int64) domain.BranchReport {
// 	return domain.BranchReport{
// 		BranchID: branchID,
// 		Rows:     rows,
// 	}
// }