using System;

using System.IO;

using System.Threading.Tasks;

using System.Collections.Generic;

using System.IO.Abstractions;

using Bicep.Core;

using Bicep.Core.Analyzers.Interfaces;

using Bicep.Core.Analyzers.Linter;

using Bicep.Core.Configuration;

using Bicep.Core.Emit;

using Bicep.Core.Features;

using Bicep.Core.FileSystem;

using Bicep.Core.Registry;

using Bicep.Core.Text;

using Bicep.Core.Registry.Auth;

using Bicep.Core.Semantics.Namespaces;

using Bicep.Core.TypeSystem.Providers;

using Bicep.Core.Utils;

using Microsoft.Extensions.DependencyInjection;

using System.IO.Abstractions.TestingHelpers;

using Environment = Bicep.Core.Utils.Environment;

public class Program

{

    public static async Task Main()

    {

        var files = new Dictionary<string, MockFileData>

        {

            ["/main.bicep"] = """

module mod 'module.bicep' = {

  name: 'module'

  params: {

    foo: 'foo'

  }

}

""",

            ["/module.bicep"] = """

param foo string

outputs foo string = foo

""",

        };

        var services = new ServiceCollection()

            .AddBicepCore(new MockFileSystem(files))

            .BuildServiceProvider();

        var template = await Compile(services, new Uri("file:///main.bicep"));

        Console.Write(template);

    }

    private static async Task<string> Compile(IServiceProvider services, Uri bicepUri)

    {

        var compiler = services.GetRequiredService<BicepCompiler>();

        var compilation = await compiler.CreateCompilation(bicepUri);

        var model = compilation.GetEntrypointSemanticModel();

​

        using var stream = new MemoryStream();

        var emitter = new TemplateEmitter(model);

        var emitResult = emitter.Emit(stream);

​

        foreach (var (file, diagnostics) in compilation.GetAllDiagnosticsByBicepFile())

        foreach (var diagnostic in diagnostics)

        {

            (var line, var character) = TextCoordinateConverter.GetPosition(file.LineStarts, diagnostic.Span.Position);

            Console.WriteLine($"{file.FileUri.LocalPath}({line + 1},{character + 1}) : {diagnostic.Level} {diagnostic.Code}: {diagnostic.Message}");

        }

​

        if (emitResult.Status == EmitStatus.Failed)

        {           

            throw new InvalidOperationException("Compilation failed!");

        }

​

        stream.Position = 0;

        return new StreamReader(stream).ReadToEnd();

    }

}

​

public static class ServiceCollectionExtensions

{

    public static IServiceCollection AddBicepCore(this IServiceCollection services, IFileSystem fileSystem) => services

        .AddSingleton<INamespaceProvider, DefaultNamespaceProvider>()

        .AddSingleton<IResourceTypeProviderFactory, ResourceTypeProviderFactory>()

        .AddSingleton<IContainerRegistryClientFactory, ContainerRegistryClientFactory>()

        .AddSingleton<ITemplateSpecRepositoryFactory, TemplateSpecRepositoryFactory>()

        .AddSingleton<IModuleDispatcher, ModuleDispatcher>()

        .AddSingleton<IArtifactRegistryProvider, DefaultArtifactRegistryProvider>()

        .AddSingleton<ITokenCredentialFactory, TokenCredentialFactory>()

        .AddSingleton<IFileResolver, FileResolver>()

        .AddSingleton<IEnvironment, Environment>()

        .AddSingleton<IFileSystem>(fileSystem)

        .AddSingleton<IConfigurationManager, ConfigurationManager>()

        .AddSingleton<IBicepAnalyzer, LinterAnalyzer>()

        .AddSingleton<IFeatureProviderFactory, FeatureProviderFactory>()

        .AddSingleton<ILinterRulesProvider, LinterRulesProvider>()

        .AddSingleton<BicepCompiler>();

}

​