Why Dependency Injection - Example from LibertyBans

/*
 * LibertyBans
 * Copyright © 2021 Anand Beh
 *
 * LibertyBans is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * LibertyBans is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with LibertyBans. If not, see <https://www.gnu.org/licenses/>
 * and navigate to version 3 of the GNU Affero General Public License.
 */

package space.arim.libertybans.core;

import jakarta.inject.Provider;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import space.arim.api.env.PlatformHandle;
import space.arim.libertybans.api.punish.PunishmentDrafter;
import space.arim.libertybans.core.alts.AltCheckFormatter;
import space.arim.libertybans.core.alts.AltDetection;
import space.arim.libertybans.core.alts.AltNotification;
import space.arim.libertybans.core.commands.extra.StandardTabCompletion;
import space.arim.libertybans.core.commands.extra.TabCompletion;
import space.arim.libertybans.core.config.Configs;
import space.arim.libertybans.core.config.Formatter;
import space.arim.libertybans.core.config.InternalFormatter;
import space.arim.libertybans.core.config.StandardConfigs;
import space.arim.libertybans.core.database.DatabaseManager;
import space.arim.libertybans.core.database.InternalDatabase;
import space.arim.libertybans.core.env.EnvEnforcer;
import space.arim.libertybans.core.env.EnvUserResolver;
import space.arim.libertybans.core.env.Environment;
import space.arim.libertybans.core.env.EnvironmentManager;
import space.arim.libertybans.core.punish.Enactor;
import space.arim.libertybans.core.punish.Enforcer;
import space.arim.libertybans.core.punish.InternalRevoker;
import space.arim.libertybans.core.punish.PunishmentCreator;
import space.arim.libertybans.core.punish.Revoker;
import space.arim.libertybans.core.punish.SecurePunishmentCreator;
import space.arim.libertybans.core.punish.StandardEnforcer;
import space.arim.libertybans.core.scope.InternalScopeManager;
import space.arim.libertybans.core.scope.Scoper;
import space.arim.libertybans.core.selector.ApplicableImpl;
import space.arim.libertybans.core.selector.CaffeineMuteCache;
import space.arim.libertybans.core.selector.IDImpl;
import space.arim.libertybans.core.selector.InternalSelector;
import space.arim.libertybans.core.selector.MuteCache;
import space.arim.libertybans.core.selector.SelectionImpl;
import space.arim.libertybans.core.selector.SelectorImpl;
import space.arim.libertybans.core.service.AsynchronicityManager;
import space.arim.libertybans.core.service.LateBindingFactoryOfTheFuture;
import space.arim.libertybans.core.service.LiveTime;
import space.arim.libertybans.core.service.StandardAsynchronicityManager;
import space.arim.libertybans.core.service.Time;
import space.arim.libertybans.core.uuid.CachingUUIDManager;
import space.arim.libertybans.core.uuid.UUIDManager;
import space.arim.libertybans.it.env.QuackEnforcer;
import space.arim.libertybans.it.env.QuackEnv;
import space.arim.libertybans.it.env.QuackUserResolver;
import space.arim.libertybans.it.env.platform.QuackPlatform;
import space.arim.libertybans.it.env.platform.QuackPlayer;
import space.arim.omnibus.DefaultOmnibus;
import space.arim.omnibus.Omnibus;
import space.arim.omnibus.util.concurrent.FactoryOfTheFuture;

import java.nio.file.Path;
import java.util.Objects;

public class ManualConstructionTest {

    @Test
    public void manualConstruction(@TempDir Path folder, PlatformHandle handle) {
        Time time = LiveTime.INSTANCE;
        Omnibus omnibus = new DefaultOmnibus();
        AsynchronicityManager asyncManager = new StandardAsynchronicityManager(omnibus, handle);
        FactoryOfTheFuture futuresFactory = new LateBindingFactoryOfTheFuture(asyncManager);

        Configs configs = new StandardConfigs(folder);
        InternalScopeManager scopeManager = new Scoper();
        DatabaseManager databaseManager = new DatabaseManager(
                folder, futuresFactory, handle::createEnhancedExecutor, configs, scopeManager, time);
        Provider<InternalDatabase> dbProvider = databaseManager::getInternal;

        // Platform-specific section which would need to be abstracted
        QuackPlatform quackPlatform = new QuackPlatform();
        EnvUserResolver envUserResolver = new QuackUserResolver(quackPlatform);
        // End platform-specific section

        UUIDManager uuidManager = new CachingUUIDManager(configs, futuresFactory, dbProvider, envUserResolver);
        InternalFormatter formatter = new Formatter(futuresFactory, configs, scopeManager, uuidManager, time);

        // Platform-specific section which would need to be abstracted
        EnvEnforcer<QuackPlayer> envEnforcer = new QuackEnforcer(formatter, handle, quackPlatform);
        Environment environment = new QuackEnv(); // No dependencies here, though a real platform has several dependencies
        // End platform-specific section

        SettableProvider<Enforcer> enforcerProvider = new SettableProvider<>();
        SettableProvider<InternalRevoker> revokerProvider = new SettableProvider<>();
        SettableProvider<MuteCache> muteCacheProvider = new SettableProvider<>();

        AltCheckFormatter altCheckFormatter = new AltCheckFormatter(configs, formatter);
        AltDetection altDetection = new AltDetection(dbProvider);
        AltNotification altNotification = new AltNotification(configs, altCheckFormatter, envEnforcer);
        PunishmentCreator punishmentCreator = new SecurePunishmentCreator(
                futuresFactory, enforcerProvider, revokerProvider, muteCacheProvider
        );
        InternalSelector selector = new SelectorImpl(
                new SelectionImpl(futuresFactory, dbProvider, punishmentCreator, time),
                new IDImpl(futuresFactory, dbProvider, punishmentCreator, time),
                new ApplicableImpl(configs, futuresFactory, dbProvider, punishmentCreator,
                        altDetection, altNotification, time),
                muteCacheProvider
        );
        MuteCache muteCache = new CaffeineMuteCache(futuresFactory, selector);
        muteCacheProvider.set(muteCache);
        Enforcer enforcer = new StandardEnforcer(
                configs, futuresFactory, dbProvider, selector, formatter, envEnforcer, uuidManager, muteCache);
        enforcerProvider.set(enforcer);
        InternalRevoker revoker = new Revoker(futuresFactory, dbProvider, punishmentCreator, muteCache, time);
        revokerProvider.set(revoker);
        PunishmentDrafter punishmentDrafter = new Enactor(scopeManager, dbProvider, punishmentCreator, time);
        TabCompletion tabCompletion = new StandardTabCompletion(configs, dbProvider, time);
        EnvironmentManager envManager = new EnvironmentManager(environment, configs);
        LibertyBansApi api = new LibertyBansApi(
                omnibus, futuresFactory, punishmentDrafter, revoker, selector,
                () -> dbProvider.get().asExternal(), formatter, scopeManager, uuidManager);
        LifecycleGodfather lifecycleGodfather = new LifecycleGodfather(
                asyncManager, configs, databaseManager, uuidManager, tabCompletion, envManager, api);

        // Commands omitted

        lifecycleGodfather.startup();
    }

    static final class SettableProvider<T> implements Provider<T> {

        private T value;

        void set(T value) {
            this.value = Objects.requireNonNull(value, "value");
        }

        @Override
        public T get() {
            return value;
        }
    }

}