package repository

import (
	"context"
	"fmt"
	"strconv"
	"time"

	dbgen "github.com/SamuelTariku/FortuneBet-Backend/gen/db"
	"github.com/SamuelTariku/FortuneBet-Backend/internal/domain"
	"go.uber.org/zap"
)

func GetDBSettingList(settings []dbgen.Setting) (domain.SettingList, error) {
	var dbSettingList domain.ValidSettingList

	var int64SettingsMap = domain.ConvertInt64SettingsMap(&dbSettingList)
	var stringSettingsMap = domain.ConvertStringSettingsMap(&dbSettingList)
	var boolSettingsMap = domain.ConvertBoolSettingsMap(&dbSettingList)
	var float32SettingsMap = domain.ConvertFloat32SettingsMap(&dbSettingList)
	var timeSettingsMap = domain.ConvertTimeSettingsMap(&dbSettingList)

	for _, setting := range settings {
		isSettingUnknown := true
		for key, dbSetting := range int64SettingsMap {
			if setting.Key == key {
				value, err := strconv.ParseInt(setting.Value, 10, 64)
				if err != nil {
					return domain.SettingList{}, err
				}
				*dbSetting = domain.ValidInt64{
					Value: value,
					Valid: true,
				}
				isSettingUnknown = false
			}
		}

		for key, dbSetting := range stringSettingsMap {
			if setting.Key == key {
				*dbSetting = domain.ValidString{
					Value: setting.Value,
					Valid: true,
				}
				isSettingUnknown = false
			}
		}

		for key, dbSetting := range boolSettingsMap {
			if setting.Key == key {
				value, err := strconv.ParseBool(setting.Value)
				if err != nil {
					return domain.SettingList{}, err
				}
				*dbSetting = domain.ValidBool{
					Value: value,
					Valid: true,
				}
				isSettingUnknown = false
			}
		}

		for key, dbSetting := range float32SettingsMap {
			if setting.Key == key {
				value, err := strconv.ParseFloat(setting.Value, 32)
				if err != nil {
					return domain.SettingList{}, err
				}
				*dbSetting = domain.ValidFloat32{
					Value: float32(value),
					Valid: true,
				}
				isSettingUnknown = false
			}
		}
		for key, dbSetting := range timeSettingsMap {
			if setting.Key == key {
				value, err := time.Parse(time.RFC3339, setting.Value)
				if err != nil {
					return domain.SettingList{}, err
				}
				*dbSetting = domain.ValidTime{
					Value: value,
					Valid: true,
				}
				isSettingUnknown = false
			}
		}

		if isSettingUnknown {
			domain.MongoDBLogger.Warn("unknown setting found on database", zap.String("setting", setting.Key))
		}
	}

	for key, dbSetting := range int64SettingsMap {
		if !dbSetting.Valid {
			fmt.Printf("setting value not found on database: %v \n", key)
			domain.MongoDBLogger.Warn("setting value not found on database", zap.String("setting", key))
		}
	}

	return domain.ValidateSettingList(dbSettingList), nil
}
func (s *Store) GetSettingList(ctx context.Context) (domain.SettingList, error) {
	settings, err := s.queries.GetSettings(ctx)
	if err != nil {
		domain.MongoDBLogger.Error("failed to get all settings", zap.Error(err))
	}

	return GetDBSettingList(settings)
}

func (s *Store) GetSettings(ctx context.Context) ([]domain.Setting, error) {
	settings, err := s.queries.GetSettings(ctx)

	if err != nil {
		domain.MongoDBLogger.Error("failed to get all settings", zap.Error(err))
	}

	var result []domain.Setting = make([]domain.Setting, 0, len(settings))
	for _, setting := range settings {
		result = append(result, domain.Setting{
			Key:       setting.Key,
			Value:     setting.Value,
			UpdatedAt: setting.UpdatedAt.Time,
		})
	}

	return result, nil
}

func (s *Store) GetSetting(ctx context.Context, key string) (domain.Setting, error) {
	dbSetting, err := s.queries.GetSetting(ctx, key)

	if err != nil {
		domain.MongoDBLogger.Error("failed to get all settings", zap.Error(err))
	}

	result := domain.Setting{
		Key:       dbSetting.Key,
		Value:     dbSetting.Value,
		UpdatedAt: dbSetting.UpdatedAt.Time,
	}

	return result, nil
}

func (s *Store) UpdateSetting(ctx context.Context, key, value string) error {
	err := s.queries.UpdateSetting(ctx, dbgen.UpdateSettingParams{
		Key:   key,
		Value: value,
	})

	if err != nil {
		domain.MongoDBLogger.Error("failed to update setting", zap.String("key", key), zap.String("value", value), zap.Error(err))

		return err
	}

	return err

}

func (s *Store) UpdateSettingList(ctx context.Context, settingList domain.ValidSettingList) error {
	convertedSettings := domain.ConvertValidSettingList(settingList)

	for _, setting := range convertedSettings {
		err := s.UpdateSetting(ctx, setting.Key, setting.Value)
		if err != nil {
			domain.MongoDBLogger.Warn("failed to update setting list", zap.String("key", setting.Key), zap.Error(err))
			return err
		}
	}
	return nil
}