using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Configuration;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Web;
using System.Web.Mvc;
using Waypoint.ActionFilters;
using Waypoint.Areas.Tracking.Models;
using Waypoint.BusinessLogic;
using Waypoint.CommandsEngine;
using Waypoint.Controllers;
using Waypoint.DAL;
using Waypoint.Helpers;
using Waypoint.Models;
using Waypoint.Models.Queries;
using Waypoint.Models.Results;
using Waypoint.Utils;

namespace Waypoint.Areas.Rental.Controllers
{
    [Authenticate]
    [RbacAuthorize(PermissionName = "RentalMaps")]
    public class TrackingController : WaypointController
    {
        public QueryProcessor _QueryProcessor { get; set; }

        private int _ConnectionOverdueTime = Convert.ToInt32(ConfigurationManager.AppSettings["ConnOverdueTime"]);
        private int _ConnectionOverdueTime_White = Convert.ToInt32(ConfigurationManager.AppSettings["ConnOverdueTime_White"]);
        protected RfidManager _rfidManager;
        private VideoManager _videoManager;
        bool _isVideoEnabled=false;
        public TrackingController()
        {
            var connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["WaypointConnStr"].ConnectionString;
            _QueryProcessor = new QueryProcessor(connectionString);
            _rfidManager = new RfidManager();
            _videoManager = new VideoManager();

            var isVideoEnabled = ConfigurationManager.AppSettings["IsVideoEnabled"];
            if(!string.IsNullOrEmpty(isVideoEnabled))
            {
                _isVideoEnabled = Boolean.Parse( isVideoEnabled);
            }
        }

        public ActionResult Index(string name)
        {
            PersistUserSettings();

            var vehiclesManager = new VehicleManager();
            ViewBag.VehiclesList = vehiclesManager.GetVehicles(UserInfo.TenantId, UserInfo.UserId, this.IsSysAdmin(), orderBy: "Name").Select(v => new { Name = v.Name, Id = v.VehicleId,ChassisNo = v.ChassisNo });

            var localTime = DateTime.UtcNow.ToLocalTime(UserInfo.Settings.TimeZone);
            var startOfDayTime = TimeSpan.FromHours(6);
            var endOfDayTime = TimeSpan.FromHours(18);
            ViewBag.IsDayTime = localTime.TimeOfDay >= startOfDayTime && localTime.TimeOfDay < endOfDayTime;

            var tenant = new TenantManager().GetTenant(UserInfo.TenantId);
            ViewBag.Tenant = tenant;
            ViewBag.IsTripSnapped = (tenant.Name.ToLowerInvariant() != "abra");
            ViewBag.IsVideoEnabled = tenant.Name.ToLowerInvariant().Contains("acacus") || tenant.Name.ToLowerInvariant().Contains("demo") || tenant.Name.ToLowerInvariant().Contains("dtc");
            ViewBag.IsAnimateTrip = tenant.Name.ToLowerInvariant().Contains("acacus") || tenant.Name.ToLowerInvariant().Contains("demo");
            ViewBag.IsShiftsEnabled = tenant.Name.ToLowerInvariant().Contains("acacus") || tenant.Name.ToLowerInvariant().Contains("demo") || _isVideoEnabled  ;

            ViewBag.DateFormat = "MM/DD/YYYY HH:mm:ss"; //GetFormatDate() ?? "dd/MM/yyyy HH:mm";
            ViewBag.DateFormatWithoutTime = GetFormatDateWithoutTime() ?? "dd/MM/yyyy";
            ViewBag.CalenderDate = GetCalenderFormatDateWithoutTime() ?? "dd/mm/yyyy";
            ViewBag.MapStyle = PageSettings?.MapFormat ?? MapFormat.Satellite;

            ViewBag.MapRefreshTime = PageSettings?.MapRefreshTime ?? MapRefreshTime.OneMinute;
            ViewBag.UnitOfDistance = PageSettings?.UnitOfDistance ?? UnitOfDistance.Km;
            ViewBag.UnitOfSpeed = PageSettings?.UnitOfSpeed ?? UnitOfSpeed.KmHr;
            ViewBag.DateFormat = PageSettings?.DateFormat ?? DateFormat.DayMonthYear;
            ViewBag.TimeFormat = PageSettings?.TimeFormat ?? TimeFormat.TwentyFourHour;
            ViewBag.Name = name;
            ViewBag.IsAutoRecording = PageSettings.IsAutoRecording;
            ViewBag.RecordingPeriod = PageSettings.PeriodOfRecording;
            ViewBag.freezeMapDeclustering = ConfigurationManager.AppSettings["freezeMapDeclustering"].ToString().ToLower();

            ViewBag.LocalDate = DateTime.UtcNow.ToLocalTime(UserInfo.Settings.TimeZone).Date;
            ViewBag.EnableDirectionMap = false;

            var enumData = from VehicleState e in Enum.GetValues(typeof(VehicleState))
                           select new
                           {
                               Id = (int)e,
                               Name = e.ToString()
                           };

            ViewBag.VehicleStates = new SelectList(enumData, "Id", "Name");

            string enableDirectionMap= ConfigurationManager.AppSettings["EnableDirectionMap"];
            bool enableDirectionMapValue = false;
            if (!string.IsNullOrEmpty(enableDirectionMap) && bool.TryParse(enableDirectionMap, out enableDirectionMapValue))
            {
                ViewBag.EnableDirectionMap = enableDirectionMapValue;
            }
            bool isMultiStreamingEnabled ;
            string isMultiStreamingEnabledValue = ConfigurationManager.AppSettings["IsMultiStreamingEnabled"];
            bool.TryParse(isMultiStreamingEnabledValue, out isMultiStreamingEnabled);
            ViewBag.IsMultiStreamingEnabled = isMultiStreamingEnabled;
            return View();
        }

        public ActionResult Mobile()
        {
            PersistUserSettings();

            var vehiclesManager = new VehicleManager();
            ViewBag.VehiclesList = vehiclesManager.GetVehicles(UserInfo.TenantId, UserInfo.UserId, this.IsSysAdmin(), orderBy: "Name").Select(v => new { Name = v.Name, Id = v.VehicleId });

            var localTime = DateTime.UtcNow.ToLocalTime(UserInfo.Settings.TimeZone);
            var startOfDayTime = TimeSpan.FromHours(6);
            var endOfDayTime = TimeSpan.FromHours(18);
            ViewBag.IsDayTime = localTime.TimeOfDay >= startOfDayTime && localTime.TimeOfDay < endOfDayTime;

            var tenant = new TenantManager().GetTenant(UserInfo.TenantId);
            ViewBag.Tenant = tenant;
            ViewBag.IsTripSnapped = (tenant.Name.ToLowerInvariant() != "abra");

            return View();
        }

        [HttpPost]
        public JsonResult UpdateTripAddress(long tripId, bool isFirstAddress, string address)
        {
            new TripManager().UpdateTripLocation(tripId, isFirstAddress, address);
            return new JsonResult();
        }

        //[HttpGet]
        [HttpPost]
        public async Task<ActionResult> TrackingDataForMap(TrackingDataForMapRequestViewModel model)
        {
            //model.FromDate = model.FromDate.AddDays(-4);
            //model.ToDate = model.ToDate.AddDays(-2);


            ViewContext vc = new ViewContext();
            var queryAllVehicles = new TrackingQuery
            {
                Time = TimeSpan.FromDays(90), // 3 months
                TenantId = UserInfo.TenantId,
                VehicleId = 0,
                IncludeAlerts = true,
                Filter = model.Filter,
                OnlyLastLocation = true,
                UserId = UserInfo.UserId,
                IsAdminUser = this.IsSysAdmin(),
                VehicleState = model.VehicleState
            };

            var dataAllVehicles = await _QueryProcessor.Process<TrackingQuery, List<TrackingQueryResult>>(queryAllVehicles);
            var tripSummaryMap = await GetTripsSummary(new VehicleTripsQuery
            {
                TenantId = UserInfo.TenantId,
                VehicleId = 0,
                FromDate = model.FromDate,
                ToDate = model.ToDate,
                TimeZone = UserInfo.Settings.TimeZone,
                UserId = UserInfo.UserId,
                IsAdminUser = this.IsSysAdmin(),
                IsDTCUser = vc.Controller.IsDTCTenant(),

            }
            .WithFromTime(model.FromTime)
            .WithToTime(model.ToTime));

            foreach (var d in dataAllVehicles)
            {
                d.IsNoSignal = _GetIsNoSignal(d.TrackingItems.Last().TimeStamp);
                d.IsNoSignal_White = _GetIsNoSignal_White(d.TrackingItems.Last().TimeStamp);
                foreach (var t in d.TrackingItems)
                {
                    t.TimeStamp = t.TimeStamp.ToLocalTime(UserInfo.Settings.TimeZone);
                    t.CreationDate = t.CreationDate.ToLocalTime(UserInfo.Settings.TimeZone);
                }
                d.TimeStamp = d.TrackingItems.First().TimeStamp;

                TripSummary tripSummary;
                if (tripSummaryMap.TryGetValue(d.VehicleId, out tripSummary))
                {
                    d.AlertCount = tripSummary.AlertCount;
                    d.TripCount = tripSummary.TripCount;
                    d.HarshBrakingCount = tripSummary.HarshBrakingCount;
                    d.IdlingAlertCount = tripSummary.IdlingAlertCount;
                }
            }

            var querySelectedVehicle = new TrackingQuery
            {
                Time = TimeSpan.FromHours(model.Hours),
                TenantId = UserInfo.TenantId,
                VehicleId = model.SelectedVehicleId,
                IncludeAlerts = true,
                OnlyLastLocation = false
            };

            var result = new TrackingDataForMapResponseViewModel
            {
                TrackingAllVehicles = dataAllVehicles,
                SelectedVehicleId = model.SelectedVehicleId
            };

            if (false && model.SelectedVehicleId > 0)
            {
                var dataSelectedVehicle = await _QueryProcessor.Process<TrackingQuery, List<TrackingQueryResult>>(querySelectedVehicle);
                foreach (var d in dataSelectedVehicle)
                {
                    d.IsNoSignal = _GetIsNoSignal(d.TrackingItems.Last().TimeStamp);
                    d.IsNoSignal_White = _GetIsNoSignal_White(d.TrackingItems.Last().TimeStamp);
                    foreach (var t in d.TrackingItems)
                    {
                        t.TimeStamp = t.TimeStamp.ToLocalTime(UserInfo.Settings.TimeZone);
                        t.CreationDate = t.CreationDate.ToLocalTime(UserInfo.Settings.TimeZone);
                    }
                }
                result.TrackingSelectedVehicle = dataSelectedVehicle;
            }

            var querySelectedVehicleTrips = new VehicleTripsQuery
            {
                TenantId = UserInfo.TenantId,
                VehicleId = model.SelectedVehicleId,
                FromDate = model.FromDate,
                ToDate = model.ToDate,
                TimeZone = UserInfo.Settings.TimeZone,
                IsDTCUser = vc.Controller.IsDTCTenant()
            }
            .WithFromTime(model.FromTime)
            .WithToTime(model.ToTime);

            if (true && model.SelectedVehicleId > 0)
            {
                var trips = await _QueryProcessor.Process<VehicleTripsQuery, List<VehicleTripResult>>(querySelectedVehicleTrips);
                foreach (var trip in trips)
                {
                    trip.CreationDate = trip.CreationDate.ToLocalTime(UserInfo.Settings.TimeZone);
                    trip.StartedOn = trip.StartedOn.ToLocalTime(UserInfo.Settings.TimeZone);
                    trip.FinishedOn = trip.FinishedOn.ToLocalTime(UserInfo.Settings.TimeZone);

                    _MapXTrips(trip);
                }
                trips.Reverse();
                result.Trips = trips;

                var vehicleStatusQuery = new LastVehicleStatusQuery
                {
                    TenantId = UserInfo.TenantId,
                    VehicleId = model.SelectedVehicleId
                };

                if (model.IsMobile)
                {
                    var status = await _QueryProcessor.Process<LastVehicleStatusQuery, LastVehicleStatusQueryResult>(vehicleStatusQuery);

                    status.TimeStamp = status.TimeStamp.ToLocalTime(UserInfo.Settings.TimeZone);
                    status.CommandDate = status.CommandDate.ToLocalTime(UserInfo.Settings.TimeZone);
                    status.ConfirmedOn = status.ConfirmedOn.ToLocalTime(UserInfo.Settings.TimeZone);
                    status.ReceivedConfirmOn = status.ReceivedConfirmOn.ToLocalTime(UserInfo.Settings.TimeZone);
                    status.SentOn = status.SentOn.ToLocalTime(UserInfo.Settings.TimeZone);

                    result.Status = status;
                }
            }

            var lastAlerts = await _QueryProcessor.Process<LastTriggeredAlertsQuery, List<LastTriggeredAlertResult>>(new LastTriggeredAlertsQuery { Count = 10, TenantId = UserInfo.TenantId });
            var dateTimeFormat = GetFormatDate(false);
            foreach (var alert in lastAlerts)
            {
                alert.FirstTime = alert.FirstTime.ToLocalTime(UserInfo.Settings.TimeZone);
                alert.LastTime = alert.FirstTime.ToLocalTime(UserInfo.Settings.TimeZone);
                alert.FirstTimeFormatted = alert.FirstTime.ToString($"ddd {dateTimeFormat}");
            }
            result.LastAlerts = lastAlerts;


            return JsonNet(result, Results.JsonNetResultOptions.AllowGet);
        }

        [HttpPost]
        public async Task<ActionResult> GetAreas()
        {

            var areas = new AreaManager().GetAreas(UserInfo.TenantId)
                .Where(x => x.Target != AreaTargets.None)
                .Select(x=> new ViewModels.AreaViewModel { Id = x.AreaId, Name = x.Name, Target = x.Target, Shape = x.Shape, Description=x.Description })
                .ToList();

            var result = await Task.FromResult<List<ViewModels.AreaViewModel>>(areas);

            return JsonNet(result, Results.JsonNetResultOptions.None);
        }

        [HttpPost]
        public ActionResult GetAlertVideos(DateTime from, DateTime to, string vehicleName)
        {
            var result = _videoManager.GetAlertVideos(from, to, vehicleName,UserInfo.TenantId);
            return JsonNet(result);
        }



        [HttpPost]
        public async Task<ActionResult> Trips(TrackingDataForMapRequestViewModel model)
        {
            ViewContext vc = new ViewContext();

            var result = new TrackingDataForMapResponseViewModel
            {
                SelectedVehicleId = model.SelectedVehicleId
            };

            var querySelectedVehicleTrips = new VehicleTripsQuery
            {
                TenantId = UserInfo.TenantId,
                VehicleId = model.SelectedVehicleId,
                FromDate = model.FromDate,
                ToDate = model.ToDate,
                TimeZone = UserInfo.Settings.TimeZone,
                IsDTCUser = vc.Controller.IsDTCTenant()
            }
            .WithFromTime(model.FromTime)
            .WithToTime(model.ToTime);

            if (model.SelectedVehicleId > 0)
            {
                var trips = await _QueryProcessor.Process<VehicleTripsQuery, List<VehicleTripResult>>(querySelectedVehicleTrips);
                trips.Reverse();

                foreach (var trip in trips)
                {
                    trip.CreationDate = trip.CreationDate.ToLocalTime(UserInfo.Settings.TimeZone);
                    trip.StartedOn = trip.StartedOn.ToLocalTime(UserInfo.Settings.TimeZone);
                    trip.FinishedOn = trip.FinishedOn.ToLocalTime(UserInfo.Settings.TimeZone);
                    _MapXTrips(trip);
                }
                result.Trips = trips;
            }

            querySelectedVehicleTrips.VehicleId = 0;
            var tripsSummaryAllVehicles = await GetTripsSummary(querySelectedVehicleTrips);
            result.TripsSummary = tripsSummaryAllVehicles;

            return JsonNet(result, Results.JsonNetResultOptions.AllowGet);
        }

        private void _MapXTrips(VehicleTripResult trip)
        {
            if (trip.IsXTrip)
            {
                if (trip.XStartOdometer.HasValue)
                {
                    trip.StartDistance = trip.XStartOdometer.Value;
                }
                if (trip.XFinishOdometer.HasValue)
                {
                    trip.FinishDistance = trip.XFinishOdometer.Value;
                }
                if (trip.XStartLoggedTimeUtc.HasValue)
                {
                    trip.StartedOn = trip.XStartLoggedTimeUtc.Value.ToLocalTime(UserInfo.Settings.TimeZone);
                }
                if (trip.XFinishLoggedTimeUtc.HasValue)
                {
                    trip.FinishedOn = trip.XFinishLoggedTimeUtc.Value.ToLocalTime(UserInfo.Settings.TimeZone);
                }
            }
        }

        public async Task<ActionResult> TripDetails(VehicleTripResult model)
        {
            var trip = new TripManager().GetTrip(model.TripId);

            var query = new TripDetailQuery
            {
                TenantId = UserInfo.TenantId,
                VehicleId = trip.VehicleId,
                FromCrumbId = trip.OriginId,
                ToCrumbId = trip.DestinationId.GetValueOrDefault(),
                TimeFrom = trip.StartedOn.GetValueOrDefault(),
                TimeTo = trip.FinishedOn.GetValueOrDefault(),
                IncludeAlerts = true
            };

            var track = await _QueryProcessor.Process<TripDetailQuery, List<TrackingQueryResult>>(query);
            foreach (var t in track)
            {
                foreach (var ti in t.TrackingItems)
                {
                    ti.TimeStamp = ti.TimeStamp.ToLocalTime(UserInfo.Settings.TimeZone);
                    ti.CreationDate = ti.CreationDate.ToLocalTime(UserInfo.Settings.TimeZone);

                    foreach (var ta in ti.TrackingAlerts)
                    {
                        ta.FirstTime = ta.FirstTime.ToLocalTime(UserInfo.Settings.TimeZone);
                        ta.LastTime = ta.LastTime.ToLocalTime(UserInfo.Settings.TimeZone);
                    }
                }
            }
            var result = track;

            return JsonNet(result, Results.JsonNetResultOptions.AllowGet);
        }

        //[HttpGet]
        [HttpPost]
        public async Task<ActionResult> TrackingDataForReport(TrackingDataForReportRequestViewModel options)
        {
            var pageSize = 20;
            var query = new VehicleQuery
            {
                IncludeRfid = true,
                TennantId = UserInfo.TenantId,

                From = options.From ?? DateTime.Now.Date,
                To = options.To ?? DateTime.Now,

                CrewName = options.CrewName,
                CrewPhone = options.CrewPhone,
                CrewRfid = options.CrewRfid,

                VehicleName = options.VehicleName,
                VehiclePhone = options.VehiclePhone,
                VehiclePlateNo = options.VehiclePlateNo
            }.WithPaging(options.Page, pageSize);

            var connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["WaypointConnStr"].ConnectionString;
            var handler = new QueryProcessor(connectionString);
            var data = await handler.Process<VehicleQuery, List<VehicleQueryResult>>(query);
            var count = await handler.Process<VehicleCountQuery, int>(new VehicleCountQuery(query));

            foreach (var d in data)
            {
                d.FirstTime = d.FirstTime.ToLocalTime(UserInfo.Settings.TimeZone);
                d.LastTime = d.LastTime.ToLocalTime(UserInfo.Settings.TimeZone);
                foreach (var r in d.RfidItems)
                {
                    r.RfidScannedOn = r.RfidScannedOn.ToLocalTime(UserInfo.Settings.TimeZone);
                }
            }

            var result = new TrackingDataForReportResponseViewModel
            {
                Data = data,
                Count = count,
                PageSize = pageSize,
                Page = options.Page,
                Pages = (int) Math.Ceiling(count / (pageSize + 0.0M))
            };

            return JsonNet(result);
        }

        [HttpPost]
        public async Task<ActionResult> LastLocations(LastLocationsRequestViewModel options)
        {
            var connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["WaypointConnStr"].ConnectionString;
            var query = new LastVehicleLocationsQuery
            {
                VehicleId = options.VehicleId,
                TenantId = UserInfo.TenantId,
                Count = 5
            };

            var handler = new QueryProcessor(connectionString);
            var data = await handler.Process<LastVehicleLocationsQuery, LastVehicleLocationsQueryResult>(query);
            var result = new LastLocationsResponseViewModel
            {
                Locations = data.Locations
            };

            return JsonNet(result);
        }

        [HttpPost]
        public async Task<ActionResult> GetContracts(GetContractsRequestViewModel model)
        {
            var contractQuery = new ContractQuery
            {
                TenantId = UserInfo.TenantId,
                VehicleId = model.ContractVehicleId.GetValueOrDefault(),
                ContractName = model.ContractName,
                ContractNumber = model.ContractNumber,
                DeviceIMEI = model.ContractDeviceIMEI,
                SIMCard = model.ContractSimCard,
                From = model.ContractFrom,
                To = model.ContractTo,
                IncludeDetails = true
            }.WithPaging(model.ContractPage.GetValueOrDefault(), 10);

            var contracts = await _QueryProcessor.Process<ContractQuery, List<ContractQueryResult>>(contractQuery);

            var contractCountQuery = new ContractCountQuery(contractQuery);
            var contractCount = await _QueryProcessor.Process<ContractCountQuery, int>(contractCountQuery);

            var result = new GetContractsResponseViewModel
            {
                Contracts = contracts,
                Count = contractCount
            };

            return JsonNet(result);
        }

        [HttpPost]
        public async Task<ActionResult> VehicleStatus(VehicleStatusRequestViewModel model)
        {
            try
            {
                DeviceTypeManager deviceTypeManager = new DeviceTypeManager();
                var vehicleStatusQuery = new LastVehicleStatusQuery
                {
                    TenantId = UserInfo.TenantId,
                    VehicleId = model.VehicleId
                };

                var result = await _QueryProcessor.Process<LastVehicleStatusQuery, LastVehicleStatusQueryResult>(vehicleStatusQuery);

                result.TimeStamp = result.TimeStamp.ToLocalTime(UserInfo.Settings.TimeZone);
                result.CommandDate = result.CommandDate.ToLocalTime(UserInfo.Settings.TimeZone);
                result.ConfirmedOn = result.ConfirmedOn.ToLocalTime(UserInfo.Settings.TimeZone);
                result.ReceivedConfirmOn = result.ReceivedConfirmOn.ToLocalTime(UserInfo.Settings.TimeZone);
                result.SentOn = result.SentOn.ToLocalTime(UserInfo.Settings.TimeZone);

                if (model.LiveTracking)
                {
                    var lastCrumb = new CrumbManager().GetCrumb(model.LastCrumbId, UserInfo.TenantId);


                    var query = new TripDetailQuery
                    {
                        TenantId = UserInfo.TenantId,
                        VehicleId = model.VehicleId,
                        FromCrumbId = model.LastCrumbId + 1,
                        ToCrumbId = 0,
                        TimeFrom = model.LastCrumbId == 0 ? DateTime.UtcNow.Subtract(TimeSpan.FromMinutes(15)) : lastCrumb != null ? lastCrumb.TimeStamp: DateTime.UtcNow.Subtract(TimeSpan.FromMinutes(15)),
                        IncludeAlerts = true
                    };

                    var track = await _QueryProcessor.Process<TripDetailQuery, List<TrackingQueryResult>>(query);

                    if (track.Count == 0 && model.LastCrumbId == 0)
                    {
                        query.OnlyLast = true;
                        track = await _QueryProcessor.Process<TripDetailQuery, List<TrackingQueryResult>>(query);
                    }

                    foreach (var t in track)
                    {
                        foreach (var ti in t.TrackingItems)
                        {
                            ti.TimeStamp = ti.TimeStamp.ToLocalTime(UserInfo.Settings.TimeZone);
                            ti.CreationDate = ti.CreationDate.ToLocalTime(UserInfo.Settings.TimeZone);
                        }
                    }

                    result.Track = track;
                    result.Query = query;
                }

                var formatDate = GetFormatDate(true);
                var deviceType = result.StreamingDeviceType;

                result.ChannelCount = deviceTypeManager.GetDeviceTypes().Where(x => x.Code == result.StreamingDeviceType).FirstOrDefault().ChannelsCount;
                result.Rfids =  _rfidManager.GetLastTen(model.FromDate, model.ToDate,model.VehicleId, UserInfo.Settings.TimeZone).ToList();
                foreach (var rfid in result.Rfids)
                {
                    rfid.ScannedOn = rfid.ScannedOn.ToLocalTime(UserInfo.Settings.TimeZone);
                    rfid.ScannedOnFormatted = rfid.ScannedOn.ToString(formatDate);
                }
                return JsonNet(result);
            }
            catch (Exception e)
            {
                return JsonNet(new ErrorResult
                {
                    Error = e.Message,
                    Message = "Error retreiving Vehicle data. Please Refresh."
                });
            }
        }

        [HttpPost]
        public async Task<ActionResult> SendCommand(VehicleStatusRequestViewModel model)
        {
            const int EnableCommand = 0;
            const int DisableCommand = 1;
            const int CancelCommand = 2;

            DeviceCommManager service = new DeviceCommManager();
            var vehicleStatusQuery = new LastVehicleStatusQuery
            {
                TenantId = UserInfo.TenantId,
                VehicleId = model.VehicleId
            };

            var vehicle = new VehicleManager().GetVehicle(model.VehicleId, UserInfo.TenantId);
            var command = new CommandManager().GetCommand(1);

            if (model.CommandId == CancelCommand)
            {
                using (var context = new WaypointContext())
                {
                    var communication = context.DeviceCommunications
                        .OrderByDescending(c => c.CommunicationId)
                        .FirstOrDefault(c => c.VehicleId == model.VehicleId);

                    if (communication != null)
                    {
                        communication.Status = (int) Models.Sms.SmsStatus.UserCanceled;
                        communication.SentMessageStatus = Models.Sms.SmsStatus.UserCanceled;
                        communication.Error = "Command was Canceled";
                        communication.IsError = true;
                        communication.ConfirmedOn = DateTime.UtcNow;

                        var sentMessages = context.SentMessages
                            .Where(m => m.CommunicationId == communication.CommunicationId)
                            .ToList();

                        foreach (var message in sentMessages)
                        {
                            message.Status = Models.Sms.SmsStatus.UserCanceled;
                        }
                    }
                    context.SaveChanges();
                }

                try
                {
                    var result = await _QueryProcessor.Process<LastVehicleStatusQuery, LastVehicleStatusQueryResult>(vehicleStatusQuery);

                    return JsonNet(result);
                }
                catch (Exception e)
                {
                    return JsonNet(new ErrorResult
                    {
                        Error = e.Message,
                        Message = "Error retreiving Vehicle data. Please Refresh."
                    });
                }
            }

            /*CommandId,SendingOption,Value,VehicleId*/
            var deviceCommunication = new DeviceCommunication();
            deviceCommunication.CreatedById = UserInfo.UserId;
            deviceCommunication.CreationDate = DateTime.UtcNow;
            deviceCommunication.TenantId = UserInfo.TenantId;

            deviceCommunication.VehicleId = model.VehicleId;
            deviceCommunication.CommandId = command.CommandId;
            deviceCommunication.SendingOption = SendingOptions.Sms;
            deviceCommunication.Value = model.CommandId == 1 ? "0" : "1"; //model.CommandId.ToString();//0: Off, 1: On

            var commandText = RuptelaCommandBuilder.BuildCommand(command.Format, deviceCommunication.Value);

            //deviceCommunication.FinalStatusOn
            deviceCommunication.Status = (int) Waypoint.Models.Sms.SmsStatus.NotSent;
            deviceCommunication.Body = commandText;
            deviceCommunication.To = vehicle.DeviceSimCard.Phone;
            deviceCommunication.UserId = UserInfo.UserId;
            deviceCommunication.TriggeredAlertId = null;
            deviceCommunication.AlertId = null;
            deviceCommunication.MessageSourceType = (int) MessageSourceType.UserCommand;

            var vehicleStatusManager = new VehicleStatusManager();
            var vehicleStatus = vehicleStatusManager.GetVehicleStatus(model.VehicleId, UserInfo.TenantId);
            var sendNow = (model.CommandId == DisableCommand && vehicleStatus != null && vehicleStatus.Speed > 10) == false;

            if (sendNow == false)
            {
                deviceCommunication.Status = (int) Models.Sms.SmsStatus.Scheduled;
                deviceCommunication.SentMessageStatus = Models.Sms.SmsStatus.Scheduled;
                deviceCommunication.SentMessageType = SentMessageType.DisableVehicle;
            }


            service.AddDeviceCommunication(deviceCommunication, SentMessageType.UserCreated);

            if (false && service.Result == 1)
            {
                if (sendNow)
                {
                    var clickatell_username = ConfigurationManager.AppSettings["Clickatell.UserName"];
                    var clickatell_password = ConfigurationManager.AppSettings["Clickatell.Password"];
                    var clickatell_api_id = ConfigurationManager.AppSettings["Clickatell.ApiId"];

                    var smsClient = new Waypoint.Messaging.ClickatellClient.SmsClient(clickatell_username, clickatell_password, clickatell_api_id);
                    await SendSmsCommand(service, deviceCommunication, smsClient);
                }
            }

            try
            {
                var result = await _QueryProcessor.Process<LastVehicleStatusQuery, LastVehicleStatusQueryResult>(vehicleStatusQuery);

                return JsonNet(result);
            }
            catch (Exception e)
            {
                return JsonNet(new ErrorResult
                {
                    Error = e.Message,
                    Message = "Error retreiving Vehicle data. Please Refresh."
                });
            }
        }

        private async Task SendSmsCommand(DeviceCommManager service, DeviceCommunication deviceCommunication, Messaging.ClickatellClient.SmsClient smsClient)
        {
            var try_count = 0;
            Models.Sms.SmsMessageResult send_result = new Models.Sms.SmsMessageResult { IsOk = false };
            while (!send_result.IsOk && try_count <= 5)
            {
                try_count++;

                send_result = await smsClient.Send(new Models.Sms.SmsMessage
                {
                    To = deviceCommunication.To,
                    Body = deviceCommunication.Body
                });

                if (send_result.IsOk)
                {
                    deviceCommunication.Reference = send_result.Reference;
                    deviceCommunication.IsError = false;
                    service.UpdateDeviceCommunication(deviceCommunication);
                    break;
                }
                else
                {
                    deviceCommunication.IsError = true;
                    deviceCommunication.Error = $"{send_result.ErrorCode}: {send_result.Error}";
                    service.UpdateDeviceCommunication(deviceCommunication);
                }
            }

            if (send_result.IsOk)
            {
                try_count = 0;
                var t = Task.Run(async () => {
                    Models.Sms.SmsReferenceResult enquire_result = new Models.Sms.SmsReferenceResult { IsOk = false };

                    while (!enquire_result.IsOk && try_count <= 5)
                    {
                        await Task.Delay(2000);

                        try_count++;

                        enquire_result = await smsClient.GetMessage(new Models.Sms.SmsReference
                        {
                            Reference = deviceCommunication.Reference
                        });

                        if (enquire_result.IsOk)
                        {
                            deviceCommunication.FinalStatusOn = enquire_result.UpdatedOn;
                            deviceCommunication.Status = (int)enquire_result.Status;
                            deviceCommunication.IsConfirmed = enquire_result.Status == Models.Sms.SmsStatus.Delivered || enquire_result.Status == Models.Sms.SmsStatus.Sent;
                            if (deviceCommunication.IsConfirmed)
                            {
                                deviceCommunication.ConfirmedOn = enquire_result.UpdatedOn;
                                deviceCommunication.ReceivedConfirmOn = DateTime.UtcNow;
                            }
                            service.UpdateDeviceCommunication(deviceCommunication);
                            break;
                        }
                        else
                        {
                            deviceCommunication.FinalStatusOn = enquire_result.UpdatedOn;
                            deviceCommunication.Status = (int)enquire_result.Status;
                            service.UpdateDeviceCommunication(deviceCommunication);
                        }
                    }
                });
            }
        }

        [HttpPost]
        public async Task<ActionResult> ExportCsv()
        {
            var form = Request.Form["options"];
            var options = Newtonsoft.Json.JsonConvert.DeserializeObject<TrackingDataForReportRequestViewModel>(form);

            var query = new VehicleQuery
            {
                IncludeRfid = true,
                TennantId = UserInfo.TenantId,

                From = options.From ?? DateTime.Now.Date,
                To = options.To ?? DateTime.Now,

                CrewName = options.CrewName,
                CrewPhone = options.CrewPhone,
                CrewRfid = options.CrewRfid,

                VehicleName = options.VehicleName,
                VehiclePhone = options.VehiclePhone,
                VehiclePlateNo = options.VehiclePlateNo
            };

            var connectionString = System.Configuration.ConfigurationManager.ConnectionStrings["WaypointConnStr"].ConnectionString;
            var handler = new QueryProcessor(connectionString);
            var data = await handler.Process<VehicleQuery, List<VehicleQueryResult>>(query);
            var result = new TrackingDataForReportResponseViewModel
            {
                Data = data
            };

            var csvBldr = new StringBuilder();

            csvBldr.AppendLine(@"Header,Bus,Date,IMEI,PlateNumber,FirstPositionLat,FirstPositionLng,FirstPositionTime,LastPositionLat,LastPositionLng,LastPositionTime");
            foreach (var v in result.Data)
            {
                csvBldr.AppendLine($"V,{v.BusName.CsvEscape()},{v.FirstTime.Date.ToString("yyyy-MM-dd").CsvEscape()},{v.IMEI.CsvEscape()},{v.PlateNo.CsvEscape()},{v.FirstLat.ToString().CsvEscape()},{v.FirstLng.ToString().CsvEscape()},{v.FirstTime.ToString("yyyy-MM-dd HH:ss").CsvEscape()},{v.LastLat.ToString().CsvEscape()},{v.LastLng.ToString().CsvEscape()},{v.LastTime.ToString("yyyy-MM-dd HH:ss").CsvEscape()}");
                foreach (var r in v.RfidItems.GroupBy(x=>x.Rfid))
                {
                    var first = r.First();
                    var last = r.Last();
                    csvBldr.AppendLine($"R,{r.Key.CsvEscape()},{first.RfidName.CsvEscape()},{first.RfidMobileNo.CsvEscape()},{first.RfidScannedOn.ToString("yyyy-MM-dd HH:ss").CsvEscape()},{first.RfidLat.ToString().CsvEscape()},{first.RfidLng.ToString().CsvEscape()},{last.RfidScannedOn.ToString("yyyy-MM-dd HH:ss").CsvEscape()},{last.RfidLat.ToString().CsvEscape()},{last.RfidLng.ToString().CsvEscape()}");
                }
            }
            var csv = csvBldr.ToString();
            var bytes = System.Text.Encoding.UTF8.GetBytes(csv);
            return File(bytes, "text/csv", "vehicle_report_" + DateTime.Now.ToString("yyyy_MM_dd_HH_mm_ss") +".csv");
        }

        private bool _GetIsNoSignal(DateTime timestamp)
        {
            var currentDate = DateTime.UtcNow;
            var isNoSignal = (currentDate - timestamp).TotalMinutes > _ConnectionOverdueTime;
            return isNoSignal;
        }

        private bool _GetIsNoSignal_White(DateTime timestamp)
        {
            var currentDate = DateTime.UtcNow;
            var isNoSignal = (currentDate - timestamp).TotalMinutes > _ConnectionOverdueTime_White;
            return isNoSignal;
        }

        private async Task<Dictionary<int, TripSummary>> GetTripsSummary(VehicleTripsQuery querySelectedVehicleTrips)
        {
            var tripSummaryMap = new Dictionary<int, TripSummary>();
            string constr = "";
            using (var context = new WaypointContext())
            {
                constr = context.Database.Connection.ConnectionString;
            }
            var handler = new VehicleTripSummeryQueryHandler(constr);
            var trips = await handler.Handle(querySelectedVehicleTrips)
                .ConfigureAwait(false);

            foreach (var trip in trips)
            {
                TripSummary summary;
                if (tripSummaryMap.TryGetValue(trip.VehicleId, out summary))
                {
                    summary.AlertCount += trip.AlertCount;
                    summary.HarshBrakingCount += trip.HarshBrakingCount;
                    summary.IdlingAlertCount += trip.IdlingAlertCount;
                    summary.TripCount += 1;
                }
                else
                {
                    summary = new TripSummary
                    {
                        VehicleId = trip.VehicleId,
                        AlertCount = trip.AlertCount,
                        HarshBrakingCount = trip.HarshBrakingCount,
                        IdlingAlertCount = trip.IdlingAlertCount,
                        TripCount = 1
                    };
                    tripSummaryMap[summary.VehicleId] = summary;
                }
            }

            return tripSummaryMap;
        }
    }

    public class TripSummary
    {
        public int VehicleId { get; set; }
        public int TripCount { get; set; }
        public int AlertCount { get; set; }
        public int HarshBrakingCount { get; set; }
        public int IdlingAlertCount { get; set; }
    }
}