package settings

import (
	"errors"
	"fmt"
	"reflect"
	"strings"
	"sync"

	"gorm.io/gorm"
	"lst.net/internal/models"
)

var (
	// Global state
	appSettings     []models.Settings
	appSettingsLock sync.RWMutex
	dbInstance      *gorm.DB
)

// Initialize loads settings into memory at startup
func Initialize(db *gorm.DB) error {
	dbInstance = db
	return Refresh()
}

// Refresh reloads settings from DB (call after updates)
func Refresh() error {
	appSettingsLock.Lock()
	defer appSettingsLock.Unlock()

	var settings []models.Settings
	if err := dbInstance.Find(&settings).Error; err != nil {
		return err
	}

	appSettings = settings
	return nil
}

// GetAll returns a thread-safe copy of settings
func GetAll() []models.Settings {
	appSettingsLock.RLock()
	defer appSettingsLock.RUnlock()

	// Return copy to prevent external modification
	copied := make([]models.Settings, len(appSettings))
	copy(copied, appSettings)
	return copied
}

// GetMap returns settings as []map[string]interface{}
func GetMap() []map[string]interface{} {
	return convertToMap(GetAll())
}

// convertToMap helper (move your existing conversion logic here)
func convertToMap(settings []models.Settings) []map[string]interface{} {
	toLowercase := func(s models.Settings) map[string]interface{} {
		t := reflect.TypeOf(s)
		v := reflect.ValueOf(s)

		data := make(map[string]interface{})

		for i := 0; i < t.NumField(); i++ {
			field := strings.ToLower(t.Field(i).Name)
			data[field] = v.Field(i).Interface()
		}

		return data
	}

	// Convert each struct in settings slice to a map with lowercase keys
	var lowercaseSettings []map[string]interface{}
	for _, setting := range settings {
		lowercaseSettings = append(lowercaseSettings, toLowercase(setting))
	}

	return lowercaseSettings
}

func GetString(name string) (string, error) {
	appSettingsLock.RLock()
	defer appSettingsLock.RUnlock()

	for _, s := range appSettings {
		if s.Name == name { // assuming your model has a "Name" field
			fmt.Println(s.Value)
			return s.Value, nil // assuming your model has a "Value" field
		}
	}
	return "", errors.New("setting not found")
}

func SetTemp(name, value string) {
	appSettingsLock.Lock()
	defer appSettingsLock.Unlock()

	for i, s := range appSettings {
		if s.Name == name {
			appSettings[i].Value = value
			return
		}
	}
	// If not found, add new setting
	appSettings = append(appSettings, models.Settings{
		Name:  name,
		Value: value,
	})
}