using CodeGen.GeneratorBase;
using CodeGen.GeneratorBase.Context;
using CodeGen.GeneratorBase.FileManager;
using CodeGen.Utils.Scan;
using Domain.Common.Generation.WebApiMethod.Attributes;
using Domain.Common.Generation.WebApiWithBulkInsert.Interfaces;
using System.Collections.Generic;
using System.Linq;

namespace CodeGen.Generators.WebApiWithBulkInsert
{
    internal class RequestEntityScanner : ICodeGeneratorScanner<RequestEntityGeneratorDTO>
    {
        public RequestEntityScanner()
        {
        }

        public GeneratedFileInfo GetDescription(RequestEntityGeneratorDTO data)
        {
            throw new System.NotImplementedException();
        }

        public List<RequestEntityGeneratorDTO> Scan(GenerationContext projectContext)
        {
            var result = new List<RequestEntityGeneratorDTO>();

            //Получаем все типы с интерфейсом IRequestEntity
            var items = projectContext.GetAllClassesWithInterface<IWebApiWithBulkInsert>();

            foreach (var item in items)
            {
                //Получаем атрибут с указанием Endpoint-а и Http метода
                WebApiMethodAttribute requestAttr = item.GetAttribute<WebApiMethodAttribute>();

                //Получаем все параметры приходящие в запросе
                var uriParamsRaw = item.Properties.Where(i=>i.GetAttribute<WebApiMethodParameterFromUriAttribute>()!=null).ToList();
                var bodyParamsRaw = item.Properties.Where(i => i.GetAttribute<WebApiMethodParameterFromBody>() != null).ToList();

                
                //Добавляем все в DTO
                result.Add(new RequestEntityGeneratorDTO()
                {
                    defaultPath = requestAttr.Endpoint,
                    methods = requestAttr?.Methods ?? WebApiMethodRequestTypes.Get,

                    //requestEntityType = item,
                    bodyParam = bodyParamsRaw.Select(i => new RequestEntityParam()
                    {
                        Name = i.Name,
                        UriNameParameter = i.Name,
                        Parameter = i.Type
                    })
                    .ToList(),

                    uriParameters = uriParamsRaw.Select(i => new RequestEntityParam()
                    {
                        Name = i.Name,
                        UriNameParameter = i.GetAttribute<WebApiMethodParameterFromUriAttribute>().ParameterName,
                        Parameter = i.Type
                    })
                    .ToList(),

                    requestEntityType = item
                });
            }

            return result;
        }
    }
}

using CodeGen.GeneratorBase;
using CodeGen.GeneratorBase.Context;
using CodeGen.Utils.Scan;
using CodeGeneration.GeneratorBase;
using Domain.Common.Generation.WebApiMethod.Attributes;
using System.Collections.Generic;

namespace CodeGen.Generators.WebApiWithBulkInsert.Infrastructure.Web
{
    class RequestEntityWebGenerator : CodeGeneratorBase<RequestEntityGeneratorDTO>
    {
        private ICodeGeneratorScanner<RequestEntityGeneratorDTO> scanner;
        public RequestEntityWebGenerator() 
        {
            place = GeneratorRunPlace.InfrastructureWeb;
            scanner = new RequestEntityScanner();
        }
        
        public override void Generate(GenerationContext context, List<RequestEntityGeneratorDTO> data)
        {
            //Добавляем шапку
            string txtExample = $@"
using Microsoft.AspNetCore.Mvc;

using Domain.Common.Interfaces.Infrastructure.MessageBus;
{GenerateUsings(data)}

namespace Infrastructure.Web.Controllers
{{
    //[ApiController]
    public partial class GeneratedWebController : ControllerBase
    {{
        {GenerateMethods(data)}
    }}
}}
";

            context.AddSource("Generated_WebApiWithBulkInsert_WebControllers", txtExample);
        }

        //Генерируем методы WebAPI
        private string GenerateMethods(List<RequestEntityGeneratorDTO> data)
        {
            var txtExample = "";

            foreach (var item in data)
            {
                txtExample += GenerateMethod(item)+"\r\n";
            }

            return txtExample;
        }

        //Генерируем метод WebApi
        private string GenerateMethod(RequestEntityGeneratorDTO item)
        {
            var txtExample = "";

            //Добавляем атрибут к методу
            if (item.methods == WebApiMethodRequestTypes.Get)
                txtExample += $@"
        [HttpGet(""{item.defaultPath}"")]";
            else if (item.methods == WebApiMethodRequestTypes.Post)
                txtExample += $@"
        [HttpPost(""{item.defaultPath}"")]";

            //Делаем метод
            txtExample += $@"
        public IActionResult Get{item.requestEntityType.Name}([FromServices] ILogger logger,[FromServices] IMessageBus busService, {GenerateParameters(item)})
        {{
            try
            {{
                {GenerateBody(item)}

                busService.Send(request, MessageBus.WebApiBulk).Wait();
            }}
            catch (Exception ex)
            {{
                logger.LogError(ex, ""WebAPiWithBulkInsert"", Request);
            }}
           
            return Ok();
        }}";

            return txtExample;
        }

        //Добавляем using-и
        private string GenerateUsings(List<RequestEntityGeneratorDTO> data)
        {
            var txtExample = "";
            foreach (var item in data)
            {
                foreach (var uri in item.uriParameters)
                    txtExample += $"\r\nusing {uri.Parameter.Namespace};";

                foreach (var body in item.bodyParam)
                    txtExample += $"\r\nusing {body.Parameter.Namespace};";

            }
            
            return txtExample;
        }

        //Генерируем тело метода
        private object GenerateBody(RequestEntityGeneratorDTO data)
        {
            return $@"
                Generated{data.requestEntityType.Name}RequestObject request = new Generated{data.requestEntityType.Name}RequestObject()
                {{
                    {GenerateAssigns(data)}
                    SourceIp = Request.HttpContext.Connection.RemoteIpAddress.ToString(),
                    Date = DateTime.Now
                }};
            
            ";
        }

        //Генерируем присваивание
        private string GenerateAssigns(RequestEntityGeneratorDTO data)
        {
            string result = "";

            foreach (var item in data.uriParameters)
            {
                result += $"{item.UriNameParameter} = {item.UriNameParameter},\r\n";
            }

            foreach (var item in data.bodyParam)
            {
                result += $"{item.UriNameParameter} = {item.UriNameParameter},\r\n";
            }

            return result;
        }

        //Генерируем строку параметров
        private object GenerateParameters(RequestEntityGeneratorDTO data)
        {
            var result = "";
            foreach(var item in data.uriParameters)
            {
                result += "[FromQuery]";
                result += item.Parameter.Name;
                result += " " + item.UriNameParameter + ", ";
            }

            foreach (var item in data.bodyParam)
            {
                result += "[FromBody]";
                result += item.Parameter.Name;
                result += " " + item.UriNameParameter + ", ";
            }

            return result.Substring(0, result.Length - 2);
        }

        public override List<RequestEntityGeneratorDTO> Parse(GenerationContext projectContext)
        {
            return scanner.Scan(projectContext);
        }
    }
}

using CodeGen.GeneratorBase;
using CodeGen.GeneratorBase.Context;
using CodeGen.Utils.Scan;
using CodeGeneration.GeneratorBase;
using System.Collections.Generic;

namespace CodeGen.Generators.WebApiWithBulkInsert.Application.Common
{
    class RequestEntityObjectWebGenerator : CodeGeneratorBase<RequestEntityGeneratorDTO>
    {
        private ICodeGeneratorScanner<RequestEntityGeneratorDTO> scanner;
        public RequestEntityObjectWebGenerator() 
        {
            place = GeneratorRunPlace.ApplicationCommon;
            scanner = new RequestEntityScanner();
        }
        
        public override void Generate(GenerationContext context, List<RequestEntityGeneratorDTO> data)
        {
            //Добавляем шапку
            string txtExample = $@"
using System;
{GenerateUsings(data)}

namespace Infrastructure.Web.Controllers
{{
    {GenerateClasses(data)}
}}
";

            context.AddSource("Generated_WebApiWithBulkInsert_RequestDTOs", txtExample);
        }

        private string GenerateClasses(List<RequestEntityGeneratorDTO> data)
        {
            var txtExample = "";

            foreach (var item in data)
            {
                txtExample += GenerateClass(item)+"\r\n";
            }

            return txtExample;
        }

        private string GenerateClass(RequestEntityGeneratorDTO item)
        {
            var txtExample = $@"
    public class Generated{item.requestEntityType.Name}RequestObject
    {{
        {GenerateProperties(item)}
    
        {GenerateFields(item)}
    
        public DateTime Date {{get;set;}}

        public string SourceIp {{get;set;}}
    }}
";
            return txtExample;
        }

        private object GenerateFields(RequestEntityGeneratorDTO data)
        {
            var result = "";

            foreach (var item in data.uriParameters)
            {
                result += @"
        public ";
                result += item.Parameter.Name;
                result += " " + item.UriNameParameter + " {get;set;}\r\n";
            }

            return result;
        }

        private object GenerateProperties(RequestEntityGeneratorDTO data)
        {
            var result = "";

            foreach (var item in data.bodyParam)
            {
                result += @"
        public ";
                result += item.Parameter.Name;
                result += " " + item.UriNameParameter + " {get;set;}\r\n";
            }

            return result;
        }

        private string GenerateUsings(List<RequestEntityGeneratorDTO> data)
        {
            var txtExample = "";
            foreach (var item in data)
            {
                foreach (var uri in item.uriParameters)
                    txtExample += $"\r\nusing {uri.Parameter.Namespace};";

                foreach (var body in item.bodyParam)
                    txtExample += $"\r\nusing {body.Parameter.Namespace};";

            }
            
            return txtExample;
        }

        public override List<RequestEntityGeneratorDTO> Parse(GenerationContext projectContext)
        {
            return scanner.Scan(projectContext);
        }
    }
}