using System;
using System.Text;
using System.Data;
using System.Linq;
using System.Web.Mvc;
using System.Data.Entity.Validation;
using System.Collections.Generic;
using Neo.Afx.Mvc;
using Neo.Afx.ViewModels;
using Neo.Afx.ComponentModel;
using Neo.Afx.Services.Integration;
using Neo.Afx.Services.Workflows;
using Neo.Afx.Services.Workflows.Entities;
using Neo.Afx.Services.Forms.Entities;
using Neo.LegitimateLicences.Common;
using Neo.LegitimateLicences.Data.Models;
using Neo.LegitimateLicences.ApplicationRequest.Models;
using Neo.LegitimateLicences.Data;
using Neo.Afx.Services.Audits;
using Neo.LegitimateLicences.Common.Helpers;
using Neo.LegitimateLicences.ApplicationRequest.Models.Database;
using Neo.Afx.Common;

namespace Neo.LegitimateLicences.ApplicationRequest
{
    public partial class ApplicationRequestController 
    {
        
        #region SaveInspection
        [HttpPost]
        public JsonNetResult SaveInspection(ApplicationDetail value)
        {
            var changes = new List<string>();
            var auditDb = new AuditsDatabase();
          
            try
            {

                #region Check if can save
                var model = GetModel();

                if (!model.CanEditInspectionDetails)
                {
                    throw new Exception("Security error");
                }
                #endregion

                var projDb = new ApplicationDatabase(); //don't use database context as we need the values refreshed every time
                    var existingModel = projDb.GetApplicationInspectionDetails(value.ApplicationDetailID, Profile.UserID);
                    ////if (existingModel != null && existingModel.UpdatedDate.ToLongTimeString() != value.UpdatedDate.ToLongTimeString())
                    ////{
                    ////    return new JsonNetResult()
                    ////    {
                    ////        Data = new JsonBaseResult()
                    ////        {
                    ////            Success = false,
                    ////            ErrorCode = "CONFLICT",
                    ////            Error ="The record has been modified by someone else. Please try again."
                    ////        }
                    ////    };
                    ////}

                    #region Check if user is allowed to edit the record at this stage
                    ////try
                    ////{
                    ////    projDb.CheckSecurity(value.ApplicationRequestDetailID, "Save", Profile.UserID);
                    ////}
                    ////catch (Exception ex)
                    ////{
                    ////    return Json(new
                    ////    {
                    ////        Result = "ERROR",
                    ////        Message = new LegitimateDatabase().GetInnermostMessage(ex)
                    ////    });
                    ////}
                    #endregion

                    value.UpdatedDate = DateTime.Now;
                    value.UpdatedByID = Profile.UserID;

                    //Do not update value.ApplicationRequestAdjudicationDecisions or value.Objections
                    ////value.ApplicationRequestAdjudicationDecisions = null;
                    ////value.Objections = null;

                    ////#region value.Documents
                    ////foreach (var document in value.Documents)
                    ////{
                    ////    Database.Update(document);

                    ////    var existingDocument = existingModel.Documents.Where(a => a.ApplicationDocumentID == document.ApplicationDocumentID).FirstOrDefault();
                    ////    if (existingDocument != null)
                    ////    {
                    ////        changes.AddRange(auditDb.GetEntityDifferences<ApplicationDocument>(existingDocument, document, "ApplicationDocumentID"));
                    ////    }
                    ////}
                    ////#endregion

                    ////#region value.Services
                    ////foreach (var service in value.Services)
                    ////{
                    ////    if (service.ApplicationServiceDetailID > 0)
                    ////    {
                    ////        Database.Update(service);

                    ////        var exstingService = existingModel.Services.Where(a => a.ApplicationServiceDetailID == service.ApplicationServiceDetailID).FirstOrDefault();
                    ////        changes.AddRange(auditDb.GetEntityDifferences<ApplicationServiceDetail>(exstingService, service, "ApplicationServiceDetailID"));

                    ////    }
                    ////    else
                    ////    {
                    ////        Database.Insert(service);
                    ////        var blankObj = new ApplicationServiceDetail();

                    ////        changes.Add(string.Format("{0}, Added service type {1}", "ApplicationServiceDetails", service.ServiceTypeID));

                    ////        changes.AddRange(auditDb.GetEntityDifferences<ApplicationServiceDetail>(blankObj, service, "ApplicationServiceDetailID"));
                    ////    }
                    ////}

                    ////if (value.RemovedServices != null)
                    ////{
                    ////    foreach (var removedService in value.RemovedServices)
                    ////    {
                    ////        changes.Add(string.Format("{0}, Removed service type {1}", "ApplicationServiceDetails", removedService.ServiceTypeID));

                    ////        var exstingService = existingModel.Services.Where(a => a.ApplicationServiceDetailID == removedService.ApplicationServiceDetailID).FirstOrDefault();
                    ////        changes.AddRange(auditDb.GetEntityDifferences<ApplicationServiceDetail>(exstingService, removedService, "ApplicationServiceDetailID"));

                    ////        Database.Context.Entry(removedService).State = System.Data.Entity.EntityState.Deleted;                            
                    ////    }
                    ////}
                    ////#endregion

                    ////#region value.Vehicles

                    ////if (value.Vehicle.ApplicationRequestDetailID > 0)
                    ////{
                    ////    Database.Update(value.Vehicle);
                    ////    changes.AddRange(auditDb.GetEntityDifferences<ApplicationVehicleDetail>(existingModel.Vehicle, value.Vehicle, "ApplicationRequestDetailID"));
                    ////}
                    ////else
                    ////{
                    ////    Database.Insert(value.Vehicle);
                    ////    var vin = (!string.IsNullOrEmpty(value.Vehicle.VIN)) ? value.Vehicle.VIN : "nothing";
                    ////    changes.Add(string.Format("{0}, Added vehicle with VIN {1}", "ApplicationVehicleDetail", vin));
                    ////}                    
                    ////#endregion

                    ////#region value.Routes
                    ////foreach (var route in value.Routes)
                    ////{
                    ////    if (route.ApplicationRouteDetailID > 0)
                    ////    {
                    ////        Database.Update(route);

                    ////        var exstingRoute = existingModel.Routes.Where(a => a.ApplicationRouteDetailID == route.ApplicationRouteDetailID).FirstOrDefault();
                    ////        changes.AddRange(auditDb.GetEntityDifferences<ApplicationRouteDetail>(exstingRoute, route, "ApplicationRouteDetailID"));

                    ////    }
                    ////    else
                    ////    {
                    ////        Database.Insert(route);
                    ////        var blankObj = new ApplicationRouteDetail();


                    ////        changes.Add(string.Format("{0}, Added route {1}, {2}, {3}, {4}", "ApplicationRouteDetails", route.RouteOrigin, route.RouteDestination, route.NationalRouteNumber, route.BoardRouteNumber));
                    ////        changes.AddRange(auditDb.GetEntityDifferences<ApplicationRouteDetail>(blankObj, route, "ApplicationRouteDetailID"));

                    ////    }
                    ////}

                    ////if (value.RemovedRoutes != null)
                    ////{
                    ////    foreach (var removedRoute in value.RemovedRoutes)
                    ////    {
                    ////        changes.Add(string.Format("{0}, Removed route {1}, {2}, {3}, {4}", "ApplicationRouteDetails", removedRoute.RouteOrigin, removedRoute.RouteDestination, removedRoute.NationalRouteNumber, removedRoute.BoardRouteNumber));

                    ////        var exstingRoute = existingModel.Routes.Where(a => a.ApplicationRouteDetailID == removedRoute.ApplicationRouteDetailID).FirstOrDefault();
                    ////        changes.AddRange(auditDb.GetEntityDifferences<ApplicationRouteDetail>(exstingRoute, removedRoute, "ApplicationRouteDetailID"));

                    ////        Database.Context.Entry(removedRoute).State = System.Data.Entity.EntityState.Deleted;                            
                    ////    }
                    ////}
                    ////#endregion

                    ////#region value.ApplicationVehicleDetailsInBulk
                    ////foreach (var bulkVehicle in value.ApplicationVehicleDetailsInBulk)
                    ////{
                    ////    if (bulkVehicle.ApplicationVehicleDetailsInBulkID > 0)
                    ////    {
                    ////        Database.Update(bulkVehicle);

                    ////        var exstingVehicleBulk = existingModel.ApplicationVehicleDetailsInBulk.Where(a => a.ApplicationVehicleDetailsInBulkID == bulkVehicle.ApplicationVehicleDetailsInBulkID).FirstOrDefault();
                    ////        changes.AddRange(auditDb.GetEntityDifferences<Models.ApplicationVehicleDetailsInBulk>(exstingVehicleBulk, bulkVehicle, "ApplicationVehicleDetailsInBulkID"));

                    ////    }
                    ////    else
                    ////    {
                    ////        Database.Insert(bulkVehicle);
                    ////        var blankObj = new Models.ApplicationVehicleDetailsInBulk();


                    ////        changes.Add(string.Format("{0}, Added vehicle {1}, {2}", "ApplicationVehicleDetailsInBulk", bulkVehicle.VIN, bulkVehicle.VehicleRegistrationNumber));
                    ////        changes.AddRange(auditDb.GetEntityDifferences<Models.ApplicationVehicleDetailsInBulk>(blankObj, bulkVehicle, "ApplicationVehicleDetailsInBulkID"));


                    ////    }
                    ////}

                    ////if (value.RemovedBulkVehicles != null)
                    ////{
                    ////    foreach (var bulkVehicle in value.RemovedBulkVehicles)
                    ////    {
                    ////        changes.Add(string.Format("{0}, Removed vehicle {1}, {2}", "ApplicationVehicleDetailsInBulk", bulkVehicle.VIN, bulkVehicle.VehicleRegistrationNumber));

                    ////        var exstingVehicleBulk = existingModel.ApplicationVehicleDetailsInBulk.Where(a => a.ApplicationVehicleDetailsInBulkID == bulkVehicle.ApplicationVehicleDetailsInBulkID).FirstOrDefault();
                    ////        changes.AddRange(auditDb.GetEntityDifferences<Models.ApplicationVehicleDetailsInBulk>(exstingVehicleBulk, bulkVehicle, "ApplicationVehicleDetailsInBulkID"));

                    ////        Database.Context.Entry(bulkVehicle).State = System.Data.Entity.EntityState.Deleted;
                    ////    }
                    ////}
                    ////#endregion

                    Database.Update(value);
                    changes.AddRange(auditDb.GetEntityDifferences<ApplicationDetail>(existingModel, value, "ApplicationDetailID"));

                    Database.Update(value.InspectionDetails);
                    changes.AddRange(auditDb.GetEntityDifferences<ApplicationInspectionDetail>(existingModel.InspectionDetails, value.InspectionDetails, "ApplicationDetailID"));
          
            }
            catch (Exception ex)
            {
                return new JsonNetResult()
                        {
                            Data = new JsonBaseResult()
                            {
                                Success = false,
                                ErrorCode = "ERROR",
                                Error =string.Format("Error: {0}", new LegitimateDatabase().GetInnermostMessage(ex))
                            }
                        };               
            }

            try
            {               
                Database.Save();
                
                WorkflowsDatabase workflowsDatabase = new WorkflowsDatabase();
                workflowsDatabase.ExecutePostFormSave(value.WorkflowInstanceID.Value, Profile.UserID);
                
                if (changes.Count > 0)
                {
                    auditDb.WriteEntries(2 /*Application*/, 2 /*Updated*/, changes, 1000 /*ApplicationRequestDetails*/, value.ApplicationDetailID, Profile.UserID);
                }                
            }
            catch (DbEntityValidationException dbEx)
            {
                foreach (var validationError in dbEx.EntityValidationErrors.SelectMany(validationErrors => validationErrors.ValidationErrors))
                {
                    return new JsonNetResult()
                        {
                            Data = new JsonBaseResult()
                            {
                                Success = false,
                                ErrorCode = "ERROR",
                                Error =string.Format("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage)
                            }
                        };
                }
            }
            catch (Exception ex)
            {
                if (ex.InnerException != null)
                {
                    if (ex.InnerException.Message.Contains("IX_PrecheckDetailID"))
                    {
                        return new JsonNetResult()
                        {
                            Data = new JsonBaseResult()
                            {
                                Success = false,
                                ErrorCode = "ERROR",
                                Error = "The application has already been saved against this pre-check. Please submit the original application instead."
                            }
                        };
                    }
                    else
                    {
                        return new JsonNetResult()
                        {
                            Data = new JsonBaseResult()
                            {
                                Success = false,
                                ErrorCode = "ERROR",
                                Error = string.Format("Error: {0}", new LegitimateDatabase().GetInnermostMessage(ex))
                            }
                        };
                    }
                }
                else {
                    return new JsonNetResult()
                    {
                        Data = new JsonBaseResult()
                        {
                            Success = false,
                            ErrorCode = "ERROR",
                            Error = string.Format("Error: {0}", new LegitimateDatabase().GetInnermostMessage(ex))
                        }
                    };
                }                
            }

            var formDb = new ApplicationDatabase();
            var formData =  formDb.GetApplicationInspectionDetails(value.ApplicationDetailID, Profile.UserID);
            
             return new JsonNetResult()
                    {
                        Data = new JsonBaseResult()
                        { 
                            Result = formData,
                            Success = true                            
                        }
                    };
        }
        #endregion

    }
}