package fiber

import (
	"sync"
)

// State is a thread-safe global key-value store for app dependencies.
type State struct {
	dependencies sync.Map
}

// NewState creates and returns a new instance of State.
func NewState() *State {
	return &State{
		dependencies: sync.Map{},
	}
}

// Set sets a key-value pair in the State.
func (s *State) Set(key string, value any) {
	s.dependencies.Store(key, value)
}

// Get retrieves a value from the State.
func (s *State) Get(key string) (any, bool) {
	return s.dependencies.Load(key)
}

// GetString retrieves a string value from the State.
func (s *State) GetString(key string) (string, bool) {
	dep, ok := s.Get(key)
	if ok {
		if depString, okCast := dep.(string); okCast {
			return depString, true
		}
	}
	return "", false
}

// GetInt retrieves an int value from the State.
func (s *State) GetInt(key string) (int, bool) {
	dep, ok := s.Get(key)
	if ok {
		if depInt, okCast := dep.(int); okCast {
			return depInt, true
		}
	}
	return 0, false
}

// GetBool retrieves a bool value from the State.
func (s *State) GetBool(key string) (bool, bool) {
	dep, ok := s.Get(key)
	if ok {
		if depBool, okCast := dep.(bool); okCast {
			return depBool, true
		}
	}
	return false, false
}

// GetFloat64 retrieves a float64 value from the State.
func (s *State) GetFloat64(key string) (float64, bool) {
	dep, ok := s.Get(key)
	if ok {
		if depFloat64, okCast := dep.(float64); okCast {
			return depFloat64, true
		}
	}
	return 0, false
}

// MustGet retrieves a value from the State and panics if the key is not found.
func (s *State) MustGet(key string) any {
	if dep, ok := s.Get(key); ok {
		return dep
	}
	panic("state: dependency not found!")
}

// Delete removes a key from the State.
func (s *State) Delete(key string) {
	s.dependencies.Delete(key)
}

// Clear removes all key-value pairs from the State.
func (s *State) Clear() {
	s.dependencies.Range(func(key, _ any) bool {
		s.dependencies.Delete(key)
		return true
	})
}

// Keys retrieves all the keys from the State.
func (s *State) Keys() []string {
	keys := make([]string, 0)
	s.dependencies.Range(func(key, _ any) bool {
		if keyStr, ok := key.(string); ok {
			keys = append(keys, keyStr)
		}
		return true
	})
	return keys
}

// Len returns the number of dependencies in the State.
func (s *State) Len() int {
	length := 0
	s.dependencies.Range(func(_, _ any) bool {
		length++
		return true
	})
	return length
}

// Has checks if the given key exists in the State.
func (s *State) Has(key string) bool {
	_, ok := s.Get(key)
	return ok
}

// GetState retrieves a value from the State, casting it to the desired type.
func (s *State) GetState[T any](key string) (T, bool) {
	dep, ok := s.Get(key)
	if ok {
		if depT, okCast := dep.(T); okCast {
			return depT, true
		}
	}
	var zeroVal T
	return zeroVal, false
}

// MustGetState retrieves a value from the State, casting it to the desired type.
// It panics if the key is not found.
func (s *State) MustGetState[T any](key string) T {
	val, ok := s.GetState[T](key)
	if !ok {
		panic("state: dependency not found!")
	}
	return val
}

// GetWithDefault retrieves a value from the State, casting it to the desired type.
// If the key is not found or the type assertion fails, it returns the provided default value.
func (s *State) GetWithDefault[T any](key string, defaultValue T) T {
	if val, ok := s.Get(key); ok {
		if typed, ok := val.(T); ok {
			return typed
		}
	}
	return defaultValue
}