package config

import (
	"fmt"
	"log"
	"os"
	"strconv"
	"strings"
	"time"

	"github.com/go-playground/validator/v10"
)
type Config struct {
	Server       ServerConfig
	Validator    *validator.Validate
}
type ServerConfig struct {
	Port int
	Mode string
}

func LoadConfig() *Config {
	log.Printf("DEBUG: Raw ENV for SECURITY_MAX_INPUT_LENGTH is: '%s'", os.Getenv("SECURITY_MAX_INPUT_LENGTH"))
	config := &Config{
		Server: ServerConfig{
			Port: getEnvAsInt("PORT", 8080),
			Mode: getEnv("GIN_MODE", "debug"),
		},
	}
	// log.Printf("DEBUG: Final Config Object. MaxInputLength is: %d", config.Security.MaxInputLength)
	// Initialize validator
	config.Validator = validator.New()
	return config
}


// Lakukan hal yang sama untuk loadKeycloakConfig


// Helper functions for getting default values based on database type
func getDefaultPort(dbType string) int {
	switch dbType {
	case "postgres":
		return 5432
	case "mysql":
		return 3306
	case "sqlserver":
		return 1433
	case "mongodb":
		return 27017
	case "sqlite":
		return 0 // SQLite doesn't use port
	default:
		return 5432
	}
}

func getDefaultSchema(dbType string) string {
	switch dbType {
	case "postgres":
		return "public"
	case "mysql":
		return ""
	case "sqlserver":
		return "dbo"
	case "mongodb":
		return ""
	case "sqlite":
		return ""
	default:
		return "public"
	}
}

func getDefaultSSLMode(dbType string) string {
	switch dbType {
	case "postgres":
		return "disable"
	case "mysql":
		return "false"
	case "sqlserver":
		return "false"
	case "mongodb":
		return "false"
	case "sqlite":
		return ""
	default:
		return "disable"
	}
}

func getDefaultMaxOpenConns(dbType string) int {
	switch dbType {
	case "postgres":
		return 25
	case "mysql":
		return 25
	case "sqlserver":
		return 25
	case "mongodb":
		return 100
	case "sqlite":
		return 1 // SQLite only supports one writer at a time
	default:
		return 25
	}
}

func getDefaultMaxIdleConns(dbType string) int {
	switch dbType {
	case "postgres":
		return 25
	case "mysql":
		return 25
	case "sqlserver":
		return 25
	case "mongodb":
		return 10
	case "sqlite":
		return 1 // SQLite only supports one writer at a time
	default:
		return 25
	}
}

func getDefaultConnMaxLifetime(dbType string) string {
	switch dbType {
	case "postgres":
		return "5m"
	case "mysql":
		return "5m"
	case "sqlserver":
		return "5m"
	case "mongodb":
		return "30m"
	case "sqlite":
		return "5m"
	default:
		return "5m"
	}
}

func getEnvFromMap(config map[string]string, key, defaultValue string) string {
	if value, exists := config[key]; exists {
		return value
	}
	return defaultValue
}

func getEnvAsIntFromMap(config map[string]string, key string, defaultValue int) int {
	if value, exists := config[key]; exists {
		if intValue, err := strconv.Atoi(value); err == nil {
			return intValue
		}
	}
	return defaultValue
}

func getEnvAsBoolFromMap(config map[string]string, key string, defaultValue bool) bool {
	if value, exists := config[key]; exists {
		if boolValue, err := strconv.ParseBool(value); err == nil {
			return boolValue
		}
	}
	return defaultValue
}

func parseDuration(durationStr string) time.Duration {
	if duration, err := time.ParseDuration(durationStr); err == nil {
		return duration
	}
	return 5 * time.Minute
}

func getEnv(key, defaultValue string) string {
	if value := os.Getenv(key); value != "" {
		return value
	}
	return defaultValue
}

func getEnvAsInt(key string, defaultValue int) int {
	valueStr := getEnv(key, "")
	if value, err := strconv.Atoi(valueStr); err == nil {
		return value
	}
	return defaultValue
}

func getEnvAsBool(key string, defaultValue bool) bool {
	valueStr := getEnv(key, "")
	if value, err := strconv.ParseBool(valueStr); err == nil {
		return value
	}
	return defaultValue
}

// parseSchemes parses comma-separated schemes string into a slice
func parseSchemes(schemesStr string) []string {
	if schemesStr == "" {
		return []string{"http"}
	}

	schemes := strings.Split(schemesStr, ",")
	for i, scheme := range schemes {
		schemes[i] = strings.TrimSpace(scheme)
	}
	return schemes
}

// parseStaticTokens parses comma-separated static tokens string into a slice
func parseStaticTokens(tokensStr string) []string {
	if tokensStr == "" {
		return []string{}
	}

	tokens := strings.Split(tokensStr, ",")
	for i, token := range tokens {
		tokens[i] = strings.TrimSpace(token)
		// Remove empty tokens
		if tokens[i] == "" {
			tokens = append(tokens[:i], tokens[i+1:]...)
			i--
		}
	}
	return tokens
}

func parseOrigins(originsStr string) []string {
	if originsStr == "" {
		return []string{"http://localhost:8080"} // Default untuk pengembangan
	}
	origins := strings.Split(originsStr, ",")
	for i, origin := range origins {
		origins[i] = strings.TrimSpace(origin)
	}
	return origins
}

func (c *Config) Validate() error {
	var errs []string

	if len(errs) > 0 {
		return fmt.Errorf("configuration validation failed: %s", strings.Join(errs, "; "))
	}
	return nil
}