private static int Main()

in tools/JsonCli/src/Program.cs [37:149]
89 lines of code
16 McCabe index (conditional complexity)

        private static int Main(string[] args)
        {
            CommandLineParser parser = new CommandLineParser(args)
                .AddOptionWithConstrainedValue("--operation", new[]
                {
                        "list",
                        "create"
                })
                .AddOptionWithValue("--templateDir");

            if (!parser.TryGetSingleValue("--operation", out string operation) || !parser.TryGetSingleValue("--templateDir", out string templateDir))
            {
                Console.SetOut(Console.Error);
                Console.WriteLine("ERROR: Expected \"--operation\" and/or \"--templateDir\" parameter.");
                return -1;
            }

            ITemplateEngineHost host = CreateHost(HostName, HostVersion);
            EnvironmentSettings = new EngineEnvironmentSettings(host, x => new SettingsLoader(x), Path.Combine(templateDir, "cache"));
            EnvironmentSettings.SettingsLoader.Components.OfType<IIdentifiedComponent>().ToList();
            _paths = new Paths(EnvironmentSettings);

            //NOTE: With the base directory virtualized, packages cannot be installed from NuGet,
            //  only local packages and folders
            EnvironmentSettings.Host.VirtualizeDirectory(_paths.User.Content);
            EnvironmentSettings.Host.VirtualizeDirectory(_paths.User.Packages);
            _settingsLoader = (SettingsLoader)EnvironmentSettings.SettingsLoader;
            _hostDataLoader = new HostSpecificDataLoader(EnvironmentSettings.SettingsLoader);

            IInstaller installer = new Installer(EnvironmentSettings);

            installer.InstallPackages(new string[] {
                Path.Combine(templateDir, "item.nupkg"),
                Path.Combine(templateDir, "project.nupkg")
            });

            //All required templates/components/lang packs have now been configured
            //Desired operation information starts at args[commandArgsStart]

            _templateCreator = new TemplateCreator(EnvironmentSettings);
            IReadOnlyList<TemplateInfo> rawTemplates = _settingsLoader.UserTemplateCache.TemplateInfo;

            var templates = new JArray();
            foreach (var rawTemplate in rawTemplates)
            {
                var template = JObject.FromObject(rawTemplate);
                template.Add("Parameters", JArray.FromObject(rawTemplate.Parameters));
                templates.Add(template);
            }


            if (string.Equals(operation, "list"))
            {
                Console.WriteLine(templates);
                return 0;
            }

            parser = parser.AddOptionWithValue("--identity");

            if (!parser.TryGetSingleValue("--identity", out string identity))
            {
                Console.SetOut(Console.Error);
                Console.WriteLine("ERROR: Expected \"--identity\" parameter.");
                return -1;
            }

            TemplateInfo info = rawTemplates.FirstOrDefault(x => string.Equals(x.Identity, identity, StringComparison.Ordinal));

            if (info == null)
            {
                Console.SetOut(Console.Error);
                Console.WriteLine("ERROR: Failed to find template with identity \"{0}\".", identity);
                return -1;
            }

            if (string.Equals(operation, "create"))
            {
                Dictionary<string, string> templateArgs = new Dictionary<string, string>(StringComparer.Ordinal);

                foreach (ITemplateParameter x in info.Parameters)
                {
                    if (x.DataType != null && x.DataType.StartsWith("bool", StringComparison.OrdinalIgnoreCase))
                    {
                        parser = parser.AddOptionWithBooleanValue($"--arg:{x.Name}", string.IsNullOrEmpty(x.DefaultValue) || string.Equals(x.DefaultValue, "true"));
                    }
                    else if (x.DataType != null && x.DataType.Equals("choice", StringComparison.OrdinalIgnoreCase))
                    {
                        parser = parser.AddOptionWithConstrainedValue($"--arg:{x.Name}", x.Choices.Keys.ToList());
                    }
                    else
                    {
                        parser = parser.AddOptionWithValue($"--arg:{x.Name}");
                    }

                    if (parser.TryGetSingleValue($"--arg:{x.Name}", out string val))
                    {
                        templateArgs[x.Name] = val;
                    }
                }

                TemplateCreationResult result = _templateCreator.InstantiateAsync(info, null, null, null, templateArgs, true, false, null).Result;
                if (result.Status == CreationResultStatus.Success)
                {
                    PostActionDispatcher postActionDispatcher = new PostActionDispatcher(EnvironmentSettings, new New3Callbacks(), result, AllowPostActionsSetting.Yes, false);
                    postActionDispatcher.Process(null);
                }

                Console.WriteLine(JObject.FromObject(result));
                return (int)result.Status;
            }

            return 0;
        }