using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using NLog;
using WebDoorCreator.Data.DTO;
using WebDoorCreator.Data.Services;

namespace WebDoorCreator.API.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class OrderController : ControllerBase
    {
        public OrderController(IConfiguration configuration, WebDoorCreatorService DataService)
        {
            Log.Info("Starting OrderController");
            _configuration = configuration;
            WDCService = DataService;
            Log.Info("Avviato OrderController");
        }
        /// <summary>
        /// GET: api/Order
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        public string Get()
        {
            return "OK";
        }
        /// <summary>
        /// GET: api/Order/GetCurrent
        /// Recupera ordini dato id cliente + stato ordini (limitato a ultimi 6 mesi)
        /// </summary>
        /// <returns></returns>
        [HttpGet("GetCurrent")]
        public async Task<List<int>> GetCurrent(int id, int ordStatus)
        {
            List<int> answ = new List<int>();
            DateTime dtEnd = DateTime.Now;
            DateTime dtStart = dtEnd.AddMonths(-6);
            var rawData = await WDCService.OrderStatusGetFilt(id, ordStatus, dtStart, dtEnd);
            if (rawData != null)
            {
                answ = rawData.Select(x => x.OrderId).ToList();
            }
            return answ;
        }
        /// <summary>
        /// Order detail for cost evaluation
        /// </summary>
        /// <param name="OrderId"></param>
        /// <returns></returns>
        [HttpGet("GetDetail")]
        public async Task<OrderDetailsDTO> GetDetail(int OrderId)
        {
            OrderDetailsDTO answ = new OrderDetailsDTO()
            {
                OrderId = OrderId
            };
            // recupero info ordine
            var rawOrder = await WDCService.OrderGetByKey(OrderId);
            if (rawOrder != null && rawOrder.CompanyNav != null)
            {
                answ.OrderDescript = rawOrder.OrderDescript;
                answ.OrderExtCode = rawOrder.OrderExtCode;

                // recupero info customer
                CustomerDTO customer = new CustomerDTO()
                {
                    Address = rawOrder.CompanyNav.Address,
                    City = rawOrder.CompanyNav.City,
                    CompanyExtCode = rawOrder.CompanyNav.CompanyExtCode,
                    CompanyId = rawOrder.CompanyNav.CompanyId,
                    CompanyName = rawOrder.CompanyNav.CompanyName,
                    State = rawOrder.CompanyNav.State,
                    VAT = rawOrder.CompanyNav.VAT,
                    ZipCode = rawOrder.CompanyNav.ZipCode
                };
                answ.CustomerInfo = customer;
                // recuper elenco porte...
                List<DoorCostingDTO> dcDTO = new List<DoorCostingDTO>();
                var doorsList = await WDCService.DoorGetByOrderId(OrderId);
                if (doorsList != null)
                {
                    foreach (var door in doorsList)
                    {
                        // recupero i dato DoorOp
                        var doorOpList = await WDCService.DoorOpGetByDoorId(door.DoorId);
                        Dictionary<string, List<string>> currBOMList = new Dictionary<string, List<string>>();
                        // ciclo su tutte le DoorOp
                        foreach (var doorOp in doorOpList)
                        {
                            // cerco se ci sia già o meno nella BOM l'item corrente
                            if (currBOMList.ContainsKey(doorOp.ObjectId))
                            {
                                currBOMList[doorOp.ObjectId].Add(doorOp.JsoncActVal);
                            }
                            else
                            {
                                List<string> currOp = new List<string>();
                                currOp.Add(doorOp.JsoncActVal);
                                currBOMList.Add(doorOp.ObjectId, currOp);
                            }
                        }
                        // creo oggetto DTO finale della porta
                        var doorDto = new DoorCostingDTO()
                        {
                            DoorId = door.DoorId,
                            Quantity = door.Quantity,
                            EstimatedWorkTime = 0,
                            BOMList = currBOMList
                        };
                        dcDTO.Add(doorDto);
                    }
                }
                //answ. = rawOrder.OrderDescript;
                answ.DoorsList = dcDTO;
            }
            // popolo con dati specifica...
            return answ;
        }

        /// <summary>
        /// Door price update for order's cost evaluation
        /// </summary>
        /// <param name="EvalResults">list of DoorPriceDTO with UnitPrices</param>
        /// <returns></returns>
        [HttpPost("DoorPriceUpdate")]
        public async Task<string> DoorPriceUpdate(List<DoorPriceDTO> EvalResults)
        {
            string answ = "NA";
            var updateSet = EvalResults
                            .Where(x => x.Valid)
                            .ToDictionary(x => x.DoorId, x => x.UnitCost);
            bool fatto = await WDCService.DoorUpdateCosts(updateSet);
            answ = fatto ? "OK" : "NO";
            return answ;
        }

        private static IConfiguration _configuration = null!;

        private static Logger Log = LogManager.GetCurrentClassLogger();
        private WebDoorCreatorService WDCService { get; set; } = null!;
    }
}