using Application.Domain.Entities;
using Application.Models;
using Infrastructure.Application.Services.Settings;
using Infrastructure.Data;
using Infrastructure.Events;
using Infrastructure.Extensions;
using IoT.Shared.Services;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System;
using System.Diagnostics;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;

namespace IoTNode.DeviceServices
{
    public class BaseDeviceService : IHostedService
    {
        internal readonly IServiceProvider _applicationServices;

        public BaseDeviceService(IServiceProvider applicationServices)
        {
            this._applicationServices = applicationServices;
        }

        protected string GetSetting(string name)
        {
            using var scope = _applicationServices.CreateScope();
            return scope.ServiceProvider.GetRequiredService<ISettingService>().GetSetting(name).Value;
        }

        public virtual Task StartAsync(CancellationToken cancellationToken)
        {
            Task.Run(async () =>
            {
                while (!cancellationToken.IsCancellationRequested)
                {
                    try
                    {
                        Execute();
                    }
                    catch (Exception ex)
                    {
                        ex.PrintStack();
                    }
                    await Task.Delay(Convert.ToInt32(GetSetting("timer.seconds")) * 1000).ConfigureAwait(true);
                }
            });
            return Task.CompletedTask;
        }

        public virtual void Execute()
        {
        }

        public virtual Task StopAsync(CancellationToken cancellationToken)
        {
            return Task.CompletedTask;
        }

        public void SendToServer(string method, object data)
        {
            Debug.WriteLine("send device to server");
            using var scope = _applicationServices.CreateScope();
            var iotNodeClient = scope.ServiceProvider.GetService<IoTNodeClient>();
            iotNodeClient.ClientToServer(method, data, null);
        }

        public void SendDataToServer(Data data)
        {
            using var scope = _applicationServices.CreateScope();
            var iotNodeClient = scope.ServiceProvider.GetService<IoTNodeClient>();
            iotNodeClient.ClientToServer($"Edit{typeof(Data).Name}", data.To<EditDataModel>(), null);
        }

        public void UpdateDevice(IRepository<Device> repo, Device device)
        {
            if (repo.SaveChanges() > 0)
            {
                this.SendToServer(Methods.EditDevice, device.To<EditDeviceModel>());
            }
        }

        public void UpdateData(IRepository<Device> repo, Device device, Data data)
        {
            var data2 = device.AddorUpdateData(data);
            if (repo.SaveChanges() > 0 && !data2.Hidden)
            {
                this.SendDataToServer(data2);
            }
        }

        public Product UpdateProduct(string productName, string productNumber, string path, string categoryNumber, string productIcon)
        {
            var scope = _applicationServices.CreateScope();

            var categoryRepo = scope.ServiceProvider.GetService<IRepository<Category>>();
            var productRepo = scope.ServiceProvider.GetService<IRepository<Product>>();
            var product = productRepo.ReadOnlyTable().FirstOrDefault(o => o.Number == productNumber);
            if (product == null)
            {
                product = new Product
                {
                    Id = $"productid-{productNumber}".ToGuid(),
                    Number = productNumber,
                    Name = productName,
                    Path = path,
                    Image = $"/images/{productIcon}.png",
                    CategoryId = categoryRepo.ReadOnlyTable().FirstOrDefault(o => o.Number == categoryNumber).Id
                };
                if (!string.IsNullOrEmpty(path))
                {
                    var iotNodeClient = scope.ServiceProvider.GetService<IoTNodeClient>();
                    product.ApiJson = iotNodeClient.GetApiJson(path);
                }
                OpenApiService.UpdateApi(product);
                productRepo.Add(product);
                productRepo.SaveChanges();
                this.SendToServer(Methods.UpdateProductResponse, product);
            }
            return product;
        }
    }
}