using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.BL;
using Tango.BL.Entities;
using System.Data.Entity;
using Tango.BL.Builders;
using Tango.BL.DTO;
using Tango.BL.Enumerations;
using Tango.Core;

namespace Tango.FSE.BL.Services
{
    public class MachineConfigurationService : FSEServiceBase
    {
        public class MachineEditingComposition : ExtendedObject, IDisposable
        {
            internal MachineDTO PreviousMachineState { get; set; }

            public Machine Machine { get; set; }
            public List<Organization> Organizations { get; set; }
            public List<HardwareVersion> HardwareVersions { get; set; }
            public List<String> Tags { get; set; }
            public String TotalDyeTime { get; set; }
            public String TotalDyeMeters { get; set; }
            internal ObservablesContext Context { get; set; }

            public MachineEditingComposition()
            {
                Organizations = new List<Organization>();
                HardwareVersions = new List<HardwareVersion>();
                Tags = new List<string>();
            }

            public void ResetCounters()
            {
                TotalDyeMeters = "0 meters";
                RaisePropertyChanged(nameof(TotalDyeMeters));
                TotalDyeTime = "00:00:00";
                RaisePropertyChanged(nameof(TotalDyeTime));
            }

            public void Dispose()
            {
                Context?.Dispose();
                Context = null;
            }
        }

        public Task<MachineEditingComposition> GetMachineEditingComposition(String machineGuid)
        {
            return Task.Factory.StartNew<MachineEditingComposition>(() =>
            {
                ConnectivityProvider.ThrowIfNoInternet();

                ObservablesContext db = ObservablesContext.CreateDefault();

                MachineEditingComposition composition = new MachineEditingComposition();

                //Organizations
                bool allowAll = CurrentUser.HasPermission(Tango.BL.Enumerations.Permissions.FSE_ManageAllOrganizationsUsersAndRoles);
                composition.Organizations = db.Organizations.Where(x => allowAll || x.Guid == CurrentUser.OrganizationGuid).Include(x => x.Sites).ToList();

                //Machine
                composition.Machine = new MachineBuilder(db).Set(machineGuid).WithConfiguration().Build();

                //Hardware Versions
                composition.HardwareVersions = db.HardwareVersions.OrderByDescending(x => x.Version).ToList();

                //Tags
                composition.Tags = db.TangoVersions.Select(x => x.Tag).Where(x => x != null).Distinct().ToList();
                composition.Tags.Insert(0, string.Empty);

                //Counters
                var jobRuns = db.JobRuns.Where(x => x.MachineGuid == machineGuid).Select(x => new { StartDate=x.StartDate, x.EndDate, x.EndPosition }).ToList();
                composition.TotalDyeTime = TimeSpan.FromHours(jobRuns.Select(x => x.EndDate - x.StartDate).Sum(x => x.TotalHours)).ToStringUnlimitedHours();
                int meters = (int)jobRuns.Select(x => x.EndPosition).Sum();
                composition.TotalDyeMeters = $"{meters.ToString("N0")} meters";

                //Store current machine state for action log.
                composition.PreviousMachineState = MachineDTO.FromObservable(composition.Machine);

                composition.Context = db;

                return composition;
            });
        }

        public Task<MachineEditingComposition> SaveMachineEditingComposition(MachineEditingComposition composition)
        {
            return Task.Factory.StartNew<MachineEditingComposition>(() =>
            {
                Authentication.ThrowIfNoPermission(Permissions.FSE_RunConfigurationModule);
                ConnectivityProvider.ThrowIfNoInternet();

                composition.Machine.SetupFpga = composition.Machine.SetupFirmware; //Unify setup FPGA with setup firmware.

                try
                {
                    var machineAfterUpdateDTO = MachineDTO.FromObservable(composition.Machine);
                    ActionLogManager.InsertLog(ActionLogType.MachineSaved, CurrentUser, composition.Machine.SerialNumber, composition.PreviousMachineState, machineAfterUpdateDTO, "Machine saved via FSE.");
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error inserting machine save action log.");
                }

                composition.Context.SaveChanges();
                composition.Context.Dispose();
                return GetMachineEditingComposition(composition.Machine.Guid).Result;
            });
        }

        public Task<int> ResetCounters(String machineGuid)
        {
            return Task.Factory.StartNew<int>(() =>
            {
                Authentication.ThrowIfNoPermission(Permissions.FSE_ResetMachineCounters);

                using (ObservablesContext db = ObservablesContext.CreateDefault())
                {
                    var sn = db.Machines.SingleOrDefault(x => x.Guid == machineGuid).SerialNumber;
                    ActionLogManager.InsertLog(ActionLogType.MachineCountersReset, CurrentUser.Guid, sn, machineGuid, "Machine counters reset via FSE.");
                    return db.JobRuns.Where(x => x.MachineGuid == machineGuid).DeleteFromQuery();
                }
            });
        }
    }
}