using ComputerShopImplementerApp.Models;
using ComputerShopContracts.BindingModels;
using ComputerShopContracts.ViewModels;
using Microsoft.AspNetCore.Mvc;
using System.Diagnostics;
using ComputerShopDataModels.Enums;
using ComputerShopDataModels.Models;
using ComputerShopContracts.SearchModels;
using ComputerShopContracts.BusinessLogicContracts;

namespace ComputerShopImplementerApp.Controllers
{
	public class HomeController : Controller
	{
		private readonly ILogger<HomeController> _logger;
		private readonly IReportImplementerLogic _logic;

		public HomeController(ILogger<HomeController> logger, IReportImplementerLogic logic)
		{
			_logger = logger;
			_logic = logic;
		}

		public IActionResult Index()
		{
			if (APIUser.User == null)
			{
				return Redirect("~/Home/Enter");
			}
			return View(/*APIUser.GetRequest<List<OrderViewModel>>($"api/main/getorders?userId={APIUser.User.Id}")*/);
		}

		//			ЗАКАЗЫ						ЗАКАЗЫ					ЗАКАЗЫ				ЗАКАЗЫ					ЗАКАЗЫ

		//!!!МБ ДОБАВИТЬ [HttpGet]
		public IActionResult Orders()
		{
			if (APIUser.User == null)
			{
				return Redirect("~/Home/Enter");
			}
			return View(APIUser.GetRequest<List<OrderViewModel>>($"api/order/getorders?userId={APIUser.User.Id}"));
		}

		[HttpGet]
		public OrderViewModel GetOrder(int orderId)
		{
			if (APIUser.User == null)
			{
				throw new Exception("Необходима авторизация");
			}
			var result = APIUser.GetRequest<OrderViewModel>($"api/order/getorder?id={orderId}");
			if (result == null)
			{
				return default;
			}
			return result;
		}




		[HttpGet]
		public IActionResult CreateOrder()
		{
			//!!!ПОТОМ УДАЛИТЬ
			//ViewBag.OrderStatuses = APIUser.GetRequest<List<String>>("api/order/getorderstatuses");
			return View();
		}


		[HttpPost]
		public void CreateOrder(OrderStatus status, DateTime date)
		{
			if (APIUser.User == null)
			{
				throw new Exception("Вход только авторизованным");
			}
			//if (count <= 0)
			//{
			//	throw new Exception("Количество и сумма должны быть больше 0");
			//}
			APIUser.PostRequest("api/order/createorder", new OrderBindingModel
			{
				UserId = APIUser.User.Id,
				Status = status,
				DateCreate = date,
				Sum = 0
			});
			Response.Redirect("Orders");
		}



		[HttpGet]
		public IActionResult UpdateOrder()
		{
			if (APIUser.User == null)
			{
				return Redirect("~/Home/Enter");
			}
			ViewBag.Orders = APIUser.GetRequest<List<OrderViewModel>>($"api/order/getorders?userId={APIUser.User.Id}");
			//ViewBag.Statuses = 
			return View();
		}

		//МБ ПОСТАВИТЬ int? и передавать order.Value
		[HttpPost]
		public void UpdateOrder(int order, OrderStatus status, DateTime date, double sum)
		{
			if (APIUser.User == null)
			{
				throw new Exception("Вход только авторизованным");
			}
			if (order == null)
			{
				throw new Exception("Выберите заказ для изменения");
			}
			if (status == null)
			{
				throw new Exception("Выберите статус для заказа");
			}
			//if (count <= 0)
			//{
			//	throw new Exception("Количество и сумма должны быть больше 0");
			//}
			APIUser.PostRequest("api/order/updateorder", new OrderBindingModel
			{
				Id = order,
				UserId = APIUser.User.Id,
				Status = status,
				DateCreate = date,
				Sum = sum
			});
			Response.Redirect("Orders");
		}


		[HttpGet]
		public IActionResult DeleteOrder()
		{
			if (APIUser.User == null)
			{
				return Redirect("~/Home/Enter");
			}
			ViewBag.Orders = APIUser.GetRequest<List<OrderViewModel>>($"api/order/getorders?userId={APIUser.User.Id}");
			//ViewBag.Statuses = 
			return View();
		}

		[HttpPost]
		public void DeleteOrder(int order)
		{
			if (APIUser.User == null)
			{
				throw new Exception("Вход только авторизованным");
			}
			//if (count <= 0)
			//{
			//	throw new Exception("Количество и сумма должны быть больше 0");
			//}
			APIUser.PostRequest("api/order/deleteorder", new OrderBindingModel
			{
				Id = order
			});
			Response.Redirect("Orders");
		}





		//			ПАРТИИ ТОВАРОВ			ПАРТИИ ТОВАРОВ			ПАРТИИ ТОВАРОВ			ПАРТИИ ТОВАРОВ				ПАРТИИ ТОВАРОВ

		public async Task<IActionResult> Shipments()
		{
			if (APIUser.User == null)
			{
				return Redirect("~/Home/Enter");
			}
			var shipments = await APIUser.GetRequestShipmentAsync<List<ShipmentViewModel>>($"api/shipment/getshipments?userId={APIUser.User.Id}");

			return View(shipments);
		}

		[HttpGet]
		public async Task<ShipmentViewModel> GetShipment(int shipmentId)
		{
			if (APIUser.User == null)
			{
				throw new Exception("Необходима авторизация");
			}
			//GetRequestShipmentAsync
			var result = await APIUser.GetRequestShipmentAsync<ShipmentViewModel>($"api/shipment/getshipment?id={shipmentId}");
			if (result == null)
			{
				return default;
			}
			return result;
		}


		[HttpGet]
		public IActionResult CreateShipment()
		{
			if (APIUser.User == null)
			{
				throw new Exception("Вход только авторизованным");
			}
			ViewBag.Orders = APIUser.GetRequest<List<OrderViewModel>>($"api/order/getorders?userId={APIUser.User.Id}");
			return View();
		}


		[HttpPost]
		public void CreateShipment(string providerName, DateTime date, int[] orders)
		{
			if (APIUser.User == null)
			{
				throw new Exception("Вход только авторизованным");
			}
			// Создаем словарь из выбранных заказов
			var selectedOrders = new Dictionary<int, IOrderModel>();
			foreach (var orderId in orders)
			{
				selectedOrders.Add(orderId, new OrderSearchModel { Id = orderId } as IOrderModel);
				//var orderModel = APIUser.GetRequest<OrderViewModel>($"api/order/getorder?id={orderId}");
				//selectedOrders.Add(orderId, orderModel);
			}

			APIUser.PostRequest("api/shipment/createshipment", new ShipmentBindingModel
			{
				UserId = APIUser.User.Id,
				ProviderName = providerName,
				DateShipment = date,
				ShipmentOrders = selectedOrders
			});
			Response.Redirect("Shipments");
		}


		//!!!МБ СДЕЛАТЬ ПО АНАЛОГИИ С public async Task<IActionResult> Shipments()
		[HttpGet]
		public async Task<IActionResult> UpdateShipment()
		{
			if (APIUser.User == null)
			{
				throw new Exception("Вход только авторизованным");
			}
			ViewBag.Shipments = await APIUser.GetRequestShipmentAsync<List<ShipmentViewModel>>($"api/shipment/getshipments?userId={APIUser.User.Id}");
			ViewBag.Orders = APIUser.GetRequest<List<OrderViewModel>>($"api/order/getorders?userId={APIUser.User.Id}");
			return View();
		}

		[HttpPost]
		public void UpdateShipment(int shipment, string providerName, DateTime date, int[] orders)
		{
			if (APIUser.User == null)
			{
				throw new Exception("Вход только авторизованным");
			}
			// Создаем словарь из выбранных заказов
			var selectedOrders = new Dictionary<int, IOrderModel>();
			foreach (var orderId in orders)
			{
				selectedOrders.Add(orderId, new OrderSearchModel { Id = orderId } as IOrderModel);
			}

			APIUser.PostRequest("api/shipment/updateshipment", new ShipmentBindingModel
			{
				Id = shipment,
				UserId = APIUser.User.Id,
				ProviderName = providerName,
				DateShipment = date,
				ShipmentOrders = selectedOrders
			});
			Response.Redirect("Shipments");
		}

		[HttpGet]
		public async Task<IActionResult> DeleteShipment()
		{
			if (APIUser.User == null)
			{
				throw new Exception("Вход только авторизованным");
			}
			ViewBag.Shipments = await APIUser.GetRequestShipmentAsync<List<ShipmentViewModel>>($"api/shipment/getshipments?userId={APIUser.User.Id}");
			return View();
		}


		//[HttpPost]
		//public void DeleteShipment(int shipment)
		//{
		//	if (APIUser.User == null)
		//	{
		//		throw new Exception("Вход только авторизованным");
		//	}
		//	APIUser.PostRequest("api/shipment/deleteshipment", new ShipmentBindingModel
		//	{
		//		Id = shipment
		//	});
		//	Response.Redirect("Shipments");
		//}


		[HttpPost]
		public async Task<IActionResult> DeleteShipment(int shipment)
		{
			if (APIUser.User == null)
			{
				throw new Exception("Вход только авторизованным");
			}
			await APIUser.PostRequestAsync("api/shipment/deleteshipment", new ShipmentBindingModel
			{
				Id = shipment
			});
			return RedirectToAction("Shipments");
		}




		//	ЗАЯВКИ НА СБОРКИ			ЗАЯВКИ НА СБОРКИ			ЗАЯВКИ НА СБОРКИ		ЗАЯВКИ НА СБОРКИ		ЗАЯВКИ НА СБОРКИ
		
		
		//public IActionResult Requests()
		//{
		//	if (APIUser.User == null)
		//	{
		//		return Redirect("~/Home/Enter");
		//	}
		//	return View(APIUser.GetRequest<List<RequestViewModel>>($"api/request/getrequests?userId={APIUser.User.Id}"));
		//}


		//МБ ТАК Requests
		public async Task<IActionResult> Requests()
		{
			if (APIUser.User == null)
			{
				return Redirect("~/Home/Enter");
			}
			var requests = await APIUser.GetRequestRequestAsync<List<RequestViewModel>>($"api/request/getrequests?userId={APIUser.User.Id}");
			//var shipments = await APIUser.GetRequestShipmentAsync<List<ShipmentViewModel>>($"api/shipment/getshipments?userId={APIUser.User.Id}");

			return View(requests);
		}


		[HttpGet]
		public async Task<RequestViewModel> GetRequest(int requestId)
		{
			if (APIUser.User == null)
			{
				throw new Exception("Необходима авторизация");
			}
			//GetRequestShipmentAsync
			var result = await APIUser.GetRequestRequestAsync<RequestViewModel>($"api/request/getrequest?id={requestId}");
			if (result == null)
			{
				return default;
			}
			return result;
		}



		[HttpGet]
		public IActionResult CreateRequest()
		{
			if (APIUser.User == null)
			{
				throw new Exception("Вход только авторизованным");
			}
			ViewBag.Orders = APIUser.GetRequest<List<OrderViewModel>>($"api/order/getorders?userId={APIUser.User.Id}");
			return View();
		}


		[HttpPost]
		public void CreateRequest(string clientFIO, DateTime date, int[] orders)
		{
			if (APIUser.User == null)
			{
				throw new Exception("Вход только авторизованным");
			}
			// Создаем словарь из выбранных заказов
			var selectedOrders = new Dictionary<int, IOrderModel>();
			foreach (var orderId in orders)
			{
				selectedOrders.Add(orderId, new OrderSearchModel { Id = orderId } as IOrderModel);
			}

			APIUser.PostRequest("api/request/createrequest", new RequestBindingModel
			{
				UserId = APIUser.User.Id,
				ClientFIO = clientFIO,
				DateRequest = date,
				RequestOrders = selectedOrders
			});
			Response.Redirect("Requests");
		}


		[HttpGet]
		public async Task<IActionResult> UpdateRequest()
		{
			if (APIUser.User == null)
			{
				throw new Exception("Вход только авторизованным");
			}
			ViewBag.Requests = await APIUser.GetRequestRequestAsync<List<RequestViewModel>>($"api/request/getrequests?userId={APIUser.User.Id}");
			ViewBag.Orders = APIUser.GetRequest<List<OrderViewModel>>($"api/order/getorders?userId={APIUser.User.Id}");
			return View();
		}

		[HttpPost]
		public void UpdateRequest(int request, string clientFIO, DateTime date, int[] orders)
		{
			if (APIUser.User == null)
			{
				throw new Exception("Вход только авторизованным");
			}
			// Создаем словарь из выбранных заказов
			var selectedOrders = new Dictionary<int, IOrderModel>();
			foreach (var orderId in orders)
			{
				selectedOrders.Add(orderId, new OrderSearchModel { Id = orderId } as IOrderModel);
			}

			APIUser.PostRequest("api/request/updaterequest", new RequestBindingModel
			{
				Id = request,
				UserId = APIUser.User.Id,
				ClientFIO = clientFIO,
				DateRequest = date,
				RequestOrders = selectedOrders
			});
			Response.Redirect("Requests");
		}


		[HttpGet]
		public async Task<IActionResult> ConnectRequestAssembly()
		{
			if (APIUser.User == null)
			{
				throw new Exception("Вход только авторизованным");
			}
			ViewBag.Requests = await APIUser.GetRequestRequestAsync<List<RequestViewModel>>($"api/request/getrequests?userId={APIUser.User.Id}");
			//ViewBag.Orders = APIUser.GetRequest<List<OrderViewModel>>($"api/order/getorders?userId={APIUser.User.Id}");
			ViewBag.Assemblies = APIUser.GetRequest<List<AssemblyViewModel>>($"api/assembly/getassemblies");
			return View();
		}

		[HttpPost]
		public void ConnectRequestAssembly(int request, int assembly)
		{
			if (APIUser.User == null)
			{
				throw new Exception("Вход только авторизованным");
			}

			APIUser.PostRequest("api/request/connectRequestAssembly", new RequestBindingModel
			{
				Id = request,
				AssemblyId = assembly
			});
			Response.Redirect("Requests");
		}




		[HttpGet]
		public async Task<IActionResult> DeleteRequest()
		{
			if (APIUser.User == null)
			{
				throw new Exception("Вход только авторизованным");
			}
			ViewBag.Requests = await APIUser.GetRequestRequestAsync<List<RequestViewModel>>($"api/request/getrequests?userId={APIUser.User.Id}");
			return View();
		}

		[HttpPost]
		public async Task<IActionResult> DeleteRequest(int request)
		{
			if (APIUser.User == null)
			{
				throw new Exception("Вход только авторизованным");
			}
			await APIUser.PostRequestAsync("api/request/deleterequest", new RequestBindingModel
			{
				Id = request
			});
			return RedirectToAction("Requests");
		}


        //ОТЧЁТЫ	ОТЧЁТЫ		ОТЧЁТЫ		ОТЧЁТЫ		ОТЧЁТЫ		ОТЧЁТЫ		ОТЧЁТЫ		ОТЧЁТЫ		ОТЧЁТЫ		ОТЧЁТЫ		ОТЧЁТЫ

        [HttpGet]
        public IActionResult ReportOrdersAssembliesToFile()
        {
            if (APIUser.User == null)
            {
                return Redirect("~/Home/Enter");
            }
            ViewBag.Orders = APIUser.GetRequest<List<OrderViewModel>>($"api/order/getorders?userId={APIUser.User.Id}");
            //ViewBag.Statuses = 
            return View();
        }

		[HttpPost]
		public void ReportOrdersAssembliesToFile(int[] orders, string type)
		{
            if (APIUser.User == null)
            {
				Redirect("Index");
                throw new Exception("Вход только авторизованным");
            }
            if (orders.Length <= 0)
            {
                throw new Exception("Выберите хотя бы 1 заказ");
            }
            if (string.IsNullOrEmpty(type))
            {
                throw new Exception("Неверный тип отчета");
            }

			//Преобразование массива в список
            List<int> ids = new List<int>();
            foreach (var item in orders)
            {
                ids.Add(item);
            }

            if (type == "docx")
			{
                APIUser.PostRequest("api/order/createreporttowordfile", new ReportBindingModel
                {
                    Ids = ids,
                    FileName = "C:\\!КУРСОВАЯ\\Сборки по выбранным заказам.docx"
                });
                Response.Redirect("Index");
            }

			if (type == "xlsx")
			{
                APIUser.PostRequest("api/order/createreporttoexcelfile", new ReportBindingModel
                {
                    Ids = ids,
                    FileName = "C:\\!КУРСОВАЯ\\Сборки по выбранным заказам.xlsx"
                });
                Response.Redirect("Index");
            }
        }


        [HttpGet]
        public IActionResult ReportOrdersByDates()
        {
            if (APIUser.User == null)
            {
                return Redirect("~/Home/Enter");
            }
            //ViewBag.Orders = APIUser.GetRequest<List<OrderViewModel>>($"api/order/getorders?userId={APIUser.User.Id}");
            //ViewBag.Statuses = 
            return View();
        }

		[HttpGet]
		public string GetOrdersReportByDates(DateTime dateFrom, DateTime dateTo)
		{
			if (APIUser.User == null)
			{
				throw new Exception("Вход только авторизованным");
			}
			List<ReportOrdersViewModel> result;
			try
			{
				result = _logic.GetReportOrdersByDates(new ReportBindingModel
				{
					UserId = APIUser.User.Id,
					DateFrom = dateFrom,
					DateTo = dateTo
				});
			}
			catch (Exception ex)
			{
				_logger.LogError(ex, "Ошибка создания отчета");
				throw;
			}
			string table = "";
			return table;
		}




		//	ОСТАЛЬНОЕ			ОСТАЛЬНОЕ			ОСТАЛЬНОЕ			ОСТАЛЬНОЕ			ОСТАЛЬНОЕ		ОСТАЛЬНОЕ		ОСТАЛЬНОЕ

		[HttpGet]
		public IActionResult Privacy()
		{
			if (APIUser.User == null)
			{
				return Redirect("~/Home/Enter");
			}
			return View(APIUser.User);
		}

		[HttpPost]
		public void Privacy(string login, string password, string email)
		{
			if (APIUser.User == null)
			{
				throw new Exception("Вход только авторизованным");
			}
			if (string.IsNullOrEmpty(login) || string.IsNullOrEmpty(password) || string.IsNullOrEmpty(email))
			{
				throw new Exception("Введите логин, пароль и почту");
			}
			APIUser.PostRequest("api/user/updatedata", new UserBindingModel
			{
				Id = APIUser.User.Id,
				Login = login,
				Password = password,
				Email = email
			});

			APIUser.User.Login = login;
			APIUser.User.Password = password;
			APIUser.User.Email = email;
			Response.Redirect("Index");
		}

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

		[HttpGet]
		public IActionResult Enter()
		{
			return View();
		}

		[HttpPost]
		public void Enter(string login, string password)
		{
			if (string.IsNullOrEmpty(login) || string.IsNullOrEmpty(password))
			{
				throw new Exception("Введите логин и пароль");
			}
			APIUser.User = APIUser.GetRequest<UserViewModel>($"api/user/loginimplementer?login={login}&password={password}");
			if (APIUser.User == null)
			{
				throw new Exception("Неверный логин/пароль");
			}
			Response.Redirect("Index");
		}

		[HttpGet]
		public IActionResult Register()
		{
			return View();
		}

		[HttpPost]
		public void Register(string login, string password, string email)
		{
			if (string.IsNullOrEmpty(login) || string.IsNullOrEmpty(password) || string.IsNullOrEmpty(email))
			{
				throw new Exception("Введите логин, пароль и почту");
			}
			APIUser.PostRequest("api/user/registerimplementer", new UserBindingModel
			{
				Login = login,
				Password = password,
				Email = email
			});
			Response.Redirect("Enter");
			return;
		}
	}
}