using DigitalData.Modules.Logging;
using ECM.JobRunner.Common.JobRunnerReference;

namespace ECM.JobRunner.Web.Data
{
    public class JobService
    {
        private readonly Logger logger;
        private readonly IEDMIServiceChannel channel;

        public JobService(LoggingService Logging, WcfService Wcf) 
        {
            logger = Logging.LogConfig.GetLogger();
            channel = Wcf.Channel;
        }

        public async Task<List<JobDefinition>> GetJobs()
        {
            var resp = await channel.GetJobConfigAsync();

            if (resp == null) return new();
            if (resp.OK == false) return new();

            return resp.JobDefinitions.ToList();
        }

        public async Task<List<ObjectType>> GetObjectTypes()
        {
            var resp = await channel.GetJobConfigAsync();

            if (resp == null) return new();
            if (resp.OK == false) return new();

            return resp.WindreamObjectTypes.ToList();
        }

        public async Task<List<JobType>> GetJobTypes()
        {
            var resp = await channel.GetJobConfigAsync();

            if (resp == null) return new();
            if (resp.OK == false) return new();

            return resp.JobTypes.ToList();
        }

        public async Task<JobDefinition?> GetJob(int pJobId)
        {
            var resp = await channel.GetJobConfigAsync();

            if (resp == null) return null;
            if (resp.OK == false) return null;

            return resp.JobDefinitions.
                    Where(j => j.Id == pJobId).
                    FirstOrDefault();
        }

        public async Task<bool> UpdateJob(JobDefinition job)
        {
            var resp = await channel.UpdateJobAsync(new UpdateJobUpdateJobRequest { 
                Job = job, 
                Action = UpdateJobUpdateJobRequest.UpdateJobAction.Update 
            });

            if (resp == null) return false;
            if (resp.OK == false) return false;
            return true;
    
        }

        public async Task<bool> CreateJob(JobDefinition job)
        {
            var resp = await channel.UpdateJobAsync(new UpdateJobUpdateJobRequest
            {
                Job = job,
                Action = UpdateJobUpdateJobRequest.UpdateJobAction.Create
            });

            if (resp != null && resp.OK)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public async Task<bool> DeleteJob(JobDefinition job)
        {
            var resp = await channel.UpdateJobAsync(new UpdateJobUpdateJobRequest
            {
                Job = job,
                Action = UpdateJobUpdateJobRequest.UpdateJobAction.Delete
            });

            if (resp != null && resp.OK)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public DateTime GetNextExecutionTime(string pCronExpression)
        {
            Quartz.CronExpression expression = new(pCronExpression);

            if (expression != null)
            {
                var next = expression.GetNextValidTimeAfter(DateTimeOffset.Now);

                if (next != null)
                {
                    return ((DateTimeOffset)next).DateTime;
                }
                else
                {
                    return DateTime.MinValue;
                }
            }
            else
            {
                return DateTime.MinValue;
            }
        }
    }
}