Reading & Writing Settings

final class SettingsResolver
{
    public function __construct(
        private readonly ApplicationSettingsRepository $appSettings,
        private readonly TenantSettingsRepository $tenantSettings,
        private readonly UserSettingsRepository $userSettings,
    ) {}

    public function get(SettingKey $key, ?Tenant $tenant = null, ?User $user = null): mixed
    {
        return $this->resolve($key, $tenant, $user)['value'];
    }

    public function resolve(SettingKey $key, ?Tenant $tenant = null, ?User $user = null): array
    {
        // Checks User → Tenant → Application → default
        // Returns ['value' => ..., 'source' => 'user'|'tenant'|'application'|'default']
    }

    public function all(?Tenant $tenant = null, ?User $user = null): array
    {
        // Returns all non-sensitive settings with their resolved values and sources
    }
}

final class ApplicationSettingsRepository
{
    public function get(SettingKey $key): mixed
    {
        $all = $this->all();
        return $all[$key->value] ?? null;
    }

    public function all(): array
    {
        return $this->cache->rememberApplication(function (): array {
            return ApplicationSetting::query()
                ->pluck('value', 'key')
                ->toArray();
        });
    }

    public function update(array $settings): array
    {
        $updated = [];
        foreach ($settings as $key => $value) {
            ApplicationSetting::updateOrCreate(
                ['key' => $key],
                ['value' => $value]
            );
            $updated[] = $key;
        }
        $this->cache->invalidateApplication();
        return $updated;
    }
}

public function rules(): array
{
    // Empty — dot-notation keys break Laravel's array-based validation
    return [];
}

public function after(): array
{
    return [
        function (Validator $validator): void {
            $this->validateSettings($validator, SettingScope::User);
        },
    ];
}

private function validateSettings(Validator $validator, SettingScope $scope): void
{
    foreach ($this->all() as $key => $value) {
        $settingKey = SettingKey::tryFromString($key);

        // Check if key is registered
        if ($settingKey === null) {
            $validator->errors()->add($key, __('settings.unknown_key', ['key' => $key]));
            continue;
        }

        // Check if key is allowed at this scope
        if (! $settingKey->allowedAtScope($scope)) {
            $validator->errors()->add($key, __('settings.scope_violation', [
                'key' => $key, 'scope' => $scope->value
            ]));
            continue;
        }

        // Validate value against the setting's type-specific rules
        $rules = $settingKey->definition()->validationRules();
        if (! empty($rules)) {
            $valueValidator = ValidatorFacade::make(
                ['value' => $value],
                ['value' => $rules]
            );

            if ($valueValidator->fails()) {
                foreach ($valueValidator->errors()->get('value') as $error) {
                    $validator->errors()->add($key, $error);
                }
            }
        }
    }
}

export function useSettings() {
  const store = useSettingsStore()

  return {
    // State
    settings: computed(() => store.settings),
    loaded: computed(() => store.isLoaded),
    loading: computed(() => store.isLoading),
    error: computed(() => store.error),

    // Shortcuts for common settings
    locale: computed(() => store.locale),
    timezone: computed(() => store.timezone),
    currency: computed(() => store.currency),
    fallbackCurrency: computed(() => store.fallbackCurrency),
    appName: computed(() => store.appName),
    publicCurrencies: computed(() => store.publicCurrencies),

    // Methods
    load: () => store.load(),
    reload: () => store.reload(),
    clear: () => store.clear(),
    get: store.get,            // get<K>(key, fallback) → typed value
    getWithSource: store.getWithSource,  // getWithSource<K>(key) → { value, source }
    has: store.has,
  }
}

export function useUserSettings() {
  const store = useSettingsStore()

  return {
    updating: computed(() => store.isUpdatingUser),
    error: computed(() => store.userError),

    update: (payload: UserSettingsPayload) => store.updateUser(payload),
    updateLocale: (locale: LocaleCode) => store.updateUser({ 'i18n.locale': locale }),
    updateTimezone: (timezone: string) => store.updateUser({ 'time.timezone': timezone }),
  }
}

export function useTenantSettings() {
  const store = useSettingsStore()

  return {
    updating: computed(() => store.isUpdatingTenant),
    error: computed(() => store.tenantError),

    update: (payload: TenantSettingsPayload) => store.updateTenant(payload),
  }
}

export function useSettingsLocale() {
  const settings = useSettings()
  const userSettings = useUserSettings()
  const switchLocalePath = useSwitchLocalePath()
  const auth = useAuth()

  const currentLocale = computed<LocaleCode>(() => settings.get('i18n.locale', 'en'))

  const availableLocales = computed(() =>
    configuredLocales.map((l) => ({
      code: l.code as LocaleCode,
      name: l.name,
    }))
  )

  async function changeLocale(newLocale: LocaleCode): Promise<void> {
    // Navigate to locale-prefixed route for immediate UI switch
    await navigateTo(switchLocalePath(newLocale))

    // Persist to backend if authenticated
    if (auth.isAuthenticated.value) {
      await userSettings.updateLocale(newLocale)
    }
  }

  return { currentLocale, availableLocales, changeLocale, isUpdating: userSettings.updating }
}

export default defineNuxtPlugin(async () => {
  if (process.env.VITEST) return

  const settingsStore = useSettingsStore()
  await settingsStore.loadPublic()
})

export default defineNuxtPlugin(async (nuxtApp) => {
  const authStore = useAuthStore()
  const settingsStore = useSettingsStore()

  async function applyLocale(): Promise<void> {
    const userLocale = settingsStore.get('i18n.locale', 'en')
    const i18n = nuxtApp.$i18n
    if (userLocale && i18n?.setLocale) {
      await i18n.setLocale(userLocale)
    }
  }

  // Initial load if already authenticated
  if (authStore.isAuthenticated) {
    await nuxtApp.runWithContext(() => settingsStore.load())
    await applyLocale()
  }

  // Watch auth changes — load on login, clear on logout
  watch(
    [() => authStore.isAuthenticated, () => authStore.isInitialized],
    async ([isAuth, isInit]) => {
      if (isAuth && isInit) {
        await nuxtApp.runWithContext(() => settingsStore.load())
        await applyLocale()
      } else if (!isAuth) {
        settingsStore.clear()
      }
    }
  )
})