using Microsoft.Extensions.DependencyInjection;

using Microsoft.Extensions.Hosting;

using Microsoft.Extensions.Logging;

using System;

using System.IO;

using System.Reflection;

using System.Threading;

using System.Threading.Tasks;

using System.Net.Http;

using Newtonsoft.Json;

using System.Collections.Generic;

​

namespace CableHoarder

{

    class Program

    {

        static async Task Main(string[] args)

        {

            await Host.CreateDefaultBuilder(args).ConfigureServices((_, services) =>

            {

                services.AddTransient<ILibraryService, LibraryService>();

                services.AddTransient(serviceProvider =>

                {

                    return new Func<string, ILibraryApiClient>(baseUrl =>

                    {

                        var httpClient = new HttpClient();

                        httpClient.BaseAddress = new Uri(baseUrl);

                        httpClient.DefaultRequestHeaders.Add("Get", "application/json");

                        var logger = serviceProvider.GetRequiredService<ILogger<LibraryApiClient>>();

                        var client = new LibraryApiClient(baseUrl, httpClient, logger);

                        return client;

                    });

                });

                services.AddHostedService<ConsoleHostedService>();

            }).UseContentRoot(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)).ConfigureLogging((_, builder) =>

            {

                builder.ClearProviders();

                builder.AddConsole();

            }).RunConsoleAsync();

        }

    }

​

    internal sealed class ConsoleHostedService : IHostedService

    {

        private readonly ILogger _logger;

        private readonly IHostApplicationLifetime _appLifetime;

        private readonly ILibraryService _libraryService;

        public ConsoleHostedService(ILogger<ConsoleHostedService> logger, IHostApplicationLifetime appLifetime, ILibraryService libraryService)

        {

            _logger = logger;

            _appLifetime = appLifetime;

            _libraryService = libraryService;

        }

​

        public Task StartAsync(CancellationToken cancellationToken)

        {

            _logger.LogDebug($"Starting with arguments: {string.Join(" ", Environment.GetCommandLineArgs())}");

            _appLifetime.ApplicationStarted.Register(() =>

            {

                Task.Run(async () =>

                {

                    try

                    {

                        await _libraryService.SearchAuthor("martha wells");

                        await _libraryService.DoOtherWork();

                    }

                    catch (Exception ex)

                    {

                        _logger.LogError(ex, "Unhandled exception!");

                    }

                    finally

                    {

                        // Stop the application once the work is done

                        _appLifetime.StopApplication();

                    }

                });

            });

            return Task.CompletedTask;

        }

​

        public Task StopAsync(CancellationToken cancellationToken)

        {

            return Task.CompletedTask;

        }

    }

​

    public interface ILibraryService

    {

        Task SearchAuthor(string author);

        Task DoOtherWork();

    }

​

    public class LibraryService : ILibraryService

    {

        private readonly ILogger<LibraryService> _logger;

        private readonly Func<string, ILibraryApiClient> _libraryApiClientFactory;

        public LibraryService(ILogger<LibraryService> logger, Func<string, ILibraryApiClient> libraryApiClientFactory)

        {

            _logger = logger;

            _libraryApiClientFactory = libraryApiClientFactory;

        }

​

        public async Task SearchAuthor(string author)

        {

            _logger.LogInformation("SearchAuthor - search using openlibrary api");

            var booksResult = await _libraryApiClientFactory("http://openlibrary.org/").SearchAsync($"search.json?author={author}");

            if (booksResult != null)

            {

                _logger.LogInformation(booksResult.Num_found.ToString());

            }

        }

​

        public async Task DoOtherWork()

        {

            _logger.LogInformation("DoOtherWork");

        }

    }

​

    public interface ILibraryApiClient

    {

        Task<BooksResult> SearchAsync(string searchTerm);

    }

​

    public class LibraryApiClient : ILibraryApiClient

    {

        private readonly HttpClient _httpClient;

        private readonly ILogger<LibraryApiClient> _logger;

        public LibraryApiClient(string baseUrl, 

            HttpClient httpClient, 

            ILogger<LibraryApiClient> logger)

        {

            _httpClient = httpClient;

            _logger = logger;

        }

        public async Task<BooksResult> SearchAsync(string searchTerm)

        {

            var response = await _httpClient.GetAsync(searchTerm);

            var responseContent = await response.Content.ReadAsStringAsync();

            _logger.LogInformation($"Result: {responseContent}");

            var result = JsonConvert.DeserializeObject<BooksResult>(responseContent);

            return result;

        }

    }

    public class BooksResult

    {

        public int Start {get;set;}

        public int Num_found {get;set;}

        public List<Book> Docs {get;set;}

    }

    public class Book

    {

    }

}