private RdEditorModel ResetModel()

in src/dotnet/RiderPlugin.UnrealLink/RiderBackendToUnrealEditor.cs [200:281]
66 lines of code
1 McCabe index (conditional complexity)

        private RdEditorModel ResetModel(Lifetime lf, IProtocol protocol)
        {
            myUnrealHost.PerformModelAction(riderModel =>
            {
                riderModel.EditorId.SetValue(riderModel.EditorId.Value + 1);
            });

            var unrealModel = new RdEditorModel(lf, protocol);
            UE4Library.RegisterDeclaredTypesSerializers(protocol.Serializers);

            unrealModel.ConnectionInfo.Advise(lf, info =>
                myUnrealHost.myModel.ConnectionInfo.SetValue(info)
            );
            
            unrealModel.AllowSetForegroundWindow.SetAsync((lt, pid) =>
            {
                return myUnrealHost.PerformModelAction(riderModel =>
                    riderModel.AllowSetForegroundWindow.Start(lt, pid)) as RdTask<bool>;
            });

            unrealModel.PlayStateFromEditor.Advise(lf, myUnrealHost.myModel.PlayStateFromEditor);

            unrealModel.PlayModeFromEditor.Advise(lf, myUnrealHost.myModel.PlayModeFromEditor);

            unrealModel.NotificationReplyFromEditor.Advise(lf, myUnrealHost.myModel.NotificationReplyFromEditor);

            unrealModel.IsGameControlModuleInitialized.Advise(lf,
                myUnrealHost.myModel.IsGameControlModuleInitialized.Set);

            unrealModel.UnrealLog.Advise(lf,
                logEvent =>
                {
                    myUnrealHost.PerformModelAction(riderModel => { OnMessageReceived(riderModel, logEvent); });
                });

            unrealModel.OnBlueprintAdded.Advise(lf, blueprintClass =>
            {
                //TO-DO
            });

            myUnrealHost.PerformModelAction(riderModel =>
            {
                riderModel.FilterLinkCandidates.SetAsync((_, candidates) =>
                    RdTask.Successful(candidates
                        .Select(request => myLinkResolver.ResolveLink(request, unrealModel.IsBlueprintPathName))
                        .AsArray()));
                riderModel.IsMethodReference.SetAsync((_, methodReference) =>
                {
                    var b = myEditorNavigator.IsMethodReference(methodReference);
                    return RdTask.Successful(b);
                });
                riderModel.OpenBlueprint.Advise(lf, blueprintReference =>
                    OnOpenedBlueprint(unrealModel, blueprintReference));

                riderModel.NavigateToClass.Advise(lf,
                    uClass => myEditorNavigator.NavigateToClass(uClass));

                riderModel.NavigateToMethod.Advise(lf,
                    methodReference => myEditorNavigator.NavigateToMethod(methodReference));

                riderModel.RequestPlayFromRider.Advise(lf, unrealModel.RequestPlayFromRider);
                riderModel.RequestPauseFromRider.Advise(lf, unrealModel.RequestPauseFromRider);
                riderModel.RequestResumeFromRider.Advise(lf, unrealModel.RequestResumeFromRider);
                riderModel.RequestStopFromRider.Advise(lf, unrealModel.RequestStopFromRider);
                riderModel.RequestFrameSkipFromRider.Advise(lf, unrealModel.RequestFrameSkipFromRider);
                riderModel.PlayModeFromRider.Advise(lf, unrealModel.PlayModeFromRider);
            });

            unrealModel.IsHotReloadAvailable.Advise(lf, myUnrealHost.myModel.IsHotReloadAvailable.Set);
            unrealModel.IsHotReloadCompiling.Advise(lf, myUnrealHost.myModel.IsHotReloadCompiling.Set);
            myUnrealHost.PerformModelAction(riderModel =>
            {
                riderModel.TriggerHotReload.Advise(lf, _ => unrealModel.TriggerHotReload());
                riderModel.IsConnectedToUnrealEditor.WhenFalse(lf, _ =>
                {
                    riderModel.IsHotReloadAvailable.Set(false);
                    riderModel.IsHotReloadCompiling.Set(false);
                });
            });

            return unrealModel;
        }