using System;
using System.Linq;
using System.Threading.Tasks;
using Comal.Classes;
using InABox.Clients;
using InABox.Core;

namespace comal.timesheets
{

    public delegate void DataChangedEvent(object sender, Type t);
    public delegate void DataRefreshedEvent();

    public class DataModel
    {
        public event DataRefreshedEvent DataRefreshed;

        public event DataChangedEvent DataChanged;

        public Employee Employee { get; private set; }

        public CoreTable TimeSheets { get; set; }

        public CoreTable Gates { get; private set; }

        public CoreTable Jobs { get; private set; }

        public bool CanBypassGates { get; private set; }

        public DataModel()
        {
        }

        public void Refresh(bool canbypassgates = true)
        {
            CanBypassGates = canbypassgates;

            RefreshTimeSheet();
            RefreshEmployee();
            RefreshJobs(canbypassgates);
        }

        private void RefreshTimeSheet()
        {
            Task.Run(() =>
            {
                try
                {
                    CoreTable table = new Client<TimeSheet>().Query(
                        new Filter<TimeSheet>(x => x.EmployeeLink.UserLink.ID).IsEqualTo(ClientFactory.UserGuid)
                            .And(x => x.Date).IsEqualTo(DateTime.Today)
                            .And(x => x.Finish).IsEqualTo(new TimeSpan()),
                        new Columns<TimeSheet>(
                            x => x.ID,
                            x => x.Date,
                            x => x.Start,
                            x => x.Notes,
                            x => x.JobLink.ID,
                            x => x.JobLink.JobNumber,
                            x => x.JobLink.Name,
                            x => x.ActivityLink.ID,
                            x => x.ActivityLink.Code,
                            x => x.ActivityLink.Description,
                            x => x.StartLocation.Latitude,
                            x => x.StartLocation.Longitude,
                            x => x.StartLocation.Timestamp,
                            x => x.EmployeeLink.ID)
                        );
                    TimeSheets = table;
                    DataChanged?.Invoke(this, typeof(TimeSheet));
                    DataRefreshed?.Invoke();
                }
                catch (Exception ex)
                {
                    var log = new MobileLogging(LogType.Query, "Data model RefreshTimeSheet()", ex.Message + ex.StackTrace, this.GetType().Name);
                }
            });
        }

        private void RefreshEmployee()
        {
            Task.Run(() =>
            {
                try
                {
                    CoreTable table = new Client<Employee>().Query(
                            new Filter<Employee>(x => x.UserLink.ID).IsEqualTo(ClientFactory.UserGuid),
                            new Columns<Employee>(
                                x => x.ID,
                                x => x.Name
                            ));
                    if (table.Rows.Any())
                    {
                        Employee = table?.Rows.FirstOrDefault()?.ToObject<Employee>();
                        DataChanged?.Invoke(this, typeof(Employee));
                        DataRefreshed?.Invoke();
                    }
                }
                catch (Exception ex)
                {
                    var log = new MobileLogging(LogType.Query, "Data model RefreshEmployee()", ex.Message + ex.StackTrace, this.GetType().Name);
                }
            });
        }

        private void RefreshJobs(bool canbypassgates)
        {
            Task.Run(() =>
            {
                try
                {
                    if (canbypassgates)
                    {
                        CoreTable table = new Client<Job>().Query(
                                new Filter<Job>(X => X.Completed).IsEqualTo(DateTime.MinValue).And(x => x.JobStatus.Active).IsEqualTo(true),
                                new Columns<Job>(
                                    X => X.ID,
                                    X => X.JobNumber,
                                    X => X.Name,
                                    X => X.SiteAddress.Location.Latitude,
                                    X => X.SiteAddress.Location.Longitude),
                                new SortOrder<Job>(x => x.JobNumber));
                        if (table.Rows.Any())
                        {
                            Jobs = table;
                            DataChanged?.Invoke(this, typeof(Job));
                            DataRefreshed?.Invoke();
                        }
                    }
                    else
                    {
                        CoreTable table = new Client<JobTracker>().Query(
                                new Filter<JobTracker>(x => x.Active).IsEqualTo(true),
                                new Columns<JobTracker>(
                                    x => x.JobLink.ID,
                                    x => x.JobLink.JobNumber,
                                    x => x.JobLink.Name,
                                    x => x.TrackerLink.DeviceID,
                                    x => x.Gate,
                                    x => x.IsJobSite
                                ));
                        if (table.Rows.Any())
                        {
                            Gates = table;
                            //DataChanged?.Invoke(this, typeof(JobTracker), e);
                            DataRefreshed?.Invoke();
                        }
                    }
                }
                catch (Exception ex)
                {
                    var log = new MobileLogging(LogType.Query, "Data model RefreshJobs()", ex.Message + ex.StackTrace, this.GetType().Name);
                }
            });
        }
    }

}