override fun extensionCreated()

in rider/src/main/kotlin/com/jetbrains/rider/plugins/godot/FrontendBackendHost.kt [40:114]
65 lines of code
6 McCabe index (conditional complexity)

        override fun extensionCreated(lifetime: Lifetime, session: ClientProjectSession, model: GodotFrontendBackendModel) {
            val project = session.project
            model.activateRider.advise(lifetime) {
                ProjectUtil.focusProjectWindow(project, true)
                val frame = WindowManager.getInstance().getFrame(project)
                if (frame != null) {
                    if (BitUtil.isSet(frame.extendedState, Frame.ICONIFIED))
                        frame.extendedState = BitUtil.set(frame.extendedState, Frame.ICONIFIED, false)
                }
            }

            model.onTestRunnerOutputEvent.advise(lifetime) { output->
                debugProcesses.filter{it.key == output.port}.firstOrNull()?.value?.console?.tryWriteMessageToConsoleView(
                    OutputMessageWithSubject(
                        output = "${output.message}\r\n",
                        type = when (output.type) {
                            TestRunnerOutputEventType.Message -> OutputType.Info
                            TestRunnerOutputEventType.Error -> OutputType.Error
                        },
                        subject = OutputSubject.Default
                    )
                )
            }

            model.startDebuggerServer.set { lt, _ ->
                val task = RdTask<Int>()
                val runManager = RunManager.getInstance(project)
                val configurationType = ConfigurationTypeUtil.findConfigurationType(MonoRemoteConfigType::class.java)
                val runConfiguration = runManager.createConfiguration(
                    GodotRunConfigurationGenerator.ATTACH_CONFIGURATION_NAME,
                    GodotDotNetRemoteConfigurationFactory(configurationType)
                )
                val remoteConfiguration = runConfiguration.configuration as GodotDotNetRemoteConfiguration
                remoteConfiguration.listenPortForConnections = true
                remoteConfiguration.port = NetworkUtils.findFreePort(500013)
                remoteConfiguration.address = "127.0.0.1"

                val processTracker: RiderDebugActiveDotNetSessionsTracker =
                    RiderDebugActiveDotNetSessionsTracker.getInstance(project)
                processTracker.dotNetDebugProcesses.change.advise(lt) { (event, debugProcess) ->
                    if (event == AddRemove.Add) {
                        debugProcesses[remoteConfiguration.port] = debugProcess
                        debugProcess.sessionLifetime.onTermination { debugProcesses.remove(remoteConfiguration.port) }
                        debugProcess.initializeDebuggerTask.debuggerInitializingState.advise(lt) {
                            if (it == DebuggerInitializingState.Initialized)
                                task.set(remoteConfiguration.port)
                            if (it == DebuggerInitializingState.Canceled)
                                task.set(0)
                        }
                    }
                }

                ProgramRunnerUtil.executeConfiguration(runConfiguration, DefaultDebugExecutor.getDebugExecutorInstance())

                task
            }

            model.runChickensoftTest.adviseNotNull(lifetime) {
                RunChickenTestsUtil.execute(it, project)
            }

            GodotProjectDiscoverer.getInstance(project).godot3Path.adviseNotNull(lifetime){
                model.godotPath.set(it)
            }

            GodotProjectDiscoverer.getInstance(project).godot4Path.adviseNotNull(lifetime){ s ->
                // for Godot3 this is done in a separate place
                RiderDebuggerWorkerModelManager.getModels().adviseNotNull(lifetime){
                    model.backendSettings.enableDebuggerExtensions.flowInto(lifetime,
                        it.value.godotDebuggerWorkerModel.showCustomRenderers)
                }

                model.godotPath.set(s)
            }
        }