AcManager.Tools.ArgumentsHandler.ProcessShared C# (CSharp) Method

ProcessShared() private method

private ProcessShared ( string id ) : Task
id string
return Task
        private async Task<ArgumentHandleResult> ProcessShared(string id) {
            SharedEntry shared;

            using (var waiting = new WaitingDialog()) {
                waiting.Report(ControlsStrings.Common_Loading);
                shared = await SharingHelper.GetSharedAsync(id, waiting.CancellationToken);
            }

            var data = shared?.Data;
            if (data == null) return ArgumentHandleResult.Failed;

            switch (shared.EntryType) {
                case SharedEntryType.Weather: {
                    var result = ShowDialog(shared, applyable: false);
                    switch (result) {
                        case Choise.Save:
                            var directory = FileUtils.EnsureUnique(Path.Combine(
                                    WeatherManager.Instance.Directories.EnabledDirectory, shared.GetFileName()));
                            Directory.CreateDirectory(directory);

                            var written = 0;
                            using (var stream = new MemoryStream(data)) {
                                var reader = ReaderFactory.Open(stream);

                                try {
                                    while (reader.MoveToNextEntry()) {
                                        if (!reader.Entry.IsDirectory) {
                                            reader.WriteEntryToDirectory(directory, new ExtractionOptions {
                                                ExtractFullPath = true,
                                                Overwrite = true
                                            });
                                            written++;
                                        }
                                    }
                                } catch (EndOfStreamException) {
                                    if (written < 2) {
                                        throw;
                                    }
                                }
                            }

                            return ArgumentHandleResult.SuccessfulShow;
                        default:
                            return ArgumentHandleResult.Failed;
                    }
                }

                case SharedEntryType.PpFilter: {
                    var result = ShowDialog(shared, appliableWithoutSaving: false);
                    switch (result) {
                        case Choise.Save:
                        case Choise.ApplyAndSave:
                            var filename = FileUtils.EnsureUnique(Path.Combine(
                                    PpFiltersManager.Instance.Directories.EnabledDirectory, shared.GetFileName()));
                            Directory.CreateDirectory(Path.GetDirectoryName(filename) ?? "");
                            File.WriteAllBytes(filename, data);
                            if (result == Choise.ApplyAndSave) {
                                AcSettingsHolder.Video.PostProcessingFilter = Path.GetFileNameWithoutExtension(filename);
                            }
                            return ArgumentHandleResult.SuccessfulShow;
                        default:
                            return ArgumentHandleResult.Failed;
                    }
                }

                case SharedEntryType.CarSetup: {
                    var content = data.ToUtf8String();
                    var metadata = SharingHelper.GetMetadata(SharedEntryType.CarSetup, content, out content);

                    var carId = metadata.GetValueOrDefault("car");
                    var trackId = metadata.GetValueOrDefault("track") ?? CarSetupObject.GenericDirectory;
                    if (carId == null) {
                        throw new InformativeException(AppStrings.Arguments_CannotInstallCarSetup, AppStrings.Arguments_MetadataIsMissing);
                    }

                    var result = ShowDialog(shared, applyable: false,
                            additionalButton: trackId == CarSetupObject.GenericDirectory ? null : AppStrings.Arguments_SaveAsGeneric);
                    switch (result) {
                        case Choise.Save:
                        case Choise.Extra:
                            var filename = FileUtils.EnsureUnique(Path.Combine(FileUtils.GetCarSetupsDirectory(carId),
                                    result == Choise.Save ? trackId : CarSetupObject.GenericDirectory, shared.GetFileName()));
                            Directory.CreateDirectory(Path.GetDirectoryName(filename) ?? "");
                            File.WriteAllText(filename, content);
                            return ArgumentHandleResult.SuccessfulShow;
                        default:
                            return ArgumentHandleResult.Failed;
                    }
                }

                case SharedEntryType.ControlsPreset: {
                    var result = ShowDialog(shared, AppStrings.Arguments_Shared_ApplyFfbOnly);
                    switch (result) {
                        case Choise.Save:
                        case Choise.ApplyAndSave:
                            var filename = FileUtils.EnsureUnique(Path.Combine(
                                    AcSettingsHolder.Controls.UserPresetsDirectory, @"Loaded", shared.GetFileName()));
                            Directory.CreateDirectory(Path.GetDirectoryName(filename) ?? "");
                            File.WriteAllBytes(filename, data);
                            if (result == Choise.ApplyAndSave) {
                                AcSettingsHolder.Controls.LoadPreset(filename, true);
                            }
                            return ArgumentHandleResult.SuccessfulShow;
                        case Choise.Apply:
                            if (File.Exists(AcSettingsHolder.Controls.Filename)) {
                                FileUtils.Recycle(AcSettingsHolder.Controls.Filename);
                            }
                            File.WriteAllBytes(AcSettingsHolder.Controls.Filename, data);
                            return ArgumentHandleResult.SuccessfulShow;
                        case Choise.Extra: // ffb only
                            var ini = IniFile.Parse(data.ToUtf8String());
                            AcSettingsHolder.Controls.LoadFfbFromIni(ini);
                            return ArgumentHandleResult.SuccessfulShow;
                        default:
                            return ArgumentHandleResult.Failed;
                    }
                }

                case SharedEntryType.ForceFeedbackPreset: {
                    var result = ShowDialog(shared, saveable: false);
                    switch (result) {
                        case Choise.Apply:
                            var ini = IniFile.Parse(data.ToUtf8String());
                            AcSettingsHolder.Controls.LoadFfbFromIni(ini);
                            AcSettingsHolder.System.LoadFfbFromIni(ini);
                            return ArgumentHandleResult.SuccessfulShow;
                        default:
                            return ArgumentHandleResult.Failed;
                    }
                }

                case SharedEntryType.VideoSettingsPreset: {
                    var result = ShowDialog(shared);
                    switch (result) {
                        case Choise.Save:
                        case Choise.ApplyAndSave:
                            var filename = FileUtils.EnsureUnique(Path.Combine(
                                    PresetsManager.Instance.GetDirectory(AcSettingsHolder.VideoPresets.PresetableKey), @"Loaded", shared.GetFileName()));
                            Directory.CreateDirectory(Path.GetDirectoryName(filename) ?? "");
                            File.WriteAllBytes(filename, data);
                            if (result == Choise.ApplyAndSave) {
                                UserPresetsControl.LoadPreset(AcSettingsHolder.VideoPresets.PresetableKey, filename);
                            }
                            return ArgumentHandleResult.SuccessfulShow;
                        case Choise.Apply:
                            AcSettingsHolder.VideoPresets.ImportFromPresetData(data.ToUtf8String());
                            return ArgumentHandleResult.SuccessfulShow;
                        default:
                            return ArgumentHandleResult.Failed;
                    }
                }

                case SharedEntryType.AssistsSetupPreset: {
                    var result = ShowDialog(shared);
                    switch (result) {
                        case Choise.Save:
                        case Choise.ApplyAndSave:
                            var filename = FileUtils.EnsureUnique(Path.Combine(
                                    PresetsManager.Instance.GetDirectory(AssistsViewModel.Instance.PresetableKey), @"Loaded", shared.GetFileName()));
                            Directory.CreateDirectory(Path.GetDirectoryName(filename) ?? "");
                            File.WriteAllBytes(filename, data);
                            if (result == Choise.ApplyAndSave) {
                                UserPresetsControl.LoadPreset(AssistsViewModel.Instance.PresetableKey, filename);
                            }
                            return ArgumentHandleResult.SuccessfulShow;
                        case Choise.Apply:
                            AssistsViewModel.Instance.ImportFromPresetData(data.ToUtf8String());
                            return ArgumentHandleResult.SuccessfulShow;
                        default:
                            return ArgumentHandleResult.Failed;
                    }
                }

                case SharedEntryType.QuickDrivePreset: {
                    var result = ShowDialog(shared, AppStrings.Arguments_Shared_JustGo);
                    switch (result) {
                        case Choise.Save:
                        case Choise.ApplyAndSave:
                            var filename = FileUtils.EnsureUnique(Path.Combine(
                                    PresetsManager.Instance.GetDirectory(QuickDrive.PresetableKeyValue), @"Loaded", shared.GetFileName()));
                            Directory.CreateDirectory(Path.GetDirectoryName(filename) ?? "");
                            File.WriteAllBytes(filename, data);
                            if (result == Choise.ApplyAndSave) {
                                QuickDrive.LoadPreset(filename);
                            }
                            return ArgumentHandleResult.SuccessfulShow;
                        case Choise.Apply:
                            QuickDrive.LoadSerializedPreset(data.ToUtf8String());
                            return ArgumentHandleResult.SuccessfulShow;
                        case Choise.Extra: // just go
                            if (!QuickDrive.RunSerializedPreset(data.ToUtf8String())) {
                                throw new InformativeException(AppStrings.Common_CannotStartRace, AppStrings.Arguments_CannotStartRace_Commentary);
                            }

                            return ArgumentHandleResult.SuccessfulShow;
                        default:
                            return ArgumentHandleResult.Failed;
                    }
                }

                case SharedEntryType.RaceGridPreset: {
                    var result = ShowDialog(shared);
                    switch (result) {
                        case Choise.Save:
                        case Choise.ApplyAndSave:
                            var filename = FileUtils.EnsureUnique(Path.Combine(
                                    PresetsManager.Instance.GetDirectory(RaceGridViewModel.PresetableKeyValue), @"Loaded", shared.GetFileName()));
                            Directory.CreateDirectory(Path.GetDirectoryName(filename) ?? "");
                            File.WriteAllBytes(filename, data);
                            if (result == Choise.ApplyAndSave) {
                                RaceGridViewModel.LoadPreset(filename);
                                QuickDrive.NavigateToPage();
                            }
                            return ArgumentHandleResult.SuccessfulShow;
                        case Choise.Apply:
                            RaceGridViewModel.LoadSerializedPreset(data.ToUtf8String());
                            QuickDrive.NavigateToPage();
                            return ArgumentHandleResult.SuccessfulShow;
                        default:
                            return ArgumentHandleResult.Failed;
                    }
                }

                default:
                    throw new Exception(string.Format(AppStrings.Arguments_SharedUnsupported, shared.EntryType));
            }
        }
    }