package main

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"sort"
	"strings"
	"time"

	"github.com/golang-jwt/jwt/v5"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

type progressResponse struct {
	SolvedQuestionIDs      []string                  `json:"solvedQuestionIds"`
	DailyActivity          map[string]int            `json:"dailyActivity"`
	DailyActivityBreakdown map[string]map[string]int `json:"dailyActivityBreakdown"`
	SolvedCount            int                       `json:"solvedCount"`
	ActiveDays             int                       `json:"activeDays"`
	WeeklySolved           int                       `json:"weeklySolved"`
	Leaderboard            []progressLeaderboardUser `json:"leaderboard"`
	CodingLeaderboard      []progressLeaderboardUser `json:"codingLeaderboard"`
	CodingSolvedCount      int                       `json:"codingSolvedCount"`
}

type progressLeaderboardUser struct {
	ID            string `json:"id"`
	DisplayName   string `json:"displayName"`
	SolvedCount   int    `json:"solvedCount"`
	CurrentStreak int    `json:"currentStreak"`
	WeeklySolved  int    `json:"weeklySolved"`
	Coins         int    `json:"coins"`
	Score         int    `json:"score"`
	Rank          int            `json:"rank"`
	IsCurrentUser bool           `json:"isCurrentUser"`
	CodingStreak  int            `json:"codingStreak,omitempty"`
	LanguageStats map[string]int `json:"languageStats,omitempty"`
}

type importedProgressBody struct {
	SolvedQuestionIDs []string       `json:"solvedQuestionIds"`
	DailyActivity     map[string]int `json:"dailyActivity"`
}

type streakSnapshot struct {
	CurrentStreak int
	LongestStreak int
	LastActiveAt  time.Time
}

var solveCoinRewards = map[string]int{
	"easy":   10,
	"medium": 25,
	"hard":   50,
}

func handleUserStats(coll *mongo.Collection) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodGet {
			jsonError(w, http.StatusMethodNotAllowed, "Method not allowed")
			return
		}

		doc, requestTimeZone, statusCode, err := authenticatedUser(r, coll)
		if err != nil {
			jsonError(w, statusCode, err.Error())
			return
		}

		if err := syncUserTimeZone(r.Context(), coll, doc, requestTimeZone); err != nil {
			jsonError(w, http.StatusInternalServerError, "Failed to load stats.")
			return
		}

		stats, err := buildProgressResponse(r.Context(), coll, doc, time.Now().UTC())
		if err != nil {
			jsonError(w, http.StatusInternalServerError, "Failed to load stats.")
			return
		}

		jsonWrite(w, http.StatusOK, map[string]any{
			"user":  toPublicUser(doc),
			"stats": stats,
		})
	}
}

func handleSolveQuestion(coll *mongo.Collection) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPost {
			jsonError(w, http.StatusMethodNotAllowed, "Method not allowed")
			return
		}

		doc, requestTimeZone, statusCode, err := authenticatedUser(r, coll)
		if err != nil {
			jsonError(w, statusCode, err.Error())
			return
		}

		var body struct {
			QuestionID string `json:"questionId"`
			Difficulty string `json:"difficulty"`
			Language   string `json:"language,omitempty"`
		}
		if err := json.NewDecoder(maxBody(w, r.Body)).Decode(&body); err != nil {
			jsonError(w, http.StatusBadRequest, "Invalid JSON body")
			return
		}

		questionID := strings.TrimSpace(body.QuestionID)
		if questionID == "" {
			jsonError(w, http.StatusBadRequest, "Question ID is required.")
			return
		}

		reward, ok := rewardForDifficulty(body.Difficulty)
		if !ok {
			jsonError(w, http.StatusBadRequest, "Question difficulty is required.")
			return
		}

		now := time.Now().UTC()
		if err := syncUserTimeZone(r.Context(), coll, doc, requestTimeZone); err != nil {
			jsonError(w, http.StatusInternalServerError, "Failed to record solve.")
			return
		}

		solvedQuestionIDs := normalizeQuestionIDs(doc.SolvedQuestionIDs)
		dailyActivity := normalizeDailyActivity(doc.DailyActivity)
		dailyActivityBreakdown := normalizeDailyActivityBreakdown(doc.DailyActivityBreakdown)
		alreadySolved := containsQuestionID(solvedQuestionIDs, questionID)

		if !alreadySolved {
			solvedQuestionIDs = append(solvedQuestionIDs, questionID)
			activityKey := activityDateKey(now, doc.StreakTimeZone)
			
			dailyActivity[activityKey] = dailyActivity[activityKey] + 1
			
			if dailyActivityBreakdown[activityKey] == nil {
				dailyActivityBreakdown[activityKey] = make(map[string]int)
			}
			
			section := "coding"
			if strings.HasPrefix(questionID, "sd-") {
				section = "systemDesign"
			} else if strings.HasPrefix(questionID, "cs-dbms-") {
				section = "dbms"
			} else if strings.HasPrefix(questionID, "cs-os-") {
				section = "os"
			} else if strings.HasPrefix(questionID, "cs-cn-") {
				section = "cn"
			} else if strings.HasPrefix(questionID, "cs-") {
				section = "csFundamentals"
			} else if strings.HasPrefix(questionID, "apt-") {
				section = "aptitude"
			}
			dailyActivityBreakdown[activityKey][section] = dailyActivityBreakdown[activityKey][section] + 1
			
			languageStats := doc.LanguageStats
			if languageStats == nil {
				languageStats = make(map[string]int)
			}
			if section == "coding" && body.Language != "" {
				lang := strings.ToLower(strings.TrimSpace(body.Language))
				languageStats[lang] = languageStats[lang] + 1
			}

			nextStreak := nextStreakUpdate(doc, requestTimeZone, now)
			doc.SolvedQuestionIDs = solvedQuestionIDs
			doc.DailyActivity = dailyActivity
			doc.DailyActivityBreakdown = dailyActivityBreakdown
			doc.CurrentStreak = nextStreak.CurrentStreak
			doc.LongestStreak = nextStreak.LongestStreak
			doc.LastActiveAt = nextStreak.LastActiveAt
			doc.StreakTimeZone = nextStreak.StreakTimeZone
			doc.Coins = maxInt(doc.Coins, 0) + reward
			doc.LanguageStats = languageStats

			if reward > 0 {
				difficultyLabel := body.Difficulty
				if len(difficultyLabel) > 0 {
					difficultyLabel = strings.ToUpper(difficultyLabel[:1]) + strings.ToLower(difficultyLabel[1:])
				}
				
				sectionName := "Coding Problem"
				if section == "systemDesign" {
					sectionName = "System Design"
				} else if section == "dbms" {
					sectionName = "DBMS"
				} else if section == "os" {
					sectionName = "OS"
				} else if section == "cn" {
					sectionName = "Computer Networks"
				} else if section == "csFundamentals" {
					sectionName = "CS Fundamentals"
				} else if section == "aptitude" {
					sectionName = "Aptitude"
				}
				
				_ = recordCoinTransaction(r.Context(), coll, doc.ID, reward, sectionName+" ("+difficultyLabel+")", "problem")
			}

			_, err = coll.UpdateByID(r.Context(), doc.ID, bson.M{
				"$set": bson.M{
					"solvedQuestionIds":      solvedQuestionIDs,
					"dailyActivity":          dailyActivity,
					"dailyActivityBreakdown": dailyActivityBreakdown,
					"currentStreak":          doc.CurrentStreak,
					"longestStreak":          doc.LongestStreak,
					"lastActiveAt":           doc.LastActiveAt,
					"streakTimeZone":         doc.StreakTimeZone,
					"coins":                  doc.Coins,
					"languageStats":          doc.LanguageStats,
				},
			})
			if err != nil {
				jsonError(w, http.StatusInternalServerError, "Failed to record solve.")
				return
			}
		}

		stats, err := buildProgressResponse(r.Context(), coll, doc, now)
		if err != nil {
			jsonError(w, http.StatusInternalServerError, "Failed to load updated stats.")
			return
		}

		jsonWrite(w, http.StatusOK, map[string]any{
			"user":  toPublicUser(doc),
			"stats": stats,
		})
	}
}

func handleImportProgress(coll *mongo.Collection) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPost {
			jsonError(w, http.StatusMethodNotAllowed, "Method not allowed")
			return
		}

		doc, requestTimeZone, statusCode, err := authenticatedUser(r, coll)
		if err != nil {
			jsonError(w, statusCode, err.Error())
			return
		}

		var body importedProgressBody
		if err := json.NewDecoder(maxBody(w, r.Body)).Decode(&body); err != nil {
			jsonError(w, http.StatusBadRequest, "Invalid JSON body")
			return
		}

		if err := syncUserTimeZone(r.Context(), coll, doc, requestTimeZone); err != nil {
			jsonError(w, http.StatusInternalServerError, "Failed to import progress.")
			return
		}

		mergedSolved := mergeQuestionIDs(doc.SolvedQuestionIDs, body.SolvedQuestionIDs)
		mergedActivity := mergeDailyActivity(doc.DailyActivity, body.DailyActivity)
		snapshot := streakSnapshotFromActivity(mergedActivity, doc.StreakTimeZone)

		doc.SolvedQuestionIDs = mergedSolved
		doc.DailyActivity = mergedActivity
		if !snapshot.LastActiveAt.IsZero() {
			doc.CurrentStreak = snapshot.CurrentStreak
			doc.LongestStreak = maxInt(doc.LongestStreak, snapshot.LongestStreak)
			doc.LastActiveAt = snapshot.LastActiveAt
		}

		_, err = coll.UpdateByID(r.Context(), doc.ID, bson.M{
			"$set": bson.M{
				"solvedQuestionIds": mergedSolved,
				"dailyActivity":     mergedActivity,
				"currentStreak":     doc.CurrentStreak,
				"longestStreak":     doc.LongestStreak,
				"lastActiveAt":      doc.LastActiveAt,
				"streakTimeZone":    doc.StreakTimeZone,
			},
		})
		if err != nil {
			jsonError(w, http.StatusInternalServerError, "Failed to import progress.")
			return
		}

		stats, err := buildProgressResponse(r.Context(), coll, doc, time.Now().UTC())
		if err != nil {
			jsonError(w, http.StatusInternalServerError, "Failed to load updated stats.")
			return
		}

		jsonWrite(w, http.StatusOK, map[string]any{
			"user":  toPublicUser(doc),
			"stats": stats,
		})
	}
}

func handleSpendCoins(coll *mongo.Collection) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPost {
			jsonError(w, http.StatusMethodNotAllowed, "Method not allowed")
			return
		}

		doc, _, statusCode, err := authenticatedUser(r, coll)
		if err != nil {
			jsonError(w, statusCode, err.Error())
			return
		}

		var body struct {
			Amount int `json:"amount"`
		}
		if err := json.NewDecoder(maxBody(w, r.Body)).Decode(&body); err != nil {
			jsonError(w, http.StatusBadRequest, "Invalid JSON body")
			return
		}
		if body.Amount <= 0 {
			jsonError(w, http.StatusBadRequest, "Amount must be greater than 0.")
			return
		}
		if maxInt(doc.Coins, 0) < body.Amount {
			jsonError(w, http.StatusBadRequest, "Not enough coins.")
			return
		}

		doc.Coins = maxInt(doc.Coins, 0) - body.Amount
		_ = recordCoinTransaction(r.Context(), coll, doc.ID, -body.Amount, "Store Purchase", "shop")
		_, err = coll.UpdateByID(r.Context(), doc.ID, bson.M{
			"$set": bson.M{
				"coins": doc.Coins,
			},
		})
		if err != nil {
			jsonError(w, http.StatusInternalServerError, "Failed to spend coins.")
			return
		}

		stats, err := buildProgressResponse(r.Context(), coll, doc, time.Now().UTC())
		if err != nil {
			jsonError(w, http.StatusInternalServerError, "Failed to load updated stats.")
			return
		}

		jsonWrite(w, http.StatusOK, map[string]any{
			"user":  toPublicUser(doc),
			"stats": stats,
		})
	}
}

func authenticatedUser(
	r *http.Request,
	coll *mongo.Collection,
) (*userDoc, string, int, error) {
	raw := readBearer(r)
	if raw == "" {
		return nil, "", http.StatusUnauthorized, fmt.Errorf("Not authenticated.")
	}

	tok, err := jwt.ParseWithClaims(raw, &jwt.RegisteredClaims{}, func(t *jwt.Token) (any, error) {
		if t.Method != jwt.SigningMethodHS256 {
			return nil, fmt.Errorf("unexpected signing method")
		}
		return []byte(jwtSecret()), nil
	})
	if err != nil || !tok.Valid {
		return nil, "", http.StatusUnauthorized, fmt.Errorf("Invalid or expired session.")
	}

	claims, ok := tok.Claims.(*jwt.RegisteredClaims)
	if !ok || claims.Subject == "" {
		return nil, "", http.StatusUnauthorized, fmt.Errorf("Invalid or expired session.")
	}

	oid, err := primitive.ObjectIDFromHex(claims.Subject)
	if err != nil {
		return nil, "", http.StatusUnauthorized, fmt.Errorf("Invalid or expired session.")
	}

	var doc userDoc
	err = coll.FindOne(r.Context(), bson.M{"_id": oid}).Decode(&doc)
	if err != nil {
		if err == mongo.ErrNoDocuments {
			return nil, "", http.StatusUnauthorized, fmt.Errorf("User not found.")
		}
		return nil, "", http.StatusInternalServerError, fmt.Errorf("Could not load user.")
	}

	return &doc, readClientTimeZone(r), http.StatusOK, nil
}

func buildProgressResponse(
	ctx context.Context,
	coll *mongo.Collection,
	currentUser *userDoc,
	now time.Time,
) (progressResponse, error) {
	solvedQuestionIDs := normalizeQuestionIDs(currentUser.SolvedQuestionIDs)
	dailyActivity := normalizeDailyActivity(currentUser.DailyActivity)
	dailyActivityBreakdown := normalizeDailyActivityBreakdown(currentUser.DailyActivityBreakdown)
	leaderboard, codingLeaderboard, err := buildLeaderboards(ctx, coll, currentUser.ID.Hex(), now)
	if err != nil {
		return progressResponse{}, err
	}

	codingSolvedCount := 0
	for _, id := range solvedQuestionIDs {
		if !strings.HasPrefix(id, "sd-") && !strings.HasPrefix(id, "cs-") && !strings.HasPrefix(id, "apt-") {
			codingSolvedCount++
		}
	}

	return progressResponse{
		SolvedQuestionIDs:      solvedQuestionIDs,
		DailyActivity:          dailyActivity,
		DailyActivityBreakdown: dailyActivityBreakdown,
		SolvedCount:            len(solvedQuestionIDs),
		ActiveDays:             countActiveDays(dailyActivity),
		WeeklySolved:           weeklySolvedCount(dailyActivity, currentUser.StreakTimeZone, now),
		Leaderboard:            leaderboard,
		CodingLeaderboard:      codingLeaderboard,
		CodingSolvedCount:      codingSolvedCount,
	}, nil
}

func buildLeaderboards(
	ctx context.Context,
	coll *mongo.Collection,
	currentUserID string,
	now time.Time,
) ([]progressLeaderboardUser, []progressLeaderboardUser, error) {
	cursor, err := coll.Find(ctx, bson.M{}, options.Find().SetProjection(bson.M{
		"_id":               1,
		"displayName":       1,
		"coins":             1,
		"currentStreak":     1,
		"longestStreak":     1,
		"lastActiveAt":      1,
		"streakTimeZone":         1,
		"solvedQuestionIds":      1,
		"dailyActivity":          1,
		"dailyActivityBreakdown": 1,
		"languageStats":          1,
	}))
	if err != nil {
		return nil, nil, err
	}
	defer cursor.Close(ctx)

	entries := make([]progressLeaderboardUser, 0)
	codingEntries := make([]progressLeaderboardUser, 0)
	for cursor.Next(ctx) {
		var doc userDoc
		if err := cursor.Decode(&doc); err != nil {
			return nil, nil, err
		}

		solvedQuestionIDs := normalizeQuestionIDs(doc.SolvedQuestionIDs)
		dailyActivity := normalizeDailyActivity(doc.DailyActivity)
		dailyActivityBreakdown := normalizeDailyActivityBreakdown(doc.DailyActivityBreakdown)
		currentStreak := visibleCurrentStreak(&doc, "", now)
		weeklySolved := weeklySolvedCount(dailyActivity, doc.StreakTimeZone, now)
		
		codingWeeklySolved := codingWeeklySolvedCount(dailyActivityBreakdown, doc.StreakTimeZone, now)
		codingStreak := codingCurrentStreak(dailyActivityBreakdown, doc.StreakTimeZone, now)
		
		codingSolvedCount := 0
		for _, id := range solvedQuestionIDs {
			if !strings.HasPrefix(id, "sd-") && !strings.HasPrefix(id, "cs-") && !strings.HasPrefix(id, "apt-") {
				codingSolvedCount++
			}
		}

		coins := maxInt(doc.Coins, 0)
		solvedCount := len(solvedQuestionIDs)
		score := solvedCount*100 + weeklySolved*15 + currentStreak*30 + coins
		codingScore := codingSolvedCount*100

		entries = append(entries, progressLeaderboardUser{
			ID:            doc.ID.Hex(),
			DisplayName:   strings.TrimSpace(doc.DisplayName),
			SolvedCount:   solvedCount,
			CurrentStreak: currentStreak,
			WeeklySolved:  weeklySolved,
			Coins:         coins,
			Score:         score,
			IsCurrentUser: doc.ID.Hex() == currentUserID,
		})

		codingEntries = append(codingEntries, progressLeaderboardUser{
			ID:            doc.ID.Hex(),
			DisplayName:   strings.TrimSpace(doc.DisplayName),
			SolvedCount:   codingSolvedCount,
			CurrentStreak: currentStreak,
			CodingStreak:  codingStreak,
			WeeklySolved:  codingWeeklySolved,
			Coins:         coins,
			Score:         codingScore,
			LanguageStats: doc.LanguageStats,
			IsCurrentUser: doc.ID.Hex() == currentUserID,
		})
	}
	if err := cursor.Err(); err != nil {
		return nil, nil, err
	}

	sort.Slice(entries, func(i, j int) bool {
		if entries[i].Score != entries[j].Score {
			return entries[i].Score > entries[j].Score
		}
		if entries[i].SolvedCount != entries[j].SolvedCount {
			return entries[i].SolvedCount > entries[j].SolvedCount
		}
		if entries[i].WeeklySolved != entries[j].WeeklySolved {
			return entries[i].WeeklySolved > entries[j].WeeklySolved
		}
		if entries[i].Coins != entries[j].Coins {
			return entries[i].Coins > entries[j].Coins
		}
		return strings.ToLower(entries[i].DisplayName) < strings.ToLower(entries[j].DisplayName)
	})

	for index := range entries {
		entries[index].Rank = index + 1
		if entries[index].DisplayName == "" {
			entries[index].DisplayName = fmt.Sprintf("User %d", index+1)
		}
	}

	sort.Slice(codingEntries, func(i, j int) bool {
		if codingEntries[i].Score != codingEntries[j].Score {
			return codingEntries[i].Score > codingEntries[j].Score
		}
		if codingEntries[i].SolvedCount != codingEntries[j].SolvedCount {
			return codingEntries[i].SolvedCount > codingEntries[j].SolvedCount
		}
		if codingEntries[i].WeeklySolved != codingEntries[j].WeeklySolved {
			return codingEntries[i].WeeklySolved > codingEntries[j].WeeklySolved
		}
		if codingEntries[i].Coins != codingEntries[j].Coins {
			return codingEntries[i].Coins > codingEntries[j].Coins
		}
		return strings.ToLower(codingEntries[i].DisplayName) < strings.ToLower(codingEntries[j].DisplayName)
	})

	for index := range codingEntries {
		codingEntries[index].Rank = index + 1
		if codingEntries[index].DisplayName == "" {
			codingEntries[index].DisplayName = fmt.Sprintf("User %d", index+1)
		}
	}

	return entries, codingEntries, nil
}

func trimLeaderboard(
	entries []progressLeaderboardUser,
	currentUserID string,
	limit int,
) []progressLeaderboardUser {
	if len(entries) <= limit {
		return entries
	}

	currentIndex := -1
	for index, entry := range entries {
		if entry.ID == currentUserID {
			currentIndex = index
			break
		}
	}

	if currentIndex == -1 || currentIndex < limit {
		return entries[:limit]
	}

	trimmed := make([]progressLeaderboardUser, 0, limit)
	trimmed = append(trimmed, entries[:limit-1]...)
	trimmed = append(trimmed, entries[currentIndex])
	return trimmed
}

func rewardForDifficulty(difficulty string) (int, bool) {
	reward, ok := solveCoinRewards[strings.ToLower(strings.TrimSpace(difficulty))]
	return reward, ok
}

func normalizeQuestionIDs(ids []string) []string {
	seen := make(map[string]struct{}, len(ids))
	normalized := make([]string, 0, len(ids))

	for _, rawID := range ids {
		id := strings.TrimSpace(rawID)
		if id == "" {
			continue
		}
		if _, exists := seen[id]; exists {
			continue
		}
		seen[id] = struct{}{}
		normalized = append(normalized, id)
	}

	return normalized
}

func containsQuestionID(ids []string, questionID string) bool {
	for _, id := range ids {
		if id == questionID {
			return true
		}
	}
	return false
}

func mergeQuestionIDs(existing, incoming []string) []string {
	return normalizeQuestionIDs(append(normalizeQuestionIDs(existing), incoming...))
}

func normalizeDailyActivity(activity map[string]int) map[string]int {
	if len(activity) == 0 {
		return map[string]int{}
	}

	normalized := make(map[string]int, len(activity))
	for key, count := range activity {
		trimmedKey := strings.TrimSpace(key)
		if trimmedKey == "" || count <= 0 {
			continue
		}
		normalized[trimmedKey] = count
	}

	return normalized
}

func normalizeDailyActivityBreakdown(breakdown map[string]map[string]int) map[string]map[string]int {
	if len(breakdown) == 0 {
		return map[string]map[string]int{}
	}

	normalized := make(map[string]map[string]int, len(breakdown))
	for dateKey, sectionMap := range breakdown {
		trimmedDateKey := strings.TrimSpace(dateKey)
		if trimmedDateKey == "" || len(sectionMap) == 0 {
			continue
		}
		
		normalizedMap := make(map[string]int, len(sectionMap))
		for sectionKey, count := range sectionMap {
			trimmedSectionKey := strings.TrimSpace(sectionKey)
			if trimmedSectionKey == "" || count <= 0 {
				continue
			}
			normalizedMap[trimmedSectionKey] = count
		}
		
		if len(normalizedMap) > 0 {
			normalized[trimmedDateKey] = normalizedMap
		}
	}

	return normalized
}

func mergeDailyActivity(existing, incoming map[string]int) map[string]int {
	merged := normalizeDailyActivity(existing)
	for key, count := range normalizeDailyActivity(incoming) {
		if merged[key] < count {
			merged[key] = count
		}
	}
	return merged
}

func countActiveDays(activity map[string]int) int {
	activeDays := 0
	for _, count := range activity {
		if count > 0 {
			activeDays++
		}
	}
	return activeDays
}

func weeklySolvedCount(activity map[string]int, timeZone string, now time.Time) int {
	if len(activity) == 0 {
		return 0
	}

	loc := mustLoadLocation(resolveStreakTimeZone("", timeZone))
	localNow := now.In(loc)
	total := 0

	for offset := 0; offset < 7; offset++ {
		currentDay := time.Date(localNow.Year(), localNow.Month(), localNow.Day(), 12, 0, 0, 0, loc).AddDate(0, 0, -offset)
		total += activity[currentDay.Format("2006-01-02")]
	}

	return total
}

func codingWeeklySolvedCount(breakdown map[string]map[string]int, timeZone string, now time.Time) int {
	if len(breakdown) == 0 {
		return 0
	}

	loc := mustLoadLocation(resolveStreakTimeZone("", timeZone))
	localNow := now.In(loc)
	total := 0

	for offset := 0; offset < 7; offset++ {
		currentDay := time.Date(localNow.Year(), localNow.Month(), localNow.Day(), 12, 0, 0, 0, loc).AddDate(0, 0, -offset)
		dayKey := currentDay.Format("2006-01-02")
		if sectionMap, ok := breakdown[dayKey]; ok {
			total += sectionMap["coding"]
		}
	}

	return total
}

func codingCurrentStreak(breakdown map[string]map[string]int, timeZone string, now time.Time) int {
	if len(breakdown) == 0 {
		return 0
	}
	loc := mustLoadLocation(resolveStreakTimeZone("", timeZone))
	localNow := now.In(loc)
	streak := 0
	
	todayKey := localNow.Format("2006-01-02")
	yesterdayKey := localNow.AddDate(0, 0, -1).Format("2006-01-02")
	
	todayCoding := 0
	if breakdown[todayKey] != nil {
		todayCoding = breakdown[todayKey]["coding"]
	}
	yesterdayCoding := 0
	if breakdown[yesterdayKey] != nil {
		yesterdayCoding = breakdown[yesterdayKey]["coding"]
	}
	
	if todayCoding == 0 && yesterdayCoding == 0 {
		return 0
	}
	
	currentDay := localNow
	if todayCoding == 0 {
		currentDay = localNow.AddDate(0, 0, -1)
	}
	
	for {
		dayKey := currentDay.Format("2006-01-02")
		codingCount := 0
		if breakdown[dayKey] != nil {
			codingCount = breakdown[dayKey]["coding"]
		}
		if codingCount > 0 {
			streak++
			currentDay = currentDay.AddDate(0, 0, -1)
		} else {
			break
		}
	}
	
	return streak
}

func activityDateKey(now time.Time, timeZone string) string {
	loc := mustLoadLocation(resolveStreakTimeZone("", timeZone))
	return now.In(loc).Format("2006-01-02")
}

func streakSnapshotFromActivity(activity map[string]int, timeZone string) streakSnapshot {
	if len(activity) == 0 {
		return streakSnapshot{}
	}

	loc := mustLoadLocation(resolveStreakTimeZone("", timeZone))
	days := make([]time.Time, 0, len(activity))
	for key, count := range activity {
		if count <= 0 {
			continue
		}
		parsed, err := time.ParseInLocation("2006-01-02", key, loc)
		if err != nil {
			continue
		}
		days = append(days, parsed)
	}

	if len(days) == 0 {
		return streakSnapshot{}
	}

	sort.Slice(days, func(i, j int) bool {
		return days[i].Before(days[j])
	})

	longestStreak := 1
	currentRun := 1
	for index := 1; index < len(days); index++ {
		dayDelta := int(days[index].Sub(days[index-1]).Hours() / 24)
		switch {
		case dayDelta <= 0:
			continue
		case dayDelta == 1:
			currentRun++
		default:
			currentRun = 1
		}
		if longestStreak < currentRun {
			longestStreak = currentRun
		}
	}

	currentStreak := 1
	for index := len(days) - 1; index > 0; index-- {
		dayDelta := int(days[index].Sub(days[index-1]).Hours() / 24)
		if dayDelta != 1 {
			break
		}
		currentStreak++
	}

	lastActiveAt := time.Date(days[len(days)-1].Year(), days[len(days)-1].Month(), days[len(days)-1].Day(), 12, 0, 0, 0, loc).UTC()
	return streakSnapshot{
		CurrentStreak: currentStreak,
		LongestStreak: longestStreak,
		LastActiveAt:  lastActiveAt,
	}
}

type coinTransactionDoc struct {
	ID        primitive.ObjectID `bson:"_id" json:"id"`
	UserID    string             `bson:"userId" json:"userId"`
	Amount    int                `bson:"amount" json:"amount"`
	Source    string             `bson:"source" json:"source"`
	Category  string             `bson:"category" json:"category"`
	CreatedAt time.Time          `bson:"createdAt" json:"createdAt"`
}

func recordCoinTransaction(ctx context.Context, coll *mongo.Collection, userID primitive.ObjectID, amount int, source string, category string) error {
	doc := coinTransactionDoc{
		ID:        primitive.NewObjectID(),
		UserID:    userID.Hex(),
		Amount:    amount,
		Source:    source,
		Category:  category,
		CreatedAt: time.Now().UTC(),
	}
	_, err := coll.Database().Collection("coin_transactions").InsertOne(ctx, doc)
	return err
}

func handleGetCoinHistory(coll *mongo.Collection) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodGet {
			jsonError(w, http.StatusMethodNotAllowed, "Method not allowed")
			return
		}

		doc, _, statusCode, err := authenticatedUser(r, coll)
		if err != nil {
			jsonError(w, statusCode, err.Error())
			return
		}

		cursor, err := coll.Database().Collection("coin_transactions").Find(r.Context(), bson.M{"userId": doc.ID.Hex()}, options.Find().SetSort(bson.M{"createdAt": -1}))
		if err != nil {
			jsonError(w, http.StatusInternalServerError, "Failed to fetch coin history.")
			return
		}
		defer cursor.Close(r.Context())

		var transactions []coinTransactionDoc
		if err := cursor.All(r.Context(), &transactions); err != nil {
			jsonError(w, http.StatusInternalServerError, "Failed to fetch coin history.")
			return
		}

		if transactions == nil {
			transactions = []coinTransactionDoc{}
		}

		sum := 0
		for _, tx := range transactions {
			sum += tx.Amount
		}

		if doc.Coins > sum {
			legacyAmount := doc.Coins - sum
			
			createdAt := doc.CreatedAt
			if createdAt.IsZero() {
				createdAt = time.Now().UTC()
			}
			
			transactions = append(transactions, coinTransactionDoc{
				ID:        primitive.NewObjectID(),
				UserID:    doc.ID.Hex(),
				Amount:    legacyAmount,
				Source:    "Initial Balance",
				Category:  "bonus",
				CreatedAt: createdAt,
			})
		}

		jsonWrite(w, http.StatusOK, transactions)
	}
}