package controllers

import (
	"strconv"

	"gitea.tbdevent.eu/TBD/reforger_crawler_main/initializers"
	"gitea.tbdevent.eu/TBD/reforger_crawler_main/models"
	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
	"gorm.io/gorm/clause"
)

// SetAddonDependencies replaces all outgoing dependency edges for an addon.
// An empty dependency list is valid and clears the edges.
func SetAddonDependencies(c *gin.Context) {
	var report models.DependencyReport
	if err := c.ShouldBindJSON(&report); err != nil {
		c.JSON(400, gin.H{"error": "Invalid JSON"})
		return
	}

	if report.AddonID == "" {
		c.JSON(400, gin.H{"error": "addonId is required"})
		return
	}

	seen := make(map[string]bool)
	edges := make([]models.AddonDependency, 0, len(report.Dependencies))
	for _, dep := range report.Dependencies {
		if dep.ID == "" || dep.ID == report.AddonID || seen[dep.ID] {
			continue
		}
		seen[dep.ID] = true
		edges = append(edges, models.AddonDependency{
			AddonID:        report.AddonID,
			DependencyID:   dep.ID,
			Version:        dep.Version,
			DependencyName: dep.Name,
		})
	}

	err := initializers.DB.Transaction(func(tx *gorm.DB) error {
		if err := tx.Where("addon_id = ?", report.AddonID).Delete(&models.AddonDependency{}).Error; err != nil {
			return err
		}
		if len(edges) == 0 {
			return nil
		}
		return tx.Clauses(clause.OnConflict{DoNothing: true}).CreateInBatches(&edges, 100).Error
	})
	if err != nil {
		c.JSON(500, gin.H{"error": err.Error()})
		return
	}

	c.JSON(200, gin.H{"status": "success", "stored": len(edges)})
}

// GetDependents returns the addons that depend on the given addon.
func GetDependents(c *gin.Context) {
	addonID := c.Param("id")

	var addon models.Addon
	if err := initializers.DB.Where("id = ?", addonID).First(&addon).Error; err != nil {
		c.JSON(404, gin.H{"error": "Addon not found"})
		return
	}

	limit := parseLimit(c.Query("limit"))

	dependents := []models.AddonSearchResult{}
	err := initializers.DB.Model(&models.Addon{}).
		Select("addons.id, addons.name, addons.type, addons.summary, addons.preview, addons.subscriber_count, addons.current_version_number, addons.author").
		Joins("JOIN addon_dependencies ad ON ad.addon_id = addons.id").
		Where("ad.dependency_id = ?", addonID).
		Order("addons.subscriber_count DESC").
		Limit(limit).
		Find(&dependents).Error
	if err != nil {
		c.JSON(500, gin.H{"error": err.Error()})
		return
	}

	c.JSON(200, models.DependentsResponse{
		AddonID:    addonID,
		Dependents: dependents,
		Total:      len(dependents),
	})
}

// GetDependencies returns the addons that the given addon depends on.
func GetDependencies(c *gin.Context) {
	addonID := c.Param("id")

	var addon models.Addon
	if err := initializers.DB.Where("id = ?", addonID).First(&addon).Error; err != nil {
		c.JSON(404, gin.H{"error": "Addon not found"})
		return
	}

	limit := parseLimit(c.Query("limit"))

	dependencies := []models.AddonSearchResult{}
	err := initializers.DB.Model(&models.Addon{}).
		Select("addons.id, addons.name, addons.type, addons.summary, addons.preview, addons.subscriber_count, addons.current_version_number, addons.author").
		Joins("JOIN addon_dependencies ad ON ad.dependency_id = addons.id").
		Where("ad.addon_id = ?", addonID).
		Order("addons.subscriber_count DESC").
		Limit(limit).
		Find(&dependencies).Error
	if err != nil {
		c.JSON(500, gin.H{"error": err.Error()})
		return
	}

	c.JSON(200, models.DependenciesResponse{
		AddonID:      addonID,
		Dependencies: dependencies,
		Total:        len(dependencies),
	})
}

func parseLimit(raw string) int {
	limit := 100
	if raw != "" {
		if val, err := strconv.Atoi(raw); err == nil && val > 0 {
			limit = val
		}
	}
	if limit > 500 {
		limit = 500
	}
	return limit
}