package handler

import (
	"strings"
	"time"
	"xboard-go/internal/database"
	"xboard-go/internal/model"
	"xboard-go/internal/service"

	"github.com/gin-gonic/gin"
)

func PluginUserOnlineDevicesUsers(c *gin.Context) {

	page := parsePositiveInt(c.DefaultQuery("page", "1"), 1)
	perPage := parsePositiveInt(c.DefaultQuery("per_page", "20"), 20)
	keyword := strings.TrimSpace(c.Query("keyword"))

	query := database.DB.Model(&model.User{}).Order("id DESC")
	if keyword != "" {
		query = query.Where("email LIKE ? OR id = ?", "%"+keyword+"%", keyword)
	}

	var total int64
	query.Count(&total)

	var users []model.User
	if err := query.Offset((page - 1) * perPage).Limit(perPage).Find(&users).Error; err != nil {
		Fail(c, 500, "failed to fetch users")
		return
	}

	userIDs := make([]int, 0, len(users))
	for _, user := range users {
		userIDs = append(userIDs, user.ID)
	}
	devices := service.GetUsersDevices(userIDs)

	list := make([]gin.H, 0, len(users))
	usersWithOnlineIP := 0
	totalOnlineIPs := 0
	for _, user := range users {
		subscriptionName := "No subscription"
		if user.PlanID != nil {
			var plan model.Plan
			if database.DB.First(&plan, *user.PlanID).Error == nil {
				subscriptionName = plan.Name
			}
		}

		ips := devices[user.ID]
		if len(ips) > 0 {
			usersWithOnlineIP++
			totalOnlineIPs += len(ips)
		}

		list = append(list, gin.H{
			"id":                user.ID,
			"email":             user.Email,
			"subscription_name": subscriptionName,
			"online_count":      len(ips),
			"online_devices":    ips,
			"last_online_text":  formatTimeValue(user.LastOnlineAt),
			"created_text":      formatUnixValue(user.CreatedAt),
		})
	}

	Success(c, gin.H{
		"list": list,
		"filters": gin.H{
			"keyword":  keyword,
			"per_page": perPage,
		},
		"summary": gin.H{
			"page_users":           len(users),
			"users_with_online_ip": usersWithOnlineIP,
			"total_online_ips":     totalOnlineIPs,
			"current_page":         page,
		},
		"pagination": gin.H{
			"current":   page,
			"last_page": calculateLastPage(total, perPage),
			"per_page":  perPage,
			"total":     total,
		},
	})
}

func PluginUserOnlineDevicesGetIP(c *gin.Context) {

	user, ok := currentUser(c)
	if !ok {
		Fail(c, 401, "unauthorized")
		return
	}

	devices := service.GetUsersDevices([]int{user.ID})
	ips := devices[user.ID]
	authToken, _ := c.Get("auth_token")
	currentToken, _ := authToken.(string)
	sessions := service.GetUserSessions(user.ID, currentToken)
	currentID := currentSessionID(c)

	sessionItems := make([]gin.H, 0, len(sessions))
	for _, session := range sessions {
		sessionItems = append(sessionItems, gin.H{
			"id":           session.ID,
			"name":         session.Name,
			"user_agent":   session.UserAgent,
			"ip":           firstString(session.IP, "-"),
			"created_at":   session.CreatedAt,
			"last_used_at": session.LastUsedAt,
			"expires_at":   session.ExpiresAt,
			"is_current":   session.ID == currentID,
		})
	}
	Success(c, gin.H{
		"ips": ips,
		"session_overview": gin.H{
			"online_ip_count":      len(ips),
			"online_ips":           ips,
			"online_device_count":  len(ips),
			"device_limit":         user.DeviceLimit,
			"last_online_at":       user.LastOnlineAt,
			"active_session_count": len(sessionItems),
			"sessions":             sessionItems,
		},
	})
}

func PluginUserAddIPv6Check(c *gin.Context) {

	user, ok := currentUser(c)
	if !ok {
		Fail(c, 401, "unauthorized")
		return
	}

	if user.PlanID == nil {
		Success(c, gin.H{"allowed": false, "reason": "No active plan"})
		return
	}

	var plan model.Plan
	if err := database.DB.First(&plan, *user.PlanID).Error; err != nil {
		Success(c, gin.H{"allowed": false, "reason": "No active plan"})
		return
	}

	ipv6Email := service.IPv6ShadowEmail(user.Email)
	var count int64
	database.DB.Model(&model.User{}).Where("email = ?", ipv6Email).Count(&count)

	Success(c, gin.H{
		"allowed":   service.PluginPlanAllowed(&plan),
		"is_active": count > 0,
	})
}

func PluginUserAddIPv6Enable(c *gin.Context) {

	user, ok := currentUser(c)
	if !ok {
		Fail(c, 401, "unauthorized")
		return
	}

	if !service.SyncIPv6ShadowAccount(user) {
		Fail(c, 403, "your plan does not support IPv6 subscription")
		return
	}

	SuccessMessage(c, "IPv6 subscription enabled/synced", true)
}

func PluginUserAddIPv6SyncPassword(c *gin.Context) {

	user, ok := currentUser(c)
	if !ok {
		Fail(c, 401, "unauthorized")
		return
	}

	ipv6Email := service.IPv6ShadowEmail(user.Email)
	result := database.DB.Model(&model.User{}).Where("email = ?", ipv6Email).Update("password", user.Password)
	if result.Error != nil {
		Fail(c, 404, "IPv6 user not found")
		return
	}
	if result.RowsAffected == 0 {
		Fail(c, 404, "IPv6 user not found")
		return
	}

	SuccessMessage(c, "Password synced to IPv6 account", true)
}



func AdminSystemStatus(c *gin.Context) {
	Success(c, gin.H{
		"server_time": time.Now().Unix(),
		"app_name":    service.MustGetString("app_name", "XBoard"),
		"app_url":     service.GetAppURL(),
		"version":     "1.0.0",
		"go_version":  "1.21+",
	})
}

// AdminSystemQueueStats returns empty queue stats (Go app has no Horizon/queue workers).
// The React frontend polls this endpoint; returning empty data prevents 404 polling errors.
func AdminSystemQueueStats(c *gin.Context) {
	Success(c, gin.H{
		"workload":     []any{},
		"masters":      []any{},
		"failed_jobs":  0,
		"total_jobs":   0,
		"pending_jobs": 0,
		"processed":    0,
		"failed":       0,
	})
}