package main

import (
	"fmt"
	"log"
	"reflect"
)

type (
	SettingsService struct {
		db *DB
	}
)

type settings struct {
	FoodDaysLookback           int `default:"30" json:"foodDaysLookback"`
	FoodAggregatedDaysLookback int `default:"30" json:"foodAggregatedDaysLookback"`
	FoodDailyLookback          int `default:"30" json:"foodDailyLookback"`
	FoodWeeklyLookback         int `default:"4" json:"foodWeeklyLookback"`
	FoodMonthlyLookback        int `default:"4" json:"foodMonthlyLookback"`
	FoodYearlyLookback         int `default:"2" json:"foodYearlyLookback"`

	WeightDaysLookback           int `default:"30" json:"weightDaysLookback"`
	WeightAggregatedDaysLookback int `default:"30" json:"weightAggregatedDaysLookback"`
	WeightDailyLookback          int `default:"30" json:"weightDailyLookback"`
	WeightWeeklyLookback         int `default:"4" json:"weightWeeklyLookback"`
	WeightMonthlyLookback        int `default:"4" json:"weightMonthlyLookback"`
	WeightYearlyLookback         int `default:"2" json:"weightYearlyLookback"`

	Target int `default:"2000" json:"target"`
}

var Settings settings

func (s *SettingsService) LoadSettings() error {
	if s.db == nil || !s.db.Ready {
		return fmt.Errorf("cannot load Settings, db is nil or is not ready")
	}

	settingsValue := reflect.ValueOf(&Settings).Elem()
	settingsType := settingsValue.Type()

	for i := 0; i < settingsValue.NumField(); i++ {
		field := settingsType.Field(i)
		key := field.Name

		var value int
		err := s.db.readConn.QueryRow("SELECT value FROM settings WHERE key = ?", key).Scan(&value)
		if err != nil {
			log.Printf("error getting setting for key %s: %v; setting default", key, err)
			_, err := s.db.writeConn.Exec("INSERT INTO settings (key, value) VALUES (?, ?)", key, field.Tag.Get("default"))
			if err != nil {
				Error.Printf("error inserting setting for key %s: %v", key, err)
				continue
			}
		}

		settingsValue.Field(i).SetInt(int64(value))
		log.Println(key, value)
	}
	return nil
}
func (s *SettingsService) Set(key string, value any) settings {
	fields := reflect.ValueOf(&Settings).Elem()
	for i := 0; i < fields.NumField(); i++ {
		field := fields.Type().Field(i)
		if field.Name == key {
			fields.Field(i).SetInt(value.(int64))

			// This could cause desync between client and server
			// But we can just refresh, I think it's fine
			go func() {
				_, err := s.db.writeConn.Exec("UPDATE settings SET value = ? WHERE key = ?", value, key)
				if err != nil {
					Error.Printf("error updating setting for key %s: %v", key)
				}
			}()

			return Settings
		}
	}
	return Settings
}