using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Entity;
using System.Linq;
using System.Threading.Tasks;
using System.Net;
using System.Web;
using System.Web.Mvc;
using HealthchoiceMVC.Models;
using System.Runtime.InteropServices.ComTypes;
using System.Net.NetworkInformation;
using HealthchoiceMVC.NonDbModels;
using HealthchoiceMVC.Services;
using HealthchoiceMVC.ViewModels;
using System.Net.Mail;
using System.Configuration;

namespace HealthchoiceMVC.Controllers
{
    public class PeopleController : Controller
    {
        private HCDBEntities db = new HCDBEntities();
        CommonController common = new CommonController();
        ApplicationUser user = new ApplicationUser();
        HCLocalService service = new HCLocalService();
        private ApplicationDbContext userDb = new ApplicationDbContext();

        // GET: People
        public async Task<ActionResult> Index(string listType)
        {
            var pID = Session["PracticeId"];
            
            List<Person> persons = new List<Person>();
            if(pID == null)
            {
                return View();
            }
            var practiceId = Convert.ToInt32(pID);
            if (listType != null)
            {
                switch (listType)
                {
                    case "practitioner":
                        return RedirectToAction("IndexPractitioner", "People", new { listType = "practitioner" });

                        break;
                    default:
                        break;
                }

            }
            PopulateViewbag();
            return View(persons);
            //return View(await db.Persons.ToListAsync());
        }
        //public async Task<ActionResult> InvitePractitioner(int? Id)
        //{
        //    var pID = Session["PracticeId"];


        //    if (pID == null)
        //    {
        //        return View();
        //    }
        //    PracticeInvite invite = new PracticeInvite();

        //    PopulateViewbag();
        //    return View(invite);
        //    //return View(await db.Persons.ToListAsync());
        //}
        public async Task<ActionResult> InviteSent()
        {
            PopulateViewbag();
            PracticeInvite practiceInvite = new PracticeInvite();
            return View(practiceInvite);
        }
       public async Task<ActionResult> InvitePractitioner(FormCollection formCollection)
       // public async Task<ActionResult> InvitePractitioner([Bind(Include = "PracticeId,InviteName,InviteEmail,SendDate")] PracticeInvite pVM)
        {
            var pID = Session["PracticeId"];
            if (pID == null)
            {
                return HttpNotFound();
            }
            var practiceId = Convert.ToInt32(pID);
            if (formCollection.Count == 0)
            {
                PracticeInvite invite = new PracticeInvite();
                PopulateViewbag();
                return View(invite);
            }
            else
            {
                
                PracticeInvite practiceInvite = new PracticeInvite
                {
                    PracticeId = practiceId,
                    InviteName = formCollection["InviteName"],
                    InviteEmail = formCollection["InviteEmail"],
                    InviteSurname = formCollection["InviteSurname"],
                    DateSent = DateTime.Now,
                    PracticeInviteId = Guid.NewGuid()
                };
                using (var myTransaction = db.Database.BeginTransaction())
                {
                    db.Entry(practiceInvite).State = EntityState.Added;
                    
                    if (SendMailAsync("practiceInvite",practiceInvite.PracticeInviteId.ToString(),practiceInvite.InviteEmail,practiceId.ToString(),practiceInvite.InviteName, practiceInvite.InviteSurname))
                    {
                        await db.SaveChangesAsync();
                        myTransaction.Commit();
                        return RedirectToAction("InviteSent");
                    }
                    else
                    {
                        ModelState.AddModelError("InviteEmail", "Could not send email");
                        PopulateViewbag();
                        return View(practiceInvite);
                    }


                }
            }

        }
        public bool  SendMailAsync(string mailType, string Id,string toAddress,string practiceId,string name, string surname)
        {
            try
            {
                var callbackUrl = Url.Action("RegisterPractitioner", "Account", new { refNo = Id}, protocol: Request.Url.Scheme);
                SmtpClient client = new SmtpClient();
                MailMessage mailMessage = new MailMessage();
                MailAddress mailAddress = new MailAddress("info@healthchoice.co.za");
                mailMessage.From = mailAddress;
                mailMessage.To.Add(toAddress);
                mailMessage.IsBodyHtml = true;
                switch (mailType.ToLower())
                {
                    case "practiceinvite":
                        using (HCDBEntities entities = new HCDBEntities())
                        {
                            int praticeID = Convert.ToInt32(practiceId);
                            var practice = entities.Practices.Where(i => i.PracticeId == praticeID).FirstOrDefault();
                            mailMessage.Subject = practice.PracticeName + " has invited you";
                            string emailBody = "<div style=\"font-family:Arial; font-size:12px;\">";
                            emailBody += "Dear " + name + "&nbsp;" + surname +"<p>";
                            emailBody += "<p>" + practice.PracticeName + " has invited you to register to access their practice</p>";
                            emailBody += string.Format("<p>Please click <a href=\"{0}\">here</a> to register with the practice on Healthchoice.", callbackUrl) + "</p>";
                            emailBody += "<p>Regards,<br /><br />The Healthchoice Team</p>";
                            emailBody += "</div>";
                            mailMessage.Body = emailBody;
                        }
                        
                        break;
                    default:
                        break;
                }
                
                client.Send(mailMessage);
                return true;
            }
            catch (Exception exc)
            {
                return false;

            }

        }
            public async Task<ActionResult> IndexPractitioner(string listType)
        {
            var pID = Session["PracticeId"];

            List<Person> persons = new List<Person>();
            if (pID == null)
            {
                return View();
            }
            
            var practiceId = Convert.ToInt32(pID);
            if (listType != null)
            {
                switch (listType)
                {
                    case "practitioner":
                        //get practice people of this type
                        var practicePersons = await db.PracticePersons.Where(p => p.PracticeId == practiceId && p.ActiveIndic == true).Select(p => p.PersonTypeId).ToListAsync().ConfigureAwait(false);
                        var personTypeId = await db.PersonTypes.Where(i => i.Description == "Practitioner").Select(i => i.PersonTypeId).FirstOrDefaultAsync().ConfigureAwait(false);
                        var r = db.PracticePersons.Where(o => o.PersonTypeId == personTypeId && o.PracticeId == practiceId && o.ActiveIndic == true).Select(o => o.PersonId).FirstOrDefault();
                        //var pl = await db.PersonPersonTypes.Where(o => practicePersons.Contains(o.PersonPersonTypeId) && o.PersonTypeId == personTypeId).Select(o => o.PersonId).ToListAsync().ConfigureAwait(false)
                        persons = await db.Persons.Where(i => db.PracticePersons.Where(o=> o.PersonTypeId == personTypeId && o.PracticeId == practiceId && o.ActiveIndic == true)
                        .Select(o=>o.PersonId).ToList().Contains(i.PersonId))
                            .ToListAsync().ConfigureAwait(false);
                        break;
                    default:
                        break;
                }
                //var people = await db.PracticePersons
                //    .Where(i=> i.ActiveIndic ==true 
                //    &&  i.PersonPersonTypeId == db.PersonPersonTypes.Where(p=> p.PersonTypeId == db.PersonTypes
                //    .Where(l=> l.Description == "Practice Manager")
                //    .Select(l=>l.PersonTypeId).FirstOrDefault()).Select(p=>p.PersonPersonTypeId).ToList())
                //var persons = await db.Persons.Include(i=> i.PersonPersonTypes.Where(j=> j.PersonPersonTypeId == db.PersonTypes == )

            }
            PopulateViewbag();
            return View(persons);
            //return View(await db.Persons.ToListAsync());
        }
        public async Task<ActionResult> IndexPatient(string listType)
        {
            var pID = Session["PracticeId"];

            List<Person> persons = new List<Person>();
            if (pID == null)
            {
                return View();
            }

            var practiceId = Convert.ToInt32(pID);
            if (listType != null)
            {
                switch (listType.ToLower())
                {
                    case "patient":
                        //get practice people of this type
                        var practicePersons = await db.PracticePersons.Where(p => p.PracticeId == practiceId && p.ActiveIndic == true).Select(p => p.PersonTypeId).ToListAsync().ConfigureAwait(false);
                        var personTypeId = await db.PersonTypes.Where(i => i.Description == "Patient").Select(i => i.PersonTypeId).FirstOrDefaultAsync().ConfigureAwait(false);
                        var r = db.PracticePersons.Where(o => o.PersonTypeId == personTypeId && o.PracticeId == practiceId && o.ActiveIndic == true).Select(o => o.PersonId).FirstOrDefault();
                        //var pl = await db.PersonPersonTypes.Where(o => practicePersons.Contains(o.PersonPersonTypeId) && o.PersonTypeId == personTypeId).Select(o => o.PersonId).ToListAsync().ConfigureAwait(false)
                        persons = await db.Persons.Where(i => db.PracticePersons.Where(o => o.PersonTypeId == personTypeId && o.PracticeId == practiceId && o.ActiveIndic == true)
                        .Select(o => o.PersonId).ToList().Contains(i.PersonId))
                            .ToListAsync().ConfigureAwait(false);
                        break;
                    default:
                        break;
                }
                //var people = await db.PracticePersons
                //    .Where(i=> i.ActiveIndic ==true 
                //    &&  i.PersonPersonTypeId == db.PersonPersonTypes.Where(p=> p.PersonTypeId == db.PersonTypes
                //    .Where(l=> l.Description == "Practice Manager")
                //    .Select(l=>l.PersonTypeId).FirstOrDefault()).Select(p=>p.PersonPersonTypeId).ToList())
                //var persons = await db.Persons.Include(i=> i.PersonPersonTypes.Where(j=> j.PersonPersonTypeId == db.PersonTypes == )

            }
            PopulateViewbag();
            return View(persons);
            //return View(await db.Persons.ToListAsync());
        }

        public async Task<ActionResult> IndexAdminPerson(string listType)
        {
            var pID = Session["PracticeId"];

            List<Person> persons = new List<Person>();
            if (pID == null)
            {
                return View();
            }
            var practiceId = Convert.ToInt32(pID);

            //get practice people of this type
            var practicePersons = await db.PracticePersons.Where(p => p.PracticeId == practiceId && p.ActiveIndic == true).Select(p => p.PersonTypeId).ToListAsync().ConfigureAwait(false);
            var personTypeId = await db.PersonTypes.Where(i => i.Description == "Practice Manager" || i.Description == "Practice Admin").Select(i => i.PersonTypeId).ToListAsync().ConfigureAwait(false);
            var r = db.PracticePersons.Where(o => personTypeId.Contains(o.PersonTypeId) && o.PracticeId == practiceId && o.ActiveIndic == true).Select(o => o.PersonId).FirstOrDefault();
            //var pl = await db.PersonPersonTypes.Where(o => practicePersons.Contains(o.PersonPersonTypeId) && o.PersonTypeId == personTypeId).Select(o => o.PersonId).ToListAsync().ConfigureAwait(false)
            persons = await db.Persons.Where(i => db.PracticePersons.Where(o => personTypeId.Contains(o.PersonTypeId) && o.PracticeId == practiceId && o.ActiveIndic == true)
            .Select(o => o.PersonId).ToList().Contains(i.PersonId))
                .ToListAsync().ConfigureAwait(false);

            PopulateViewbag();
            return View(persons);
        }


        // GET: People/Details/5
        public async Task<ActionResult> Details(int? id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            Person person = await db.Persons.FindAsync(id);
            if (person == null)
            {
                return HttpNotFound();
            }
            PopulateViewbag();
            return View(person);
        }

        // GET: People/Create
        public ActionResult Create()
        {
            PopulateViewbag();
            return View();
        }

        // POST: People/Create
        // To protect from overposting attacks, please enable the specific properties you want to bind to, for 
        // more details see https://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<ActionResult> Create([Bind(Include = "PersonId,TitleId,FirstName,MiddleName,LastName,DateofBirth,IDTypeId,Gender,CreatedDate,LinkedLogin,IdentityNumber")] Person person)
        {
            if (ModelState.IsValid)
            {
                db.Persons.Add(person);
                await db.SaveChangesAsync();
                return RedirectToAction("Index");
            }
            PopulateViewbag();
            return View(person);
        }

        // GET: People/Edit/5
        public async Task<ActionResult> Edit(int? id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            Person person = await db.Persons.FindAsync(id);
            if (person == null)
            {
                return HttpNotFound();
            }
            PopulateViewbag();
            return View(person);
        }
        public async Task<ActionResult> EditAdmin(int? id)
        {
            if (id == null)
            {
                Person person = new Person();
                person.CreatedDate = DateTime.Now;
                person.DateofBirth = new DateTime(1900, 1, 1);
                var pID = Session["PracticeId"];
                if (pID == null)
                {
                    return HttpNotFound();
                }
                Admin_vm v = new Admin_vm();
                v.AdminPerson = person;
                v.ContactNumber = "";
                v.Email = "";


                PopulateViewbag();
                return View(v);
            }
            else
            {
                Person person = await db.Persons.FindAsync(id);
                if (person == null)
                {
                    return HttpNotFound();
                }
                var pID = Session["PracticeId"];
                if (pID == null)
                {
                    return HttpNotFound();
                }

                var practiceId = Convert.ToInt32(pID);
                var personTypeId = await db.PersonTypes.Where(i => i.Description == "Practice Manager" || i.Description == "Practice Admin").Select(i => i.PersonTypeId).ToListAsync().ConfigureAwait(false);
                var practicePerson = await db.PracticePersons
                    .Where(i => i.PersonId == person.PersonId && i.PracticeId == practiceId && i.ActiveIndic == true && personTypeId.Contains(i.PersonTypeId))
                    .FirstOrDefaultAsync().ConfigureAwait(false);
                Admin_vm v = new Admin_vm();
                if (practicePerson != null)
                {
                    v.personTypeId = practicePerson.PersonTypeId;
                }

                
                var personContact = await db.PersonContacts.Where(i => i.PersonId == person.PersonId && i.ContactType.Description == "Email" && i.ContactClass.Description == "Work").Select(i => i.ContactValue).FirstOrDefaultAsync().ConfigureAwait(false);
                if (personContact != null)
                {
                    v.Email = personContact;
                }
                else
                {
                    v.Email = "";
                }
                personContact = await db.PersonContacts.Where(i => i.PersonId == person.PersonId && i.ContactType.Description == "CellPhone" && i.ContactClass.Description == "Work").Select(i => i.ContactValue).FirstOrDefaultAsync().ConfigureAwait(false);
                if (personContact != null)
                {
                    v.ContactNumber = personContact;
                }
                else
                {
                    v.ContactNumber = "";
                }
                v.AdminPerson = person;
                PopulateViewbag();
                return View(v);
            }
        }
        public async Task<ActionResult> EditPatient(int? id)
        {
            if (id == null)
            {
                Person person = new Person();
                person.CreatedDate = DateTime.Now;
                person.DateofBirth = new DateTime(1900, 1, 1);
                var pID = Session["PracticeId"];
                if (pID == null)
                {
                    return HttpNotFound();
                }
                var practiceId = Convert.ToInt32(pID);
                var personTypeId = await db.PersonTypes.Where(i => i.Description == "Patient").Select(i => i.PersonTypeId).FirstOrDefaultAsync().ConfigureAwait(false);

                Patient_vm v = new Patient_vm();
                v.Patient = person;
                v.MedicalScheme =0;
                v.SchemeNumber = "";
                v.FileNumber = "";
                //v.Age = 0;
                

                PopulateViewbag();
                return View(v);
            }
            else
            {
                Person person = await db.Persons.FindAsync(id);
                if (person == null)
                {
                    return HttpNotFound();
                }
                var pID = Session["PracticeId"];
                if (pID == null)
                {
                    return HttpNotFound();
                }

                var practiceId = Convert.ToInt32(pID);
                var personTypeId = await db.PersonTypes.Where(i => i.Description == "Patient").Select(i => i.PersonTypeId).FirstOrDefaultAsync().ConfigureAwait(false);

                Patient_vm v = new Patient_vm();
                var personContact = await db.PersonContacts.Where(i => i.PersonId == person.PersonId && i.ContactType.Description == "Email" && i.ContactClass.Description == "Work").Select(i => i.ContactValue).FirstOrDefaultAsync().ConfigureAwait(false);
                if (personContact != null)
                {
                    v.Email = personContact;
                }
                else
                {
                    v.Email = "";
                }
                personContact = await db.PersonContacts.Where(i => i.PersonId == person.PersonId && i.ContactType.Description == "CellPhone" && i.ContactClass.Description == "Work").Select(i => i.ContactValue).FirstOrDefaultAsync().ConfigureAwait(false);
                if (personContact != null)
                {
                    v.ContactNumber = personContact;
                }
                else
                {
                    v.ContactNumber = "";
                }
                v.Patient = person;
                v.MedicalScheme = 0;
                v.SchemeNumber = "";
                v.FileNumber = "";
                //v.Age = 0;
                var personFields = await db.PersonFields.Where(i => i.PersonId == person.PersonId && i.PersonTypeId == personTypeId).ToListAsync().ConfigureAwait(false);
                foreach (PersonField field in personFields)
                {
                    switch (field.FieldType)
                    {
                        case "MedicalScheme":
                            v.MedicalScheme = Convert.ToInt32(field.FieldValue);
                            break;
                        //case "Age":
                        //    v.Age = Convert.ToInt32(field.FieldValue);
                        //    break;
                        case "SchemeNumber":
                            v.SchemeNumber = field.FieldValue;
                            break;
                        case "FileNumber":
                            v.FileNumber = field.FieldValue;
                            break;
                        default:
                            break;
                    }

                }

                var personAddresses = await db.PersonAddresses.Where(i => i.PersonId == person.PersonId).ToListAsync().ConfigureAwait(false);
                foreach (PersonAddress address in personAddresses)
                {
                    switch (address.PersonAddressTypeId)
                    {
                        case 1:
                            v.AddressLineOne = address.AddressLineOne;
                            v.AddressLineTwo = address.AddressLineTwo;
                            v.AreaSuburb = address.AreaSuburb;
                            v.CityTown = address.CityTown;
                            v.PostalCode = address.PostalCode;
                            break;
                        case 2:
                            v.PostalAddressLineOne = address.AddressLineOne;
                            v.PostalAddressLineTwo = address.AddressLineTwo;
                            v.PostalAreaSuburb = address.AreaSuburb;
                            v.PostalCityTown = address.CityTown;
                            v.PostalPostalCode = address.PostalCode;
                            break;
                        default:

                            break;
                    }
                    

                }



                PopulateViewbag();
                return View(v);
            }
        }
        public async Task<ActionResult> EditPractitioner(int? id)
        {
            if (id == null)
            {
                Person person = new Person();
                person.CreatedDate = DateTime.Now;
                person.DateofBirth = new DateTime(1900, 1, 1);
                var pID = Session["PracticeId"];
                if (pID == null)
                {
                    return HttpNotFound();
                }
                var practiceId = Convert.ToInt32(pID);
                var personTypeId = await db.PersonTypes.Where(i => i.Description == "Practitioner").Select(i => i.PersonTypeId).FirstOrDefaultAsync().ConfigureAwait(false);

                Practitioner_vm v = new Practitioner_vm();
                v.Practitioner = person;
                v.prov_discipline_code = 0;
                v.prov_discipline_desc = "";
                v.prov_sub_discipline_desc = "";
                v.prov_sub_discipline_key = 0;
                v.prov_hpcsa_no = "";
                v.practiceId = practiceId;
                PopulateViewbag();
                return View(v);
            }
            else
            {
                Person person = await db.Persons.FindAsync(id);
                if (person == null)
                {
                    return HttpNotFound();
                }
                var pID = Session["PracticeId"];
                if (pID == null)
                {
                    return HttpNotFound();
                }
                
                var practiceId = Convert.ToInt32(pID);
                var personTypeId = await db.PersonTypes.Where(i => i.Description == "Practitioner").Select(i => i.PersonTypeId).FirstOrDefaultAsync().ConfigureAwait(false);
                
                Practitioner_vm v = new Practitioner_vm();
                var personContact = await db.PersonContacts.Where(i => i.PersonId == person.PersonId && i.ContactType.Description == "Email" && i.ContactClass.Description == "Work").Select(i => i.ContactValue).FirstOrDefaultAsync().ConfigureAwait(false);
                if (personContact != null)
                {
                    v.Email = personContact;
                }
                else
                {
                    v.Email = "";
                }
                personContact = await db.PersonContacts.Where(i => i.PersonId == person.PersonId && i.ContactType.Description == "CellPhone" && i.ContactClass.Description == "Work").Select(i => i.ContactValue).FirstOrDefaultAsync().ConfigureAwait(false);
                if (personContact != null)
                {
                    v.ContactNumber = personContact;
                }
                else
                {
                    v.ContactNumber = "";
                }
                v.practiceId = practiceId;
                v.Practitioner = person;
                v.prov_discipline_code = 0;
                v.prov_discipline_desc = "";
                v.prov_sub_discipline_desc = "";
                v.prov_sub_discipline_key = 0;
                v.prov_hpcsa_no = "";
                var personFields = await db.PersonFields.Where(i => i.PersonId == person.PersonId && i.PersonTypeId == personTypeId).ToListAsync().ConfigureAwait(false);
                foreach (PersonField field in personFields)
                {
                    switch (field.FieldType)
                    {
                        case "prov_discipline_code":
                            v.prov_discipline_code = Convert.ToInt32(field.FieldValue);
                            break;  
                        case "prov_sub_discipline_key":
                            v.prov_sub_discipline_key = Convert.ToInt32(field.FieldValue);
                            break;
                        case "prov_hpcsa_no":
                            v.prov_hpcsa_no = field.FieldValue;
                            break;
                        default:
                            break;
                    }

                }

                

                PopulateViewbag();
                return View(v);
            }
        }
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<ActionResult> EditPatient(FormCollection formCollection)
        //public async Task<ActionResult> EditPractitioner([Bind(Include = "Practitioner.PersonId,Practitioner.TitleId,Practitioner.FirstName,Practitioner.MiddleName," +
        //    "Practitioner.LastName,Practitioner.DateofBirth,Practitioner.IDTypeId,Practitioner.Gender,Practitioner.LinkedLogin,Practitioner.CreatedDate,Practitioner.IdentityNumber")] Practitioner_vm pVM)
        {
            var pID = Session["PracticeId"];
            if (pID == null)
            {
                return HttpNotFound();
            }
            var practiceId = Convert.ToInt32(pID);
            Patient_vm v = new Patient_vm();
            Person p = new Person
            {
                PersonId = Convert.ToInt32(formCollection["Patient.PersonId"]),
                TitleId = Convert.ToInt32(formCollection["Patient.TitleId"]),
                FirstName = formCollection["Patient.FirstName"],
                MiddleName = formCollection["Patient.MiddleName"],
                LastName = formCollection["Patient.LastName"],
                Gender = formCollection["Patient.Gender"],
                IdentityNumber = formCollection["Patient.IdentityNumber"],
                IDTypeId = Convert.ToInt32(formCollection["Patient.IDTypeId"]),
                LinkedLogin = formCollection["Patient.LinkedLogin"],
                DateofBirth = Convert.ToDateTime(formCollection["Patient.DateofBirth"]),
                CreatedDate = Convert.ToDateTime(formCollection["Patient.CreatedDate"])
            };
         
            v.ContactNumber = formCollection["ContactNumber"];
            v.MedicalScheme = Convert.ToInt32(formCollection["MedicalScheme"]);
            //v.Age = Convert.ToInt32(formCollection["Age"]);
            v.SchemeNumber = formCollection["SchemeNumber"];
            v.FileNumber = formCollection["FileNumber"];
            v.Email = formCollection["Email"];
            v.Patient = p;

            if (v.Patient.IDTypeId.ToString().Equals("1") && v.Patient.IdentityNumber.Length != 13)
            {
                ModelState.AddModelError(String.Empty, "Your South African ID Number should be 13 digits.");
            }
            if (p.PersonId == 0)
            {

                //now we check if patient exists
                var personContacts = await db.PersonContacts.Where(c => c.ContactTypeId == 1 & c.ContactValue == v.Email).ToListAsync().ConfigureAwait(false);
                if (personContacts.Count != 0)
                {
                    ModelState.AddModelError(String.Empty, "Patient with this email address already exists ");
                }
                var practitioner = await db.Persons.Where(c => c.IdentityNumber.Trim() == p.IdentityNumber.Trim()).FirstOrDefaultAsync().ConfigureAwait(false);
                if (practitioner != null)
                {
                    ModelState.AddModelError(String.Empty, "Patient with that ID already exists.");
                }

                if (ModelState.IsValid)
                {
                    using (var myTransaction = db.Database.BeginTransaction())
                    {
                        db.Entry(p).State = EntityState.Added;
                        await db.SaveChangesAsync();

                        var practicePerson = new PracticePerson
                        {
                            PersonId = p.PersonId,
                            PracticeId = practiceId,
                            PersonTypeId = await db.PersonTypes.Where(i => i.Description == "Patient").Select(i => i.PersonTypeId).FirstOrDefaultAsync().ConfigureAwait(false),
                            ActiveIndic = true
                        };
                        db.PracticePersons.Add(practicePerson);
                        await db.SaveChangesAsync();
                        //add contact details
                        //email
                        var personContact = new PersonContact
                        {
                            PersonId = p.PersonId,
                            ContactTypeId = await db.ContactTypes.Where(i => i.Description == "email").Select(i => i.ContactTypeId).FirstOrDefaultAsync().ConfigureAwait(false),
                            ContactClassId = await db.ContactClasses.Where(i => i.Description == "work").Select(i => i.ContactClassId).FirstOrDefaultAsync().ConfigureAwait(false),
                            AlternativeClass = "",
                            ContactValue = v.Email,
                            IsValidated = false
                        };
                        db.PersonContacts.Add(personContact);
                        await db.SaveChangesAsync();
                        //phone
                        personContact = new PersonContact
                        {
                            PersonId = p.PersonId,
                            ContactTypeId = await db.ContactTypes.Where(i => i.Description == "cellphone").Select(i => i.ContactTypeId).FirstOrDefaultAsync().ConfigureAwait(false),
                            ContactClassId = await db.ContactClasses.Where(i => i.Description == "work").Select(i => i.ContactClassId).FirstOrDefaultAsync().ConfigureAwait(false),
                            AlternativeClass = "",
                            ContactValue = v.ContactNumber,
                            IsValidated = false
                        };
                        db.PersonContacts.Add(personContact);
                        await db.SaveChangesAsync();
                        //add discipline
                        //PersonField personField = new PersonField
                        //{
                        //    PersonTypeId = await db.PersonTypes.Where(i => i.Description == "Patient").Select(i => i.PersonTypeId).FirstOrDefaultAsync().ConfigureAwait(false),
                        //    PersonId = p.PersonId,
                        //    FieldType = "MedicalScheme",
                        //    FieldValue = v.MedicalScheme.ToString()
                        //};
                        //db.PersonFields.Add(personField);
                        //await db.SaveChangesAsync();
                        //add sub discipline
                        PersonField personField4 = new PersonField
                        {
                            PersonTypeId = await db.PersonTypes.Where(i => i.Description == "Patient").Select(i => i.PersonTypeId).FirstOrDefaultAsync().ConfigureAwait(false),
                            PersonId = p.PersonId,
                            FieldType = "FileNumber",
                            FieldValue = v.FileNumber.ToString()
                        };
                        db.PersonFields.Add(personField4);
                        await db.SaveChangesAsync();
                        //PersonField personField2 = new PersonField
                        //{
                        //    PersonTypeId = await db.PersonTypes.Where(i => i.Description == "Patient").Select(i => i.PersonTypeId).FirstOrDefaultAsync().ConfigureAwait(false),
                        //    PersonId = p.PersonId,
                        //    FieldType = "SchemeNumber",
                        //    FieldValue = v.SchemeNumber.ToString()
                        //};
                        //db.PersonFields.Add(personField2);
                        //await db.SaveChangesAsync();
                        //add hpcsa
                        //PersonField personField5 = new PersonField
                        //{
                        //    PersonTypeId = await db.PersonTypes.Where(i => i.Description == "Patient").Select(i => i.PersonTypeId).FirstOrDefaultAsync().ConfigureAwait(false),
                        //    PersonId = p.PersonId,
                        //    FieldType = "Age",
                        //    FieldValue = v.Age.ToString()
                        //};
                        //db.PersonFields.Add(personField5);
                        //await db.SaveChangesAsync();
                        //add address
                        PersonAddress personAddress = new PersonAddress
                        {
                            //street
                            PersonAddressTypeId = 1,
                            PersonId = p.PersonId,
                            AddressLineOne = formCollection["AddressLineOne"],
                            AddressLineTwo = formCollection["AddressLineTwo"],
                            AreaSuburb = formCollection["AreaSuburb"],
                            CityTown = formCollection["CityTown"],
                            PostalCode = formCollection["PostalCode"],
                            ActiveIndic = 1
                        };
                        db.PersonAddresses.Add(personAddress);
                        //add postal
                        PersonAddress postalAddress = new PersonAddress
                        {
                            //street
                            PersonAddressTypeId = 2,
                            PersonId = p.PersonId,
                            AddressLineOne = formCollection["PostalAddressLineOne"],
                            AddressLineTwo = formCollection["PostalAddressLineTwo"],
                            AreaSuburb = formCollection["PostalAreaSuburb"],
                            CityTown = formCollection["PostalCityTown"],
                            PostalCode = formCollection["PostalPostalCode"],
                            ActiveIndic = 1
                        };
                        db.PersonAddresses.Add(postalAddress);
                        await db.SaveChangesAsync();


                        myTransaction.Commit();

                        return RedirectToAction("IndexPatient", new { listType = "patient" });
                    }
                }
                else
                {
                    PopulateViewbag();
                    return View(v);
                }


            }
            else
            {
                ////get email and update
                //var personContacts = await db.PersonContacts.Where(c => c.ContactTypeId == 1 & c.PersonId == v.Patient.PersonId).ToListAsync().ConfigureAwait(false);
                //if(personContacts == null)
                //{
                //    var personC = new PersonContacthen
                //    {
                //        PersonId = p.PersonId,
                //        ContactTypeId = await db.ContactTypes.Where(i => i.Description == "email").Select(i => i.ContactTypeId).FirstOrDefaultAsync().ConfigureAwait(false),
                //        ContactClassId = await db.ContactClasses.Where(i => i.Description == "work").Select(i => i.ContactClassId).FirstOrDefaultAsync().ConfigureAwait(false),
                //        AlternativeClass = "",
                //        ContactValue = v.Email,
                //        IsValidated = false
                //    };
                //    db.PersonContacts.Add(personC);
                //    await db.SaveChangesAsync();
                //}
                //else
                //{
                //    personContacts. = v.Email;
                //    await db.SaveChangesAsync();
                //}


            }
            v.Patient = p;

            //var m = formCollection["Practitioner.PersonId"];
            if (ModelState.IsValid)
            {
                //fix date if wrong.
                db.Entry(p).State = EntityState.Modified;
                await db.SaveChangesAsync();
                return RedirectToAction("IndexPatient", new { listType = "patient" });
            }
            PopulateViewbag();
            return View(v);
        }

        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<ActionResult> EditPractitioner(FormCollection formCollection)
       //public async Task<ActionResult> EditPractitioner([Bind(Include = "Practitioner.PersonId,Practitioner.TitleId,Practitioner.FirstName,Practitioner.MiddleName," +
       //    "Practitioner.LastName,Practitioner.DateofBirth,Practitioner.IDTypeId,Practitioner.Gender,Practitioner.LinkedLogin,Practitioner.CreatedDate,Practitioner.IdentityNumber")] Practitioner_vm pVM)
        {
            var pID = Session["PracticeId"];
            if (pID == null)
            {
                return HttpNotFound();
            }
            var practiceId = Convert.ToInt32(pID);
            Practitioner_vm v = new Practitioner_vm();
            Person p = new Person
            {
                PersonId = Convert.ToInt32(formCollection["Practitioner.PersonId"]),
                TitleId = Convert.ToInt32(formCollection["Practitioner.TitleId"]),
                FirstName = formCollection["Practitioner.FirstName"],
                MiddleName = formCollection["Practitioner.MiddleName"],
                LastName = formCollection["Practitioner.LastName"],
                Gender = formCollection["Practitioner.Gender"],
                IdentityNumber = formCollection["Practitioner.IdentityNumber"],
                IDTypeId = Convert.ToInt32(formCollection["Practitioner.IDTypeId"]),
                LinkedLogin = formCollection["Practitioner.LinkedLogin"],
                DateofBirth = Convert.ToDateTime(formCollection["Practitioner.DateofBirth"]),
                CreatedDate = Convert.ToDateTime(formCollection["Practitioner.CreatedDate"])
            };
            v.practiceId = Convert.ToInt32(formCollection["practiceId"]);
            v.ContactNumber = formCollection["ContactNumber"];
            v.prov_discipline_code = Convert.ToInt32(formCollection["prov_discipline_code"]);
            v.prov_sub_discipline_key = Convert.ToInt32(formCollection["prov_sub_discipline_key"]);
            v.prov_hpcsa_no = formCollection["prov_hpcsa_no"];
          
            v.Email = formCollection["Email"];
            v.Practitioner = p;

            if (v.Practitioner.IDTypeId.ToString().Equals("1") && v.Practitioner.IdentityNumber.Length != 13)
            {
                ModelState.AddModelError(String.Empty, "Your South African ID Number should be 13 digits.");
            }
            if (p.PersonId == 0)
            {
                
                //now we check if patient exists
                var personContacts = await db.PersonContacts.Where(c => c.ContactTypeId == 1 & c.ContactValue == v.Email).ToListAsync().ConfigureAwait(false);
                    if (personContacts.Count != 0)
                    {
                    ModelState.AddModelError(String.Empty, "Practitioner with this email address already exists ");
                    }
                    var practitioner = await db.Persons.Where(c => c.IdentityNumber.Trim() == p.IdentityNumber.Trim()).FirstOrDefaultAsync().ConfigureAwait(false);
                    if (practitioner != null)
                    {
                    ModelState.AddModelError(String.Empty, "Practitioner with that ID already exists.");
                    }
              
                if (ModelState.IsValid)
                {
                    using (var myTransaction =db.Database.BeginTransaction())
                    {
                        db.Entry(p).State = EntityState.Added;
                        await db.SaveChangesAsync();

                        var practicePerson = new PracticePerson
                        {
                            PersonId = p.PersonId,
                            PracticeId = practiceId,
                            PersonTypeId = await db.PersonTypes.Where(i => i.Description == "Practitioner").Select(i => i.PersonTypeId).FirstOrDefaultAsync().ConfigureAwait(false),
                            ActiveIndic = true
                        };
                        db.PracticePersons.Add(practicePerson);
                        await db.SaveChangesAsync();
                        //add contact details
                        //email
                        var personContact = new PersonContact
                        {
                            PersonId = p.PersonId,
                            ContactTypeId = await db.ContactTypes.Where(i => i.Description == "email").Select(i => i.ContactTypeId).FirstOrDefaultAsync().ConfigureAwait(false),
                            ContactClassId = await db.ContactClasses.Where(i => i.Description == "work").Select(i => i.ContactClassId).FirstOrDefaultAsync().ConfigureAwait(false),
                            AlternativeClass = "",
                            ContactValue = v.Email,
                            IsValidated = false
                        };
                        db.PersonContacts.Add(personContact);
                        await db.SaveChangesAsync();
                        //phone
                        personContact = new PersonContact
                        {
                            PersonId = p.PersonId,
                            ContactTypeId = await db.ContactTypes.Where(i => i.Description == "cellphone").Select(i => i.ContactTypeId).FirstOrDefaultAsync().ConfigureAwait(false),
                            ContactClassId = await db.ContactClasses.Where(i => i.Description == "work").Select(i => i.ContactClassId).FirstOrDefaultAsync().ConfigureAwait(false),
                            AlternativeClass = "",
                            ContactValue = v.ContactNumber,
                            IsValidated = false
                        };
                        db.PersonContacts.Add(personContact);
                        await db.SaveChangesAsync();
                        //add discipline
                        PersonField personField = new PersonField
                        {
                            PersonTypeId = await db.PersonTypes.Where(i => i.Description == "Practitioner").Select(i => i.PersonTypeId).FirstOrDefaultAsync().ConfigureAwait(false),
                            PersonId = p.PersonId,
                            FieldType = "prov_discipline_code",
                            FieldValue = v.prov_discipline_code.ToString()
                        };
                        db.PersonFields.Add(personField);
                        await db.SaveChangesAsync();
                        //add sub discipline
                        PersonField personField4 = new PersonField
                        {
                            PersonTypeId = await db.PersonTypes.Where(i => i.Description == "Practitioner").Select(i => i.PersonTypeId).FirstOrDefaultAsync().ConfigureAwait(false),
                            PersonId = p.PersonId,
                            FieldType = "prov_sub_discipline_key",
                            FieldValue = v.prov_sub_discipline_key.ToString()
                        };
                        db.PersonFields.Add(personField4);
                        await db.SaveChangesAsync();
                        PersonField personField2 = new PersonField
                        {
                            PersonTypeId = await db.PersonTypes.Where(i => i.Description == "Practitioner").Select(i => i.PersonTypeId).FirstOrDefaultAsync().ConfigureAwait(false),
                            PersonId = p.PersonId,
                            FieldType = "prov_hpcsa_no",
                            FieldValue = v.prov_hpcsa_no.ToString()
                        };
                        db.PersonFields.Add(personField2);
                        await db.SaveChangesAsync();
                        myTransaction.Commit();
                        return RedirectToAction("IndexPractitioner", new { listType = "practitioner" });
                    }
                }
                else
                {
                    PopulateViewbag();
                    return View(v);
                }
               

            }
            v.Practitioner = p;

            //var m = formCollection["Practitioner.PersonId"];
            if (ModelState.IsValid)
            {
                //fix date if wrong.
                db.Entry(p).State = EntityState.Modified;
                await db.SaveChangesAsync();
                return RedirectToAction("IndexPractitioner", new { listType = "practitioner" });
            }
            PopulateViewbag();
            return View(v);
        }
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<ActionResult> EditAdmin(FormCollection formCollection)
        //public async Task<ActionResult> EditPractitioner([Bind(Include = "Practitioner.PersonId,Practitioner.TitleId,Practitioner.FirstName,Practitioner.MiddleName," +
        //    "Practitioner.LastName,Practitioner.DateofBirth,Practitioner.IDTypeId,Practitioner.Gender,Practitioner.LinkedLogin,Practitioner.CreatedDate,Practitioner.IdentityNumber")] Practitioner_vm pVM)
        {
            var pID = Session["PracticeId"];
            if (pID == null)
            {
                return HttpNotFound();
            }
            var practiceId = Convert.ToInt32(pID);
            Admin_vm v = new Admin_vm();
            Person p = new Person
            {
                PersonId = Convert.ToInt32(formCollection["AdminPerson.PersonId"]),
                TitleId = Convert.ToInt32(formCollection["AdminPerson.TitleId"]),
                FirstName = formCollection["AdminPerson.FirstName"],
                MiddleName = formCollection["AdminPerson.MiddleName"],
                LastName = formCollection["AdminPerson.LastName"],
                Gender = formCollection["AdminPerson.Gender"],
                IdentityNumber = formCollection["AdminPerson.IdentityNumber"],
                IDTypeId = Convert.ToInt32(formCollection["AdminPerson.IDTypeId"]),
                LinkedLogin = formCollection["AdminPerson.LinkedLogin"],
                DateofBirth = Convert.ToDateTime(formCollection["AdminPerson.DateofBirth"]),
                CreatedDate = Convert.ToDateTime(formCollection["AdminPerson.CreatedDate"])
            };
           
            v.personTypeId = Convert.ToInt32(formCollection["personTypeId"]);
            v.ContactNumber = formCollection["ContactNumber"];
            v.Email = formCollection["Email"];
            v.AdminPerson = p;

            if (v.AdminPerson.IDTypeId.ToString().Equals("1") && v.AdminPerson.IdentityNumber.Length != 13)
            {
                ModelState.AddModelError(String.Empty, "Your South African ID Number should be 13 digits.");
            }
            if (p.PersonId == 0)
            {

                //now we check if patient exists
                var personContacts = await db.PersonContacts.Where(c => c.ContactTypeId == 1 & c.ContactValue == v.Email).ToListAsync().ConfigureAwait(false);
                if (personContacts.Count != 0)
                {
                    ModelState.AddModelError(String.Empty, "Admin / Manager with this email address already exists ");
                }
                var practitioner = await db.Persons.Where(c => c.IdentityNumber.Trim() == p.IdentityNumber.Trim()).FirstOrDefaultAsync().ConfigureAwait(false);
                if (practitioner != null)
                {
                    ModelState.AddModelError(String.Empty, "Admin / Manager with that ID already exists.");
                }

                if (ModelState.IsValid)
                {
                    using (var myTransaction = db.Database.BeginTransaction())
                    {
                        db.Entry(p).State = EntityState.Added;
                        await db.SaveChangesAsync();

                        var practicePerson = new PracticePerson
                        {
                            PersonId = p.PersonId,
                            PracticeId = practiceId,
                            PersonTypeId = v.personTypeId,
                            ActiveIndic = true
                        };
                        db.PracticePersons.Add(practicePerson);
                        await db.SaveChangesAsync();
                        //add contact details
                        //email
                        var personContact = new PersonContact
                        {
                            PersonId = p.PersonId,
                            ContactTypeId = await db.ContactTypes.Where(i => i.Description == "email").Select(i => i.ContactTypeId).FirstOrDefaultAsync().ConfigureAwait(false),
                            ContactClassId = await db.ContactClasses.Where(i => i.Description == "work").Select(i => i.ContactClassId).FirstOrDefaultAsync().ConfigureAwait(false),
                            AlternativeClass = "",
                            ContactValue = v.Email,
                            IsValidated = false
                        };
                        db.PersonContacts.Add(personContact);
                        await db.SaveChangesAsync();
                        //phone
                        personContact = new PersonContact
                        {
                            PersonId = p.PersonId,
                            ContactTypeId = await db.ContactTypes.Where(i => i.Description == "cellphone").Select(i => i.ContactTypeId).FirstOrDefaultAsync().ConfigureAwait(false),
                            ContactClassId = await db.ContactClasses.Where(i => i.Description == "work").Select(i => i.ContactClassId).FirstOrDefaultAsync().ConfigureAwait(false),
                            AlternativeClass = "",
                            ContactValue = v.ContactNumber,
                            IsValidated = false
                        };
                        db.PersonContacts.Add(personContact);
                        await db.SaveChangesAsync();
                        
                        myTransaction.Commit();
                        return RedirectToAction("IndexAdminPerson", new { listType = "Admin" });
                    }
                }
                else
                {
                    PopulateViewbag();
                    return View(v);
                }


            }
            v.AdminPerson = p;

            //var m = formCollection["Practitioner.PersonId"];
            if (ModelState.IsValid)
            {
                //fix date if wrong.
                db.Entry(p).State = EntityState.Modified;
                await db.SaveChangesAsync();
                return RedirectToAction("IndexAdminPerson", new { listType = "Admin" });
            }
            PopulateViewbag();
            return View(v);
        }
        // POST: People/Edit/5
        // To protect from overposting attacks, please enable the specific properties you want to bind to, for 
        // more details see https://go.microsoft.com/fwlink/?LinkId=317598.
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<ActionResult> Edit([Bind(Include = "PersonId,TitleId,FirstName,MiddleName,LastName,DateofBirth,IDTypeId,Gender,CreatedDate,LinkedLogin,IdentityNumber")] Person person)
        {
            if (ModelState.IsValid)
            {
                //fix date if wrong.
         
                db.Entry(person).State = EntityState.Modified;
                await db.SaveChangesAsync();
                return RedirectToAction("Index", new { listType = "practitioner" });
            }
            PopulateViewbag();
            return View(person);
        }

        // GET: People/Delete/5
        public async Task<ActionResult> Delete(int? id)
        {
            if (id == null)
            {
                return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
            }
            Person person = await db.Persons.FindAsync(id);
            if (person == null)
            {
                return HttpNotFound();
            }
            return View(person);
        }

        // POST: People/Delete/5
        [HttpPost, ActionName("Delete")]
        [ValidateAntiForgeryToken]
        public async Task<ActionResult> DeleteConfirmed(int id)
        {
            Person person = await db.Persons.FindAsync(id);
            db.Persons.Remove(person);
            await db.SaveChangesAsync();
            return RedirectToAction("Index");
        }
        private void PopulateViewbag()
        {
            //ViewBag.CountryList = service.GetListOfCountries();
            //ViewBag.CountryListAll = service.GetListOfCountriesAll();
            ViewBag.GenderList = service.GetLookUpDropDown("gender");
            ViewBag.TitleList = service.GetLookUpDropDown("titleid");
            ViewBag.IdType = service.GetLookUpDropDown("id_no_type").Where(i=> i.Text == "South African ID");
            ViewBag.SchemeList = service.GetLookUpDropDown("medschemes");
            //ViewBag.PDIStatus = service.GetLookUpDropDown("PDI");
            var personTypes = db.PersonTypes.Where(i => i.Description == "Practice Manager" || i.Description == "Practice Admin").ToList();
            List<SelectListItem> LookUpList = new List<SelectListItem>();
            LookUpList.Add(new SelectListItem { Text = "-Please select-", Value = "" });
            foreach (PersonType pt in personTypes)
            {
                LookUpList.Add(new SelectListItem { Text = pt.Description, Value = pt.PersonTypeId.ToString() });
            }
            ViewBag.AdminTypeList = LookUpList;
            ViewBag.Disciplines = service.GetDisciplines();
           // List<SelectListItem> SubDisciplines = new List<SelectListItem>();
           // SubDisciplines.Add(new SelectListItem { Text = "-Select discipline first-", Value = "" });
            ViewBag.SubDisciplines = service.GetSubDisciplinesByDisciplineCode(72); 
            //ViewBag.ProvSpecialityTypeList = service.GetLookUpDropDown("provider_speciality_type");
            //service.GetSubDisciplinesByDisciplineCode();
           // var SubDisciplineKeys = new string[] { "", "18" };
            //ViewBag.SubDisciplineList = service.GetSubDisciplinesByDisciplineCode(72); //JQuery needs to be added.
        }
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                db.Dispose();
            }
            base.Dispose(disposing);
        }
    }
}