using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;
using InABox.Mobile;
using InABox.Rpc;

namespace comal.timesheets
{

    public class GPSEventArgs : EventArgs
    {
        
    }
    
    public delegate void GPSLocationUpdatedEvent(GPSEventArgs args);

    public class BluetoothEventArgs : EventArgs
    {
        
    }

    public delegate void BluetoothScanFinishedEvent(BluetoothEventArgs args);
    
    public class TransportConnectedEventArgs : EventArgs
    {
        
    }

    public delegate void TransportConnectedEvent(TransportConnectedEventArgs args);
    
    public class TransportDisconnectedEventArgs : EventArgs
    {
        
    }

    public delegate void TransportDisconnectedEvent(TransportDisconnectedEventArgs args);
    
    public class DataModel : IModelHost
    {

        public event GPSLocationUpdatedEvent GPSLocationUpdated;

        public event BluetoothScanFinishedEvent BluetoothScanFinished;

        /// <summary>
        /// All Active Employees of the Company
        /// </summary>
        public EmployeeModel Employees { get; private set; }

        /// <summary>
        /// EmployeeDetails for Currently Logged in User
        /// </summary>
        public EmployeeDetailModel Me { get; private set; }
        
        /// <summary>
        /// All Employee Teams for the Company
        /// Should this be just teams I am a part of, or all available teams
        /// Need to implement a Security Token to differentiate
        /// </summary>
        public EmployeeTeamModel EmployeeTeams { get; private set; }
        
        /// <summary>
        /// All Available Contacts - used in Deliveries
        /// </summary>
        public ContactModel Contacts { get; private set; }
        
        /// <summary>
        /// All Defined Bluetooth-enabled Gates
        /// </summary>
        public BluetoothGateModel BluetoothGates { get; private set; }
        
        /// <summary>
        /// Unprocessed Timesheets for Currently Logged in User
        /// </summary>
        public TimeSheetModel TimeSheets { get; private set; }
        
        /// <summary>
        /// List of All active Jobs
        /// </summary>
        public JobLookupModel JobLookups { get; private set; }
        
        /// <summary>
        /// List of Jobs that Currently Logged in User has access To
        /// </summary>
        public JobModel Jobs { get; private set; }

        /// <summary>
        /// List of Assignments for ??? need to specify this.
        /// Can I see other people's assignments?  (Security Token)
        /// How far back / forward can I look.
        /// This smells Transient, or maybe split into lookups (for all)
        /// and shells (for mine)
        /// Possibly need a back/forward window as well?
        /// </summary>
        public AssignmentModel Assignments { get; private set; }
        
        /// <summary>
        /// Master Product Catalogue for the company
        /// This should be split into Lookups and Shells
        /// </summary>
        public ProductModel Products { get; private set; }
        
        /// <summary>
        /// Master Product Groups List (Lookup?)
        /// </summary>
        public ProductGroupLookupModel ProductGroupsLookup { get; private set; }

        /// <summary>
        /// All GPS Tracker Devices registered by the company
        /// </summary>
        public GPSTrackerModel GPSTrackers { get; private set; }
        
        /// <summary>
        /// Master Equipment Register
        /// </summary>
        public EquipmentModel Equipment { get; private set; }
        
        /// <summary>
        /// Master List of Equipment Groups
        /// </summary>
        public EquipmentGroupModel EquipmentGroups { get; private set; }
        
        /// <summary>
        /// List of all Deliveries made in the last 90 days
        /// hmmm.. should be configurable?
        /// </summary>
        public DeliveryModel Deliveries { get; private set; }
        
        /// <summary>
        /// My Notifications (open only?)
        /// </summary>
        public NotificationModel Notifications { get; private set; }
        
        /// <summary>
        /// All Open Kanbans
        /// </summary>
        public KanbanLookupModel KanbanLookups { get; private set; }
        
        /// <summary>
        /// All Tasks I am subscribed to
        /// </summary>
        public KanbanModel Kanbans { get; private set; }
        
        /// <summary>
        /// Available Form Library - this includes all "Applies To" values
        /// You can filter to a specific type by using the "Search" function
        /// </summary>
        public DigitalFormModel DigitalForms { get; private set; }
        
        // The list of open task-kased forms for the current user
        // Specifically for us in the "Forms" module
        // This overlaps the "Task" module a fair amount, but it provides
        // an alternative paradigm for tasks
        public KanbanFormModel KanbanForms { get; private set; }
        
        /// <summary>
        /// List of Employees, along with Clock on / off status
        /// </summary>
        public InOutModel InOut { get; private set; }
        
        /// <summary>
        /// List of all available Document Set Tags
        /// </summary>
        public JobDocumentSetTagModel DocumentSetTags { get; private set; }
        
        /// <summary>
        /// List of available Delivery Barcodes
        /// </summary>
        public DeliveryItemLookupModel DeliveryItems { get; private set; }
        
        public DataModel()
        {
            Me = new EmployeeDetailModel(this,
                () => new Filter<Employee>(x => x.UserLink.ID).IsEqualTo(ClientFactory.UserGuid)
            );
            
            Employees = new EmployeeModel(this,
                () => LookupFactory.DefineFilter<Employee>());

            EmployeeTeams = new EmployeeTeamModel(this,
                () => new Filter<EmployeeTeam>(x => x.EmployeeLink.ID)
                    .InQuery(LookupFactory.DefineFilter<Employee>(), x => x.ID)
            );
            
            InOut = new InOutModel(this,
                () => LookupFactory.DefineFilter<Employee>()
                    .And(x=>x.ID).IsNotEqualTo(App.Data.Me.ID));

            Jobs = new JobModel(this, MyJobsFilter);

            JobLookups = new JobLookupModel(this,
                () => LookupFactory.DefineFilter<Job>());
            
            
            Products = new ProductModel(this,
                () => LookupFactory.DefineFilter<Product>());

            ProductGroupsLookup = new ProductGroupLookupModel(this,
                () => LookupFactory.DefineFilter<ProductGroup>());

            GPSTrackers = new GPSTrackerModel(this,
                () => LookupFactory.DefineFilter<GPSTracker>());

            Equipment = new EquipmentModel(this,
                () =>
                {
                    var filter = LookupFactory.DefineFilter<Equipment>();
                    var privfilter = new Filter<Equipment>(x => x.Private).IsEqualTo(false);
                    if (InABox.Core.Security.IsAllowed<CanViewPrivateEquipment>())
                        return filter;
                    return filter != null
                        ? filter.And(privfilter)
                        : privfilter;
                },
                "equipment.index");

            EquipmentGroups = new EquipmentGroupModel(this,
                () => LookupFactory.DefineFilter<EquipmentGroup>());

            Deliveries = new DeliveryModel(this,
                () => new Filter<Delivery>(x => x.Completed).IsEqualTo(DateTime.MinValue)
                    .Or(x => x.Completed).IsGreaterThanOrEqualTo(DateTime.Today.AddDays(-90))
            );

            DeliveryItems = new DeliveryItemLookupModel(this,
                () => LookupFactory.DefineFilter<DeliveryItem>()
            );
            
            Notifications = new NotificationModel(this, 
                () => new Filter<Notification>(x=>x.Closed).IsEqualTo(DateTime.MinValue)
                    .And(x=>x.Employee.ID).IsEqualTo(App.Data.Me.ID)
            );
            
            TimeSheets = new TimeSheetModel(this,
                () => new Filter<TimeSheet>(x=>x.Processed).IsEqualTo(DateTime.MinValue)
                    .And(x=>x.EmployeeLink.ID).IsEqualTo(App.Data.Me.ID));

            Assignments = new AssignmentModel(this,
                () => new Filter<Assignment>(x => x.Date).IsGreaterThanOrEqualTo(DateTime.Today.AddDays(-90))
                    .And(x => x.Date).IsLessThanOrEqualTo(DateTime.Today.AddDays(90))
            );
            
            Contacts = new ContactModel(this, 
                () => LookupFactory.DefineFilter<Contact>());

            Kanbans = new KanbanModel(this,
                () => new Filter<KanbanSubscriber>(x => x.Employee.ID).IsEqualTo(App.Data.Me.ID));
            
            KanbanLookups = new KanbanLookupModel(this,
                () => new Filter<Kanban>(x => x.Completed).IsEqualTo(DateTime.MinValue));

            BluetoothGates = new BluetoothGateModel(this,
                () => new Filter<JobTracker>(x => x.Active).IsEqualTo(true)
            );

            DigitalForms = new DigitalFormModel(this,
                () => new Filter<EmployeeDigitalForm>(x => x.Employee.ID).IsEqualTo(App.Data.Me.ID)
                    .And(x => x.Form.Active).IsEqualTo(true)
                    .And(x => x.Form.Secure).IsEqualTo(false)
            );

            KanbanForms = new KanbanFormModel(this,
                () => new Filter<KanbanForm>(x=>x.Parent.EmployeeLink.ID).IsEqualTo(App.Data.Me.ID)
                    .And(x=>x.FormCompleted).IsEqualTo(DateTime.MinValue)
            );

            DocumentSetTags = new JobDocumentSetTagModel(this,
                () => null
            );

        }

        private static Filter<Job> MyJobsFilter()
        {
            return InABox.Core.Security.IsAllowed<CanViewAllJobs>()
                ? new Filter<Job>(X => X.Completed).IsEqualTo(DateTime.MinValue)
                    .And(x => x.JobStatus.Active).IsEqualTo(true)
                : new Filter<Job>(X => X.Completed).IsEqualTo(DateTime.MinValue)
                    .And(x => x.JobStatus.Active).IsEqualTo(true)
                    .And(x => x.ID).InQuery(
                        new Filter<JobEmployee>(x => x.EmployeeLink.ID).IsEqualTo(App.Data.Me.ID),
                        x => x.JobLink.ID
                    );
        }

        public void Setup()
        {
            _connected = true;
            
            InABox.Core.Security.CheckTokens();
            Me.Refresh(true);
            
            Task[] _setuptasks = new Task[]
            {
                Task.Run(() => TimeSheets.Refresh(true)),
                Task.Run(() => GPSTrackers.Refresh(true)),
                Task.Run(() => BluetoothGates.Refresh(true)),
                Task.Run(() => Notifications.Refresh(true)),
                Task.Run(() => Kanbans.Refresh(true))
            };
            Task.WaitAll(_setuptasks);

            App.Bluetooth.OnScanFinished += OnBluetoothScanFinished;
            App.GPS.OnLocationFound += OnGPSLocationFound;
            
            App.Transport.OnOpen += OnTransportConnected;
            App.Transport.OnClose += OnTransportDisconnected;

            
        }

        public bool IsConnected() => _connected;

        private bool _connected;

        public event TransportDisconnectedEvent TransportDisconnected;
        
        public event TransportConnectedEvent TransportConnected;
        
        private void OnTransportDisconnected(IRpcTransport transport, RpcTransportCloseArgs e)
        {
            _connected = false;
            TransportDisconnected?.Invoke(new TransportDisconnectedEventArgs());
            Task.Run(() =>
            {
                while (!_connected)
                    App.Transport.Connect();
                var status = ClientFactory.Validate(ClientFactory.SessionID);
            });
        }

        private void OnTransportConnected(IRpcTransport transport, RpcTransportOpenArgs e)
        {
            _connected = true;
            TransportConnected?.Invoke(new TransportConnectedEventArgs());
        }

        private GPSTrackerLocation GetGPSTrackerUpdate(string deviceid, InABox.Core.Location location,
            TimeSpan threshold, double distance)
        {
            GPSTrackerShell tracker = GPSTrackers.FirstOrDefault(x => x.DeviceID.Equals(deviceid));
            if (tracker != null)
            {
                if ((tracker.Timestamp < location.Timestamp.Subtract(threshold)) || (tracker.Location.DistanceTo(location, UnitOfLength.Kilometers) > distance))
                {
                    GPSTrackerLocation gpsTrackerLocation = new GPSTrackerLocation();
                    gpsTrackerLocation.DeviceID = tracker.DeviceID;
                    gpsTrackerLocation.Tracker.ID = tracker.ID;
                    gpsTrackerLocation.Location = location; 
                    return gpsTrackerLocation;
                }
                
            }
            return null;
        }
        
        private InABox.Core.Location _lastgpslocation = new InABox.Core.Location();
        
        private void OnGPSLocationFound(LocationServices sender)
        {
            if (_lastgpslocation.Timestamp < DateTime.Now.Subtract(TimeSpan.FromMinutes(2)))
            {
                
                var devicelocation = new InABox.Core.Location()
                {
                    Latitude = App.GPS.Latitude,
                    Longitude = App.GPS.Longitude,
                    Timestamp = App.GPS.TimeStamp,
                    Address = App.GPS.Address
                };    

                GPSTrackers.Refresh(false);

                var update = GetGPSTrackerUpdate(MobileUtils.GetDeviceID(), devicelocation, TimeSpan.FromMinutes(2), 0.1);
                if (update != null)
                    new Client<GPSTrackerLocation>().Save(update, "Updated via Mobile Device", (o, e) => { });

            }
            GPSLocationUpdated?.Invoke(new GPSEventArgs());
        }
        
        private void OnBluetoothScanFinished(Bluetooth sender)
        {
            UploadTiles();
            BluetoothScanFinished?.Invoke(new BluetoothEventArgs());
        }

        private void UploadTiles()
        {
            try
            {
                if (App.GPS.Latitude.Equals(0.0F) && App.GPS.Longitude.Equals(0.0F))
                    return;

                if (App.Bluetooth.DetectedBlueToothMACAddresses.Count == 0)
                    return;

                var devicelocation = new InABox.Core.Location()
                {
                    Latitude = App.GPS.Latitude,
                    Longitude = App.GPS.Longitude,
                    Timestamp = App.GPS.TimeStamp,
                    Address = App.GPS.Address
                };

                GPSTrackers.Refresh(true);

                List<GPSTrackerLocation> updates = new List<GPSTrackerLocation>();
                foreach (String deviceid in App.Bluetooth.DetectedBlueToothMACAddresses)
                {
                    var update = GetGPSTrackerUpdate(deviceid, devicelocation, TimeSpan.FromMinutes(2), 0.1);
                    if (update != null)
                        updates.Add(update);
                }

                if (updates.Any())
                    new Client<GPSTrackerLocation>().Save(updates, $"Updated by Mobile {MobileUtils.GetDeviceID()}",
                        (o, e) => { });
            }
            catch (Exception ex)
            {
                MobileLogging.Log($"UploadTiles() {ex.Message} \n {ex.StackTrace}");
            }
        }
        
        
        public int EmployeeFormsToDo { get; set; }
        
        public int QualificationsNeedingAttention { get; set; }

        public bool UpdateHRItemsNeedingAttention()
        {
            try
            {
                EmployeeFormsToDo = 0;
                QualificationsNeedingAttention = 0;
                CoreTable table = new Client<EmployeeQualification>().Query(
                    new Filter<EmployeeQualification>(x => x.Employee.ID).IsEqualTo(Me.ID),
                    new Columns<EmployeeQualification>(
                        x => x.ID, //0
                        x => x.Expiry, //1
                        x => x.FrontPhoto.ID //2
                        )
                    );
                if (table.Rows.Any())
                {
                    List<Guid> IDs = new List<Guid>();
                    foreach (CoreRow row in table.Rows)
                    {
                        List<object> list = row.Values;
                        if (list[0] == null) { list[0] = Guid.Empty; } //0
                        if (list[1] == null) { list[1] = DateTime.MinValue; } //1
                        if (list[2] == null) { list[2] = Guid.Empty; } //2

                        if (DateTime.Parse(list[1].ToString()) <= DateTime.Today.AddDays(30))
                        {
                            if (!Guid.Parse(list[2].ToString()).Equals(Guid.Empty))
                            {
                                CoreTable innerTable = new Client<Document>().Query(
                                    new Filter<Document>(x => x.ID).IsEqualTo(Guid.Parse(list[2].ToString())),
                                    new Columns<Document>(x => x.Created)
                                    );
                                CoreRow innerRow = innerTable.Rows.First();
                                List<object> innerList = innerRow.Values;
                                if (DateTime.Parse(innerList[0].ToString()) < DateTime.Today.AddDays(-7)) //if photo was added more than 7 days ago, added to list needing attention
                                {
                                    if (!IDs.Contains(Guid.Parse(list[0].ToString())))
                                        IDs.Add(Guid.Parse(list[0].ToString()));
                                }
                            }
                            else
                            {
                                if (!IDs.Contains(Guid.Parse(list[0].ToString())))
                                    IDs.Add(Guid.Parse(list[0].ToString()));
                            }
                        }
                        if (Guid.Parse(list[2].ToString()).Equals(Guid.Empty))
                        {
                            if (!IDs.Contains(Guid.Parse(list[0].ToString())))
                                IDs.Add(Guid.Parse(list[0].ToString()));
                        }
                    }
                    QualificationsNeedingAttention = IDs.Count;
                }

                CoreTable table1 = new Client<EmployeeForm>().Query(
                    new Filter<EmployeeForm>(x => x.Parent.ID).IsEqualTo(Me.ID).And
                    (x => x.FormCompleted).IsEqualTo(DateTime.MinValue),
                    new Columns<EmployeeForm>(x => x.FormCompleted)
                    );
                if (table1.Rows.Any())
                {
                    EmployeeFormsToDo = table1.Rows.Count;
                }

                if (QualificationsNeedingAttention > 0 || EmployeeFormsToDo > 0)
                {
                    return true;
                }
                else
                    return false;
            }
            catch
            {
                return false;
            }
        }

        public void CheckEmployeeFormsToDo()
        {
            try
            {
                CoreTable table1 = new Client<EmployeeForm>().Query(
                    new Filter<EmployeeForm>(x => x.Parent.ID).IsEqualTo(Me.ID).And
                    (x => x.FormCompleted).IsEqualTo(DateTime.MinValue),
                    new Columns<EmployeeForm>(x => x.FormCompleted)
                    );
                if (table1.Rows.Any())
                {
                    EmployeeFormsToDo = table1.Rows.Count;
                }
                else
                {
                    EmployeeFormsToDo = 0;
                }
            }
            catch
            {

            }
        }


    }

}