using CsvHelper;
using Globallcoach.Models;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System;

namespace Globallcoach.Controllers
{
	public class AdminImportController : Controller
    {
		private void CreateDocument(int deployment, DocumentItem item)
		{
			// TODO: Check permissions

			item.Save(HttpContext);
		}

		private string FindExistingDocument(IDatabaseConnection connection, int type, string name, string parent)
        {
            IDatabaseQuery query = connection.CreateQuery("SELECT guid FROM documents INNER JOIN document_versions ON documents.database_revision = document_versions.database_revision AND documents.guid = document_versions.document_guid WHERE deleted_revision = 0 AND document_type_id = @type AND parent_guid = @parent AND title = @name");
			query.AddParameter("type", type);
			query.AddParameter("parent", parent);
			query.AddParameter("name", name);

			using (IDatabaseQueryResult result = query.RunQuery())
			{
				if (result.Read())
				{
					return result.GetString(0);
				}
			}

			return null;
        }

		private string GetLeague(IDatabaseConnection connection, int deployment, string name)
        {
            string guid = FindExistingDocument(connection, Constants.DocumentTypeLeague, name, Constants.ParentLcsp);

            if (string.IsNullOrEmpty(guid))
            {
                DocumentItem league = new DocumentItem(deployment, Constants.DocumentTypeLeague, Constants.ParentLcsp);
				league.Name = name;
				CreateDocument(deployment, league);
				guid = league.Guid;
            }

            return guid;
        }

        private string GetClub(IDatabaseConnection connection, int deployment, string leagueGuid, string name)
        {
            string guid = FindExistingDocument(connection, Constants.DocumentTypeClub, name, leagueGuid);

            if (string.IsNullOrEmpty(guid))
            {
                DocumentItem club = new DocumentItem(deployment, Constants.DocumentTypeClub, leagueGuid);
				club.Name = name;
				CreateDocument(deployment, club);
				guid = club.Guid;
            }

            return guid;
        }

        private string GetSquad(IDatabaseConnection connection, int deployment, string clubGuid, string name)
        {
            string guid = FindExistingDocument(connection, Constants.DocumentTypeSquad, name, clubGuid);

            if (string.IsNullOrEmpty(guid))
            {
				DocumentItem squad = new DocumentItem(deployment, Constants.DocumentTypeSquad, clubGuid);
				squad.Name = name;
				CreateDocument(deployment, squad);
				guid = squad.Guid;
            }

            return guid;
        }

		public string GetSquadGuid(IDatabaseConnection connection, int deployment, ImportItem item)
        {
            string league = GetLeague(connection, deployment, item.League);
            string club = GetClub(connection, deployment, league, item.Club);
            string squad = GetSquad(connection, deployment, club, item.Squad);

            return squad;
        }

		public int GetUserId(IDatabaseConnection connection, string email)
		{
			IDatabaseQuery query = connection.CreateQuery("SELECT id FROM users WHERE email = @email");
			query.AddParameter("email", email);

			using (IDatabaseQueryResult result = query.RunQuery())
			{
				if (result.Read())
				{
					return result.GetInt32(0);
				}
			}

			return -1;
		}

		public int GetApiId(IDatabaseConnection connection, string email)
		{
			IDatabaseQuery query = connection.CreateQuery("SELECT api_id FROM users WHERE email = @email");
			query.AddParameter("email", email);

			using (IDatabaseQueryResult result = query.RunQuery())
			{
				if (result.Read())
				{
					return result.GetInt32(0);
				}
			}

			return -1;
		}

		private void ProcessDocument(int id, string data, int deployment)
		{
			using (IDatabaseConnection deploymentConnection = DatabaseUtilities.GetDeploymentConnection())
			{
				using (IDatabaseConnection clientConnection = DatabaseUtilities.GetClientConnection(deployment))
				{
					IDatabaseQuery query = deploymentConnection.CreateQuery("UPDATE csv_imports SET processing = true WHERE id = @id");
					query.AddParameter("id", id);
					query.RunNonQuery();

					ImportItem item = ParseLine(data);

					if (item == null)
						return;

					if (string.IsNullOrEmpty(item.League))
					{
						CreateImportError(deploymentConnection, id, deployment, data, "Player does not have a league");
						return;
					}

					if (string.IsNullOrEmpty(item.Club))
					{
						CreateImportError(deploymentConnection, id, deployment, data, "Player does not have a club");
						return;
					}

					if (string.IsNullOrEmpty(item.Squad))
					{
						CreateImportError(deploymentConnection, id, deployment, data, "Player does not have a squad");
						return;
					}

					if (!string.IsNullOrEmpty(item.GuardianEmail) && string.IsNullOrEmpty(item.GuardianName))
					{
						CreateImportError(deploymentConnection, id, deployment, data, "Primary guardian does not have a name");
						return;
					}

					if (!string.IsNullOrEmpty(item.SecondaryGuardianEmail) && string.IsNullOrEmpty(item.SecondaryGuardianName))
					{
						CreateImportError(deploymentConnection, id, deployment, data, "Secondary guardian does not have a name");
						return;
					}

					string squadGuid = GetSquadGuid(clientConnection, deployment, item);

					if (!UserUtilities.IsValidEmail(item.Email))
					{
						item.Email = UserUtilities.GenerateEmailForUser(item.Name, deployment);
					}

					if (string.IsNullOrEmpty(item.Name))
					{
						CreateImportError(deploymentConnection, id, deployment, data, "Player does not have a name");
						return;
					}

					query = deploymentConnection.CreateQuery("UPDATE csv_imports SET email = @email WHERE id = @id");
					query.AddParameter("email", item.Email);
					query.AddParameter("id", id);
					query.RunNonQuery();

					int primaryParentId = -1;
					int secondaryParentId = -1;

					if (!string.IsNullOrEmpty(item.GuardianName))
					{
						string primaryEmail = item.GuardianEmail;

						if (!UserUtilities.IsValidEmail(primaryEmail))
						{
							primaryEmail = UserUtilities.GenerateEmailForUser(item.GuardianName, deployment);
						}

						if (UserUtilities.UserExists(deploymentConnection, primaryEmail))
						{
							UserItem parent = new UserItem(deployment, GetApiId(deploymentConnection, primaryEmail));
							parent.Load();

							if (parent.ClientRoleId == Constants.ClientRoleGuardian)
								primaryParentId = GetUserId(deploymentConnection, primaryEmail);
						}
						else
						{
							UserItem guardianUser = new UserItem();
							guardianUser.FullName = item.GuardianName;
							guardianUser.Email = primaryEmail;
							guardianUser.DeploymentId = deployment;
							guardianUser.ClientRoleId = Constants.ClientRoleGuardian;
							guardianUser.DeploymentRoleId = Constants.DeploymentRoleNone;
							guardianUser.Save(HttpContext);

							primaryParentId = guardianUser.Id;
						}
					}

					if (!string.IsNullOrEmpty(item.SecondaryGuardianName))
					{
						string secondaryEmail = item.SecondaryGuardianEmail;

						if (!UserUtilities.IsValidEmail(secondaryEmail))
						{
							secondaryEmail = UserUtilities.GenerateEmailForUser(item.SecondaryGuardianName, deployment);
						}

						if (UserUtilities.UserExists(deploymentConnection, secondaryEmail))
						{
							UserItem secondaryParent = new UserItem(deployment, GetApiId(deploymentConnection, secondaryEmail));
							secondaryParent.Load();

							if (secondaryParent.ClientRoleId == Constants.ClientRoleGuardian)
								secondaryParentId = GetUserId(deploymentConnection, secondaryEmail);
						}
						else
						{
							UserItem guardianUser = new UserItem();
							guardianUser.FullName = item.SecondaryGuardianName;
							guardianUser.Email = secondaryEmail;
							guardianUser.DeploymentId = deployment;
							guardianUser.ClientRoleId = Constants.ClientRoleGuardian;
							guardianUser.DeploymentRoleId = Constants.DeploymentRoleNone;
							guardianUser.Save(HttpContext);

							secondaryParentId = guardianUser.Id;
						}
					}

					UserItem playerUser = new UserItem();
					playerUser.FullName = item.Name;
					playerUser.Email = item.Email;
					playerUser.DeploymentId = deployment;
					playerUser.ClientRoleId = Constants.ClientRolePlayer;
					playerUser.DeploymentRoleId = Constants.DeploymentRoleNone;
					playerUser.PrimaryParentId = primaryParentId;
					playerUser.SecondaryParentId = secondaryParentId;
					playerUser.Save(HttpContext);

					int apiId = playerUser.ApiId;

					DocumentItem player = new DocumentItem(deployment, Constants.DocumentTypePlayer, squadGuid);
					player.Name = item.Name;
					player.Guid = Utilities.GetPlayerGuid(apiId);

					PlayerDocumentData playerData = (PlayerDocumentData)player.Data;
					playerData.Number = item.Number;
					playerData.PhoneNumber = item.PhoneNumber;
					playerData.DateOfBirth = item.DateOfBirth;
					playerData.YouthNationality = item.Nationality;
					playerData.Email = item.Email;
					playerData.Graduation = item.Graduation;
					playerData.Save(HttpContext);

					DocumentItem guardian = new DocumentItem(deployment, Constants.DocumentTypePlayerGuardian, player.Guid);
					guardian.Name = "Player: Guardian (" + DateTime.Now.ToString("dd/MM/yyyy") + ")";
					GuardianDocumentData guardianData = (GuardianDocumentData)guardian.Data;
					guardianData.PrimaryGuardian = item.GuardianName;
					guardianData.PrimaryRelationship = item.GuardianRelationship;
					guardianData.PrimaryAddress = item.GuardianAddress;
					guardianData.PrimaryPhoneNumber = item.GuardianPhoneNumber;
					guardianData.PrimaryEmail = item.GuardianEmail;
					guardianData.SecondaryGuardian = item.SecondaryGuardianName;
					guardianData.SecondaryRelationship = item.SecondaryGuardianRelationship;
					guardianData.SecondaryAddress = item.SecondaryGuardianAddress;
					guardianData.SecondaryPhoneNumber = item.SecondaryGuardianPhoneNumber;
					guardianData.SecondaryEmail = item.SecondaryGuardianEmail;
					guardian.Save(HttpContext);

					DocumentItem academic = new DocumentItem(deployment, Constants.DocumentTypePlayerAcademic, player.Guid);
					academic.Name = "Player: Academic (" + DateTime.Now.ToString("dd/MM/yyyy") + ")";
					AcademicDocumentData academicData = (AcademicDocumentData)academic.Data;
					academicData.School = item.AcademicSchool;
					academicData.GPA = item.AcademicGPA;
					academicData.ACT = item.AcademicACT;
					academicData.TOEFL = item.AcademicTOEFL;
					academic.Save(HttpContext);

					query = deploymentConnection.CreateQuery("UPDATE csv_imports SET processed = true, processing = false, error = null WHERE id = @id");
					query.AddParameter("id", id);
					query.RunNonQuery();
				}
			}
		}

		public void CreateImportError(IDatabaseConnection connection, int id, int deployment, string data, string error)
		{
			IDatabaseQuery query = connection.CreateQuery("UPDATE csv_imports SET processed = true, processing = false, error = @error WHERE id = @id");
			query.AddParameter("id", id);
			query.AddParameter("error", error);
			query.RunNonQuery();
		}

		public async Task ProcessDocuments(int deployment)
		{
			using (IDatabaseConnection connection = Globallcoach.Database.CreateConnection(Constants.DeploymentDatabase))
			{
				IDatabaseQuery query = connection.CreateQuery("SELECT id, header, data FROM csv_imports WHERE deployment = @deployment AND user_id = @user AND processing = false AND processed = false");
				query.AddParameter("deployment", deployment);
				query.AddParameter("user", UserUtilities.GetAdminId(HttpContext));

				using (IDatabaseQueryResult result = query.RunQuery())
				{
					while (result.Read())
					{
						ProcessDocument(result.GetInt32(0), result.GetString(1) + result.GetString(2), deployment);
						await Task.Delay(0);
					}
				}
			}
		}

		public ImportItem ParseLine(string csv)
		{
			ImportItem item = new ImportItem();

			var reader = new CsvReader(new StringReader(csv));

			if (reader.Read())
			{
				if (!reader.IsRecordEmpty())
				{
					string name;
					if (reader.TryGetField<string>("Player Name", out name))
						item.Name = name.Trim();

					int number;
					if (reader.TryGetField<int>("Player Number", out number))
						item.Number = number;

					string squad;
					if (reader.TryGetField<string>("Squad", out squad))
						item.Squad = squad.Trim();

					DateTime dob;
					if (reader.TryGetField<DateTime>("Player dob", out dob))
						item.DateOfBirth = dob;

					string nationality;
					if (reader.TryGetField<string>("Player Nationality", out nationality))
						item.Nationality = nationality;

					string email;
					if (reader.TryGetField<string>("Player Email", out email))
						item.Email = email;

					string phoneNo;
					if (reader.TryGetField<string>("Player Phone Number", out phoneNo))
						item.PhoneNumber = phoneNo;

					DateTime graduation;
					if (reader.TryGetField<DateTime>("Player Graduation Year", out graduation))
						item.Graduation = graduation;

					string playerId;
					if (reader.TryGetField<string>("Player Identification", out playerId))
						item.PlayerIdentification = playerId;

					string coachName;
					if (reader.TryGetField<string>("Coach Name", out coachName))
						item.CoachName = coachName;

					string coachAddress;
					if (reader.TryGetField<string>("Coach Address", out coachAddress))
						item.CoachAddress = coachAddress;

					string coachPhone;
					if (reader.TryGetField<string>("Coach Phone Number", out coachPhone))
						item.CoachPhoneNumber = coachPhone;

					string coachEmail;
					if (reader.TryGetField<string>("Coach Email", out coachEmail))
						item.CoachEmail = coachEmail;

					string guardianName;
					if (reader.TryGetField<string>("Guardian Name", out guardianName))
						item.GuardianName = guardianName;

					string guardianRelationship;
					if (reader.TryGetField<string>("Guardian Relationship", out guardianRelationship))
						item.GuardianRelationship = guardianRelationship;

					string guardianAddress;
					if (reader.TryGetField<string>("Guardian Address", out guardianAddress))
						item.GuardianAddress = guardianAddress;

					string guardianPhone;
					if (reader.TryGetField<string>("Guardian Phone Number", out guardianPhone))
						item.GuardianPhoneNumber = guardianPhone;

					string guardianEmail;
					if (reader.TryGetField<string>("Guardian Email", out guardianEmail))
						item.GuardianEmail = guardianEmail;

					string guardianPassport;
					if (reader.TryGetField<string>("Guardian Passport", out guardianPassport))
						item.GuardianPassport = guardianPassport;

					string secondaryGuardianName;
					if (reader.TryGetField<string>("Secondary Guardian Name", out secondaryGuardianName))
						item.SecondaryGuardianName = secondaryGuardianName;

					string secondaryGuardianChild;
					if (reader.TryGetField<string>("Secondary Guardian Child", out secondaryGuardianChild))
						item.SecondaryGuardianChild = secondaryGuardianChild;

					string secondaryGuardianRelationship;
					if (reader.TryGetField<string>("Secondary Guardian Relationship", out secondaryGuardianRelationship))
						item.SecondaryGuardianRelationship = secondaryGuardianRelationship;

					string secondaryGuardianAddress;
					if (reader.TryGetField<string>("Secondary Guardian Address", out secondaryGuardianAddress))
						item.SecondaryGuardianAddress = secondaryGuardianAddress;

					string secondaryGuardianPhoneNumber;
					if (reader.TryGetField<string>("Secondary Guardian Phone Number", out secondaryGuardianPhoneNumber))
						item.SecondaryGuardianPhoneNumber = secondaryGuardianPhoneNumber;

					string secondaryGuardianEmail;
					if (reader.TryGetField<string>("Secondary Guardian Email", out secondaryGuardianEmail))
						item.SecondaryGuardianEmail = secondaryGuardianEmail;

					string academicSchool;
					if (reader.TryGetField<string>("Academic School", out academicSchool))
						item.AcademicSchool = academicSchool;

					string academicGPA;
					if (reader.TryGetField<string>("Academic gpa", out academicGPA))
						item.AcademicGPA = academicGPA;

					string academicACT;
					if (reader.TryGetField<string>("Academic act", out academicACT))
						item.AcademicACT = academicACT;

					string academicTOEFL;
					if (reader.TryGetField<string>("Academic toefl", out academicTOEFL))
						item.AcademicTOEFL = academicTOEFL;

					string league;
					if (reader.TryGetField<string>("League", out league))
						item.League = league.Trim();

					string club;
					if (reader.TryGetField<string>("Club", out club))
						item.Club = club.Trim();

					return item;
				}
			}

			return null;
		}

		public ImportModel ProcessCSV(int deployment, string filename, string data)
		{
			using (IDatabaseConnection connection = Globallcoach.Database.CreateConnection(Constants.DeploymentDatabase))
			{
				ImportModel model = new ImportModel();
				string csvHeader = "";

				var parser = new CsvParser(new StringReader(data));

				while (true)
				{
					var row = parser.Read();

					if (row == null)
						break;

					if (parser.Row == 1)
					{
						csvHeader = parser.RawRecord;
					}
					else
					{
						ImportItem item = ParseLine(csvHeader + parser.RawRecord);

						if (item != null)
						{
							IDatabaseQuery query = connection.CreateQuery("INSERT INTO csv_imports (filename, deployment, user_id, header, data, processing, processed) VALUES (@filename, @deployment, @user, @header, @data, false, false)");
							query.AddParameter("filename", filename);
							query.AddParameter("deployment", deployment);
							query.AddParameter("user", UserUtilities.GetAdminId(HttpContext));
							query.AddParameter("header", csvHeader);
							query.AddParameter("data", parser.RawRecord);

							query.RunNonQuery();

							model.Items.Add(item);
						}
					}
				}

				return model;
			}
		}

		[Route("admin/deployment/import/process")]
		[Authorize(Roles = "client_admin,client_headcoach")]
		public async Task<IActionResult> ConfirmImportCurrent()
		{
			return await ConfirmImport(UserUtilities.GetDeploymentId(HttpContext));
		}

		[Route("admin/deployments/{deployment}/import/process")]
		[Authorize(Roles = "sales")]
		public async Task<IActionResult> ConfirmImport(int deployment)
		{
			ProcessDocuments(deployment);

			DocumentModel model = new DocumentModel(deployment, Constants.ParentLcsp);
            model.Populate(UserUtilities.GetApiId(HttpContext));

            return View("~/Views/Admin/Database/Index.cshtml", model);
		}

		[HttpGet("admin/deployment/import/csv")]
		[Authorize(Roles = "client_admin,client_headcoach")]
		public IActionResult PickFileCurrent()
		{
			return PickFile(UserUtilities.GetDeploymentId(HttpContext));
		}

		[HttpGet("admin/deployments/{deployment}/import/csv")]
		[Authorize(Roles = "sales,client_admin,client_headcoach")]
		public IActionResult PickFile(int deployment)
		{
			DocumentModel model = new DocumentModel(deployment, Constants.ParentLcsp);

			return View("~/Views/Admin/Import/PickFile.cshtml", model);
		}

		[Route("admin/deployment/import/list")]
		[Authorize(Roles = "client_admin,client_headcoach")]
		public IActionResult ListCurrent()
		{
			return List(UserUtilities.GetDeploymentId(HttpContext));
		}

		[Route("admin/deployments/{deployment}/import/list")]
		[Authorize(Roles = "sales")]
		public IActionResult List(int deployment)
		{
			CurrentImportsModel model = new CurrentImportsModel();
			model.DeploymentId = deployment;

			using (IDatabaseConnection connection = Globallcoach.Database.CreateConnection(Constants.DeploymentDatabase))
			{
				IDatabaseQuery query = connection.CreateQuery("SELECT data FROM csv_imports WHERE processing = false AND processed = false AND deployment = @deployment AND user_id = @user");
				query.AddParameter("deployment", deployment);
				query.AddParameter("user", UserUtilities.GetAdminId(HttpContext));

				using (IDatabaseQueryResult result = query.RunQuery())
				{
					while (result.Read())
					{
						CurrentImportsItem item = new CurrentImportsItem();
						item.Data = result.GetString(0);
						model.Items.Add(item);
					}
				}
			}

			return View("~/Views/Admin/Import/CurrentImports.cshtml", model);
		}

		[Route("admin/deployment/import/errors")]
		[Authorize(Roles = "client_admin,client_headcoach")]
		public IActionResult ListErrorsCurrent()
		{
			return ListErrors(UserUtilities.GetDeploymentId(HttpContext));
		}

		[Route("admin/deployments/{deployment}/import/errors")]
		[Authorize(Roles = "sales")]
		public IActionResult ListErrors(int deployment)
		{
			// TODO: Filter imports based on a specific import...

			CurrentImportsModel model = new CurrentImportsModel();
			model.DeploymentId = deployment;

			using (IDatabaseConnection connection = Globallcoach.Database.CreateConnection(Constants.DeploymentDatabase))
			{
				IDatabaseQuery query = connection.CreateQuery("SELECT data, error FROM csv_imports WHERE deployment = @deployment AND user_id = @user AND error IS NOT NULL");
				query.AddParameter("deployment", deployment);
				query.AddParameter("user", UserUtilities.GetAdminId(HttpContext));

				using (IDatabaseQueryResult result = query.RunQuery())
				{
					while (result.Read())
					{
						CurrentImportsItem item = new CurrentImportsItem();
						item.DeploymentId = deployment;
						item.Data = result.GetString(0);
						item.Error = result.GetString(1);
						model.Items.Add(item);
					}
				}
			}

			return View("~/Views/Admin/Import/ImportErrors.cshtml", model);
		}

		[Route("admin/deployment/import/errors/export")]
		[Authorize(Roles = "client_admin,client_headcoach")]
		public FileContentResult ExportErrorsCurrent()
		{
			return ExportErrors(UserUtilities.GetDeploymentId(HttpContext));
		}

		[Route("admin/deployments/{deployment}/import/errors/export")]
		[Authorize(Roles = "sales")]
		public FileContentResult ExportErrors(int deployment)
		{
			string csvData = "Player Name,Player Number,Player Picture,Squad,Player dob,Player Nationality,Player Email,Player Phone Number,Player Graduation Year,Player Identification,Player Passport,Coach Name,Coach Address,Coach Phone Number,Coach Email,Guardian Name,Guardian Relationship,Guardian Address,Guardian Phone Number,Guardian Email,Guardian Passport,Secondary Guardian Name,Secondary Guardian Child,Secondary Guardian Relationship,Secondary Guardian Address,Secondary Guardian Phone Number,Secondary Guardian Email,Academic School,Academic gpa,Academic act,Academic toefl,League,Club,Import Error\n";

			using (IDatabaseConnection connection = Globallcoach.Database.CreateConnection(Constants.DeploymentDatabase))
			{
				IDatabaseQuery query = connection.CreateQuery("SELECT data, error FROM csv_imports WHERE deployment = @deployment AND user_id = @user AND error IS NOT NULL");
				query.AddParameter("deployment", deployment);
				query.AddParameter("user", UserUtilities.GetAdminId(HttpContext));

				using (IDatabaseQueryResult result = query.RunQuery())
				{
					while (result.Read())
					{
						csvData += result.GetString(0).Trim() + "," + result.GetString(1) + "\n";
					}
				}
			}

			var file = new FileContentResult(Encoding.UTF8.GetBytes(csvData), "application/csv");
			file.FileDownloadName = "errors.csv";
			return file;
		}

		[Route("admin/deployment/import/errors/clear")]
		[Authorize(Roles = "client_admin,client_headcoach")]
		public IActionResult ClearErrorsCurrent()
		{
			return ClearErrors(UserUtilities.GetDeploymentId(HttpContext), true);
		}

		[Route("admin/deployments/{deployment}/import/errors/clear")]
		[Authorize(Roles = "sales")]
		public IActionResult ClearErrors(int deployment)
		{
			return ClearErrors(deployment, false);
		}

		private IActionResult ClearErrors(int deployment, bool current)
		{
			using (IDatabaseConnection connection = DatabaseUtilities.GetDeploymentConnection())
			{
				IDatabaseQuery query = connection.CreateQuery("DELETE FROM csv_imports WHERE deployment = @deployment AND user_id = @user AND error IS NOT NULL");
				query.AddParameter("deployment", deployment);
				query.AddParameter("user", UserUtilities.GetAdminId(HttpContext));
				query.RunNonQuery();
			}

			return current ? RedirectToAction("ListErrorsCurrent", "AdminImport") : RedirectToAction("ListErrors", "AdminImport", new { deployment = deployment });
		}

		[HttpPost("admin/deployment/import/csv")]
		[Authorize(Roles = "client_admin,client_headcoach")]
		public IActionResult ImportCSVCurrent()
		{
			return ImportCSV(UserUtilities.GetDeploymentId(HttpContext));
		}

		[HttpPost("admin/deployments/{deployment}/import/csv")]
		[Authorize(Roles = "sales")]
		public IActionResult ImportCSV(int deployment)
		{
			ImportModel model = new ImportModel();

			var files = Request.Form.Files;

            foreach (var file in files)
            {
				Stream stream = file.OpenReadStream();
				StreamReader reader = new StreamReader(stream);
				string data = reader.ReadToEnd();

				model = ProcessCSV(deployment, file.Name, data);
			}

			model.DeploymentId = deployment;

			return View("~/Views/Admin/Import/Review.cshtml", model);
		}

		[HttpGet("admin/deployment/import/template")]
		public IActionResult TemplateCurrent()
		{
			return Template(UserUtilities.GetDeploymentId(HttpContext));
		}

		[HttpGet("admin/deployments/{deployment}/import/template")]
		public IActionResult Template(int deployment)
		{
			string csvData = "Player Name,Player Number,Player Picture,Squad,Player dob,Player Nationality,Player Email,Player Phone Number,Player Graduation Year,Player Identification,Player Passport,Coach Name,Coach Address,Coach Phone Number,Coach Email,Guardian Name,Guardian Relationship,Guardian Address,Guardian Phone Number,Guardian Email,Guardian Passport,Secondary Guardian Name,Secondary Guardian Child,Secondary Guardian Relationship,Secondary Guardian Address,Secondary Guardian Phone Number,Secondary Guardian Email,Academic School,Academic gpa,Academic act,Academic toefl,League,Club";

			var file = new FileContentResult(Encoding.UTF8.GetBytes(csvData), "application/csv");
			file.FileDownloadName = "template.csv";
			return file;
		}

		[HttpGet("admin/deployment/export/passwords")]
		[Authorize(Roles = "client_admin,client_headcoach")]
		public IActionResult ExportPasswordsCurrent()
		{
			return ExportPasswords(UserUtilities.GetDeploymentId(HttpContext));
		}

		[HttpGet("admin/deployments/{deployment}/export/passwords")]
		[Authorize(Roles = "sales")]
		public IActionResult ExportPasswords(int deployment)
		{
			string csvData = "";
			using (IDatabaseConnection connection = Database.CreateConnection(Constants.DeploymentDatabase))
			{
				IDatabaseQuery query = connection.CreateQuery("SELECT csv_imports.email, users.generated_password, users.full_name FROM csv_imports INNER JOIN users ON csv_imports.email = users.email WHERE deployment = @deployment AND processing = 0 AND processed = 1 AND error IS NULL ORDER BY users.full_name");
				query.AddParameter("deployment", deployment);
				using (IDatabaseQueryResult result = query.RunQuery())
				{
					while (result.Read())
					{
						csvData += result.GetString(0) + ",";
						csvData += result.GetString(1) + ",";
						csvData += result.GetString(2) + ",";
						csvData += Environment.NewLine;
					}
				}
			}

			var file = new FileContentResult(Encoding.UTF8.GetBytes(csvData), "application/csv");
			file.FileDownloadName = "passwords.csv";
			return file;
		}
	}

}