using Application.Domain.Entities;
using Infrastructure.Events;
using IoT.Shared.Services;
using IoTNode.DeviceServices.Onvif;

namespace IoTNode.Services
{
    public class IoTNodeToServerEventHandler :
        IEventHander<EntityInsertedEvent<Product>>,
        IEventHander<EntityUpdatedEvent<Product>>,
        IEventHander<EntityDeletedEvent<Product>>,
        IEventHander<EntityInsertedEvent<Api>>,
        IEventHander<EntityUpdatedEvent<Api>>,
        IEventHander<EntityDeletedEvent<Api>>,
        IEventHander<EntityInsertedEvent<Parameter>>,
        IEventHander<EntityUpdatedEvent<Parameter>>,
        IEventHander<EntityDeletedEvent<Parameter>>,
        IEventHander<EntityUpdatedEvent<Node>>,
        IEventHander<EntityInsertedEvent<Device>>,
        IEventHander<EntityUpdatedEvent<Device>>,
        IEventHander<EntityDeletedEvent<Device>>,
        IEventHander<EntityInsertedEvent<Data>>,
        IEventHander<EntityUpdatedEvent<Data>>,
        IEventHander<EntityDeletedEvent<Data>>,
        IEventHander<EntityInsertedEvent<Command>>,
        IEventHander<EntityUpdatedEvent<Command>>,
        IEventHander<EntityDeletedEvent<Command>>,
        IEventHander<EntityInsertedEvent<Scene>>,
        IEventHander<EntityUpdatedEvent<Scene>>,
        IEventHander<EntityDeletedEvent<Scene>>,
        IEventHander<EntityInsertedEvent<SceneTimer>>,
        IEventHander<EntityUpdatedEvent<SceneTimer>>,
        IEventHander<EntityDeletedEvent<SceneTimer>>,
        IEventHander<EntityInsertedEvent<SceneTigger>>,
        IEventHander<EntityUpdatedEvent<SceneTigger>>,
        IEventHander<EntityDeletedEvent<SceneTigger>>
    {
        private readonly ISceneTiggerService _sceneTiggerService;
        private readonly OnvifService _onvifService;
        private readonly IoTNodeClient _iotNodeClient;

        public IoTNodeToServerEventHandler(ISceneTiggerService sceneTiggerService, OnvifService onvifService, IoTNodeClient iotNodeClient)
        {
            this._sceneTiggerService = sceneTiggerService;
            this._onvifService = onvifService;
            this._iotNodeClient = iotNodeClient;
        }

        private void ClientToServer<T>(BaseEvent<T> message)
        {
            if (message is EntityInsertedEvent<T> || message is EntityUpdatedEvent<T>)
            {
                _iotNodeClient.ClientToServer($"Edit{typeof(T).Name}", message.Data, null);
            }
            else if (message is EntityDeletedEvent<T>)
            {
                _iotNodeClient.ClientToServer($"Delete{typeof(T).Name}", message.Data, null);
            }
        }

        public void Handle(EntityInsertedEvent<Product> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityUpdatedEvent<Product> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityDeletedEvent<Product> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityInsertedEvent<Api> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityUpdatedEvent<Api> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityDeletedEvent<Api> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityInsertedEvent<Parameter> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityUpdatedEvent<Parameter> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityDeletedEvent<Parameter> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityUpdatedEvent<Node> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityInsertedEvent<Device> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityUpdatedEvent<Device> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityDeletedEvent<Device> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityInsertedEvent<Data> message)
        {
            if (!message.Data.Hidden)
            {
                this.ClientToServer(message);
            }
        }

        public void Handle(EntityUpdatedEvent<Data> message)
        {
            if (!message.Data.Hidden)
            {
                this.ClientToServer(message);
            }
        }

        public void Handle(EntityDeletedEvent<Data> message)
        {
            if (!message.Data.Hidden)
            {
                this.ClientToServer(message);
            }
        }

        public void Handle(EntityInsertedEvent<Command> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityUpdatedEvent<Command> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityDeletedEvent<Command> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityInsertedEvent<Scene> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityUpdatedEvent<Scene> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityDeletedEvent<Scene> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityInsertedEvent<SceneTimer> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityUpdatedEvent<SceneTimer> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityDeletedEvent<SceneTimer> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityInsertedEvent<SceneTigger> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityUpdatedEvent<SceneTigger> message)
        {
            this.ClientToServer(message);
        }

        public void Handle(EntityDeletedEvent<SceneTigger> message)
        {
            this.ClientToServer(message);
        }
    }
}