using Microsoft.AspNetCore.Mvc;
using PolyclinicBusinessLogic.BusinessLogics;
using PolyclinicBusinessLogic.OfficePackage;
using PolyclinicContracts.BindingModels;
using PolyclinicContracts.BusinessLogicsContracts;
using PolyclinicContracts.SearchModels;
using PolyclinicContracts.ViewModels;
using PolyclinicDataModels.Models;
using PolyclinicWebAppSuretor.Models;
using System.Diagnostics;

namespace PolyclinicWebAppSuretor.Controllers
{
    public class HomeController : Controller
    {
        private readonly ILogger<HomeController> _logger;
        private readonly IProcedureLogic _procedureLogic;
        private readonly IMedicamentLogic _medicamentLogic;
        private readonly IRecipeLogic _recipeLogic;
        private readonly ISymptomLogic _symptomLogic;
        private readonly ICourseLogic _courseLogic;
        private readonly ISuretorReportLogic _suretorReportLogic;
        private readonly IUserLogic _userLogic;

        public HomeController(ILogger<HomeController> logger,
            IProcedureLogic procedureLogic,
            IMedicamentLogic medicamentLogic,
            IRecipeLogic recipeLogic,
            ISymptomLogic symptomLogic,
            ICourseLogic courseLogic,
            ISuretorReportLogic suretorReportLogic,
            IUserLogic userLogic)
        {
            _logger = logger;
            _procedureLogic = procedureLogic;
            _medicamentLogic = medicamentLogic;
            _recipeLogic = recipeLogic;
            _symptomLogic = symptomLogic;
            _courseLogic = courseLogic;
            _suretorReportLogic = suretorReportLogic;
            _userLogic = userLogic;
        }

        public IActionResult Index()
        {
            return View();
        }

        public IActionResult Privacy()
        {
            return View();
        }

        [HttpGet]
        [HttpPost]
        public IActionResult Register(RegisterModel model)
        {
            var errors = new List<string>();

            if (HttpContext.Request.Method == "POST")
            {
                var userEmail = _userLogic.ReadElement(new UserSearchModel { Email = model.Email });
                if (userEmail != null) errors.Add("Этот Email уже зарегистирован");
                if (model.Password != model.ConfirmPassword) errors.Add("Пароли не совпадают");
                if (errors.Count > 0)
                {
                    model.Errors = errors;
                    model.Email = string.Empty;
                    model.ConfirmPassword = string.Empty;
                    model.FIO = model.FIO;
                    return View(model);
                }
                /*var user = new UserViewModel { 
                    Email 
                };*/
                return RedirectToAction("Login");
            }
            else
            {
                return View();
            }
        }

        /// <summary>
        /// RECIPES
        /// </summary>
        /// <returns></returns>

        public IActionResult Recipes()
        {
            List<RecipeViewModel> recipes = _recipeLogic.ReadList(null);
            if (recipes == null)
            {
                recipes = new();
            }
            return View(recipes);
        }

        [HttpGet]
        [HttpPost]
        public IActionResult CreateRecipe(RecipeModel model, int[] selectedProcedures)
        {
            ViewBag.Courses = _courseLogic.ReadList();
            if (HttpContext.Request.Method == "GET")
            {
                ViewData["Title"] = "Новый рецепт";
                model = new()
                {
                    Procedures = _procedureLogic.ReadList().Select(x => (x, false)).ToList()
                };
                return View("CreateRecipe", model);
            }
            else
            {
                var allProcedures = _procedureLogic.ReadList(null);

                RecipeBindingModel recipe = new RecipeBindingModel
                {
                    ProceduresCount = model.RecipeViewModel.ProceduresCount,
                    Comment = model.RecipeViewModel.Comment,
                    CourseId = model.RecipeViewModel.CourseId,
                    RecipeProcedures = selectedProcedures
                        .ToDictionary(
                            x => x,
                            x => allProcedures.Where(y => y.Id == x) as IProcedureModel
                        )
                };

                _recipeLogic.Create(recipe);
                return RedirectToAction("Recipes");
            }
        }
        [HttpGet]
        [HttpPost]
        public IActionResult EditRecipe(int id, RecipeModel model, int[] selectedProcedures)
        {
            ViewBag.Courses = _courseLogic.ReadList();

            if (HttpContext.Request.Method == "GET")
            {
                var obj = _recipeLogic.ReadElement(new RecipeSearchModel { Id = id });
                model = new()
                {
                    RecipeViewModel = obj,
                    Procedures = _procedureLogic.ReadList().Select(x => (x, obj.RecipeProcedures.ContainsKey(x.Id))).ToList()
                };
                ViewData["Title"] = "Редактировать рецепт";
                return View("CreateRecipe", model);
            }
            else
            {
                var allProcedures = _procedureLogic.ReadList(null);

                RecipeBindingModel recipe = new RecipeBindingModel
                {
                    Id = id,
                    ProceduresCount = model.RecipeViewModel.ProceduresCount,
                    Comment = model.RecipeViewModel.Comment,
                    CourseId = model.RecipeViewModel.CourseId,
                    RecipeProcedures = selectedProcedures
                        .ToDictionary(
                            x => x,
                            x => allProcedures.Where(y => y.Id == x) as IProcedureModel
                        )
                };
                _recipeLogic.Update(recipe);
                return RedirectToAction("Recipes");
            }
        }
        [HttpPost]
        public IActionResult DeleteRecipe(int id)
        {
            var obj = _recipeLogic.ReadElement(new RecipeSearchModel { Id = id });
            if (obj != null)
            {
                _recipeLogic.Delete(new RecipeBindingModel { Id = obj.Id });
            }
            return RedirectToAction("Recipes");
        }

        /// <summary>
        /// MEDICAMENTS
        /// </summary>
        /// <returns></returns>

        public IActionResult Medicaments()
        {
            List<MedicamentViewModel> medicaments = _medicamentLogic.ReadList(null);
            if (medicaments == null)
            {
                medicaments = new();
            }
            return View(medicaments);
        }

        [HttpGet]
        [HttpPost]
        public IActionResult CreateMedicament(MedicamentViewModel model)
        {
            ViewBag.Procedures = _procedureLogic.ReadList(null);
            ViewBag.Symptomes = _symptomLogic.ReadList(null);
            if (HttpContext.Request.Method == "GET")
            {
                ViewData["Title"] = "Новый препарат";
                return View();
            }
            else
            {
                // TODO прописать UserId
                MedicamentBindingModel medicament = new MedicamentBindingModel
                {
                    Name = model.Name,
                    Comment = model.Comment ?? string.Empty,
                    SymptomId = model.SymptomId,
                    ProcedureId = model.ProcedureId,
                };
                _medicamentLogic.Create(medicament);
                return RedirectToAction("Medicaments");
            }
        }

        [HttpGet]
        [HttpPost]
        public IActionResult EditMedicament(MedicamentViewModel model)
        {
            ViewBag.Procedures = _procedureLogic.ReadList(null);
            ViewBag.Symptomes = _symptomLogic.ReadList(null);
            if (HttpContext.Request.Method == "GET")
            {
                var obj = _medicamentLogic.ReadElement(new MedicamentSearchModel { Id = model.Id });
                ViewData["Title"] = "Редактировать препарат";
                return View("CreateMedicament", obj);
            }
            else
            {
                MedicamentBindingModel medicament = new MedicamentBindingModel
                {
                    Id = model.Id,
                    Name = model.Name,
                    Comment = model.Comment ?? string.Empty,
                    SymptomId = model.SymptomId,
                    ProcedureId = model.ProcedureId,
                };
                _medicamentLogic.Update(medicament);
                return RedirectToAction("Medicaments");
            }
        }

        [HttpPost]
        public IActionResult DeleteMedicament(int id)
        {
            var obj = _medicamentLogic.ReadElement(new MedicamentSearchModel { Id = id });
            if (obj != null)
            {
                _medicamentLogic.Delete(new MedicamentBindingModel { Id = obj.Id });
            }
            return RedirectToAction("Medicaments");
        }


        public IActionResult Procedures()
        {
            List<ProcedureViewModel> procedure = _procedureLogic.ReadList(null);
            if (procedure == null)
            {
                procedure = new();
            }
            return View(procedure);
        }

        [HttpGet]
        [HttpPost]
        public IActionResult CreateProcedure(ProcedureViewModel model)
        {
            if (HttpContext.Request.Method == "GET")
            {
                ViewData["Title"] = "Новая процедура";
                return View();
            }
            else
            {
                // TODO прописать UserId
                ProcedureBindingModel procedure = new ProcedureBindingModel
                {
                    Name = model.Name,
                    Comment = model.Comment ?? string.Empty,
                    DateStartProcedure = model.DateStartProcedure,
                    DateStopProcedure = model.DateStopProcedure
                };
                _procedureLogic.Create(procedure);
                return RedirectToAction("Procedures");
            }
        }

        [HttpGet]
        [HttpPost]
        public IActionResult EditProcedure(ProcedureViewModel model)
        {
            if (HttpContext.Request.Method == "GET")
            {
                var obj = _procedureLogic.ReadElement(new ProcedureSearchModel { Id = model.Id });
                ViewData["Title"] = "Редактировать процедуру";
                return View("CreateProcedure", obj);
            }
            else
            {
                ProcedureBindingModel procedure = new ProcedureBindingModel
                {
                    Id = model.Id,
                    Name = model.Name,
                    Comment = model.Comment,
                    DateStartProcedure = model.DateStartProcedure,
                    DateStopProcedure = model.DateStopProcedure
                };
                _procedureLogic.Update(procedure);
                return RedirectToAction("Procedures");
            }
        }

        [HttpPost]
        public IActionResult DeleteProcedure(int id)
        {
            var obj = _procedureLogic.ReadElement(new ProcedureSearchModel { Id = id });
            if (obj != null)
            {
                _procedureLogic.Delete(new ProcedureBindingModel { Id = obj.Id });
            }
            return RedirectToAction("Procedures");
        }



        public IActionResult AddSymptomToMedicament(AddSymptomToMedicamentModel model)
        {
            model = new()
            {
                Medicaments = _medicamentLogic.ReadList(null),
                Symptoms = _symptomLogic.ReadList(null)
            };
            return View(model);
        }

        public IActionResult ListCoursesByProcedures()
        {
            ViewBag.Procedures = _procedureLogic.ReadList(null);
            return View();
        }

        [HttpPost]
        public IActionResult CreateWordFile(int procedureId, string fileName, string fileFormat)
        {
            var procedure = _procedureLogic.ReadElement(new ProcedureSearchModel { Id = procedureId });
            ViewBag.Procedures = procedure;

            fileName = fileName + $".{fileFormat}";

            if (procedure == null)
            {
                return NotFound("Процедура не найдена");
            }

            var report = new ReportBindingModel
            {
                FileName = fileName,
            };

            var procedureSearch = new ProcedureSearchModel { Id = procedureId };

            procedureSearch.Name = procedure.Name;

            if (fileFormat == "docx")
            {
                _suretorReportLogic.SaveCoursesByProcedureToWordFile(report, procedureSearch);
            }
            else if (fileFormat == "xlsx")
            {
                _suretorReportLogic.SaveCoursesByProcedureToExcelFile(report, procedureSearch);
            }

            var filePath = Path.Combine(Directory.GetCurrentDirectory(), fileName);
            byte[] fileBytes = System.IO.File.ReadAllBytes(filePath);
            string mimeType = fileFormat.ToLower() == "docx" ? "application/vnd.openxmlformats-officedocument.wordprocessingml.document" : "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
            return File(fileBytes, mimeType, fileName);
        }

        /// <summary>
        // PROCEDURESREPORT
        /// </summary>
        /// <returns></returns>

        [HttpGet]
        /*public IActionResult ProceduresReport()
        {
            return View(new List<ReportProceduresViewModel>());
        }*/

        [HttpPost]
        public IActionResult ProceduresReport(DateTime? dateFrom, DateTime? dateTo, string reportType)
        {
            if (reportType == "form")
            {
                var proceduresReport = _suretorReportLogic.GetProceduresByMedicametsAndSymptoms();

                // Фильтрация данных по дате (если нужно)
                if (dateFrom.HasValue)
                {
                    proceduresReport = proceduresReport.Where(p => p.DateStartProcedure >= dateFrom.Value).ToList();
                }
                if (dateTo.HasValue)
                {
                    proceduresReport = proceduresReport.Where(p => p.DateStopProcedure <= dateTo.Value).ToList();
                }

                return View(proceduresReport);
            }
            else if (reportType == "email")
            {
                var reportBindingModel = new ReportBindingModel
                {
                    FileName = "ProceduresReport.pdf",
                    DateFrom = dateFrom,
                    DateTo = dateTo
                };

                _suretorReportLogic.SaveProceduresToPdfFile(reportBindingModel);

                // Чтение сгенерированного файла
                var fileName = "ProceduresReport.pdf";
                var filePath = Path.Combine(Directory.GetCurrentDirectory(), fileName);
                byte[] fileBytes = System.IO.File.ReadAllBytes(filePath);
                // Возвращаем файл в виде скачиваемого контента
                return File(fileBytes, "application/pdf", fileName);
            }
            else
            {
                return View(new List<ReportProceduresViewModel>());
            }
        }


        [HttpGet]
        [HttpPost]
        public IActionResult Login()
        {
            if (HttpContext.Request.Method == "POST")
            {
                // какие-то действия при нажатии кнопки входа
                return View();
            }
            else
            {
                return View();
            }
        }

        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public IActionResult Error()
        {
            return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
        }
    }
}