using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Manager.Interfaces.DTO;
using Manager.Interfaces.Models;
using Manager.Services;
using ManagerService.Service.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Mqtt.Client.AspNetCore.Services;
using Newtonsoft.Json;
using NSwag.Annotations;

namespace ManagerService.Controllers
{
    [Authorize] // TODO Add ROLES (Roles = "Admin")
    [ApiController, Route("api/[controller]")]
    [OpenApiTag("Device", Description = "Device management")]
    public class DeviceController : ControllerBase
    {
        private DeviceDatabaseService _deviceService;
        private ConfigurationDatabaseService _configurationService;
        private readonly ILogger<DeviceController> _logger;

        public DeviceController(ILogger<DeviceController> logger, DeviceDatabaseService deviceService, ConfigurationDatabaseService configurationService)
        {
            _logger = logger;
            _deviceService = deviceService;
            _configurationService = configurationService;
        }

        /// <summary>
        /// Get a list of all devices
        /// </summary>
        [ProducesResponseType(typeof(List<DeviceDTO>), 200)]
        [ProducesResponseType(typeof(string), 500)]
        [HttpGet]
        public ObjectResult Get()
        {
            try
            {
                List<Device> devices = _deviceService.GetAll();

                return new OkObjectResult(devices.Select(d => d.ToDTO()));
            }
            catch (Exception ex)
            {
                return new ObjectResult(ex.Message) { StatusCode = 500 };
            }
        }


        /// <summary>
        /// Get a specific device 
        /// </summary>
        /// <param name="id">id device</param>  
        [AllowAnonymous]
        [ProducesResponseType(typeof(DeviceDetailDTO), 200)]
        [ProducesResponseType(typeof(string), 404)]
        [ProducesResponseType(typeof(string), 500)]
        [HttpGet("{id}/detail")]
        public ObjectResult GetDetail(string id)
        {
            try
            {
                Device device = _deviceService.GetById(id);

                if (device == null)
                    throw new KeyNotFoundException("This device was not found");

                return new OkObjectResult(device.ToDetailDTO());
            }
            catch (KeyNotFoundException ex)
            {
                return new NotFoundObjectResult(ex.Message) { };
            }
            catch (Exception ex)
            {
                return new ObjectResult(ex.Message) { StatusCode = 500 };
            }
        }

        /// <summary>
        /// Create a new device
        /// </summary>
        /// <param name="newDevice">New device info</param>  
        [AllowAnonymous]
        [ProducesResponseType(typeof(DeviceDetailDTO), 200)]
        [ProducesResponseType(typeof(string), 400)]
        [ProducesResponseType(typeof(string), 404)]
        [ProducesResponseType(typeof(string), 409)]
        [ProducesResponseType(typeof(string), 500)]
        [HttpPost]
        public ObjectResult Create([FromBody] DeviceDetailDTO newDevice)
        {
            try
            {
                if (newDevice == null)
                    throw new ArgumentNullException("Device param is null");

                var configuration = _configurationService.GetById(newDevice.configurationId);

                if (configuration == null)
                    throw new KeyNotFoundException("Configuration does not exist");

                Device device = new Device();
                if (_deviceService.IsExistIdentifier(newDevice.identifier))
                {
                    // Update info
                    device = _deviceService.GetByIdentifier(newDevice.identifier);
                    device.DateUpdate = DateTime.Now;
                }
                else {
                    // Creation
                    device.Identifier = newDevice.identifier;
                    device.DateCreation = DateTime.Now;
                }

                device.Name = newDevice.name;
                device.Configuration = configuration.Label;
                device.ConfigurationId = newDevice.configurationId;
                device.IpAddressETH = newDevice.ipAddressETH;
                device.IpAddressWLAN = newDevice.ipAddressWLAN;
                device.Connected = newDevice.connected;
                device.ConnectionLevel = newDevice.connectionLevel;
                device.LastConnectionLevel = newDevice.lastConnectionLevel;
                device.BatteryLevel = newDevice.batteryLevel;
                device.LastBatteryLevel = newDevice.lastBatteryLevel;

                Device deviceCreated = _deviceService.IsExistIdentifier(newDevice.identifier) ? _deviceService.Update(device.Id, device) : _deviceService.Create(device);

                return new OkObjectResult(deviceCreated.ToDTO());
            }
            catch (ArgumentNullException ex)
            {
                return new BadRequestObjectResult(ex.Message) { };
            }
            catch (KeyNotFoundException ex)
            {
                return new NotFoundObjectResult(ex.Message) { };
            }
            catch (InvalidOperationException ex)
            {
                return new ConflictObjectResult(ex.Message) { };
            }
            catch (Exception ex)
            {
                return new ObjectResult(ex.Message) { StatusCode = 500 };
            }
        }


        /// <summary>
        /// Update a device
        /// </summary>
        /// <param name="updatedDevice">Device to update</param>  
        [ProducesResponseType(typeof(DeviceDetailDTO), 200)]
        [ProducesResponseType(typeof(string), 400)]
        [ProducesResponseType(typeof(string), 404)]
        [ProducesResponseType(typeof(string), 500)]
        [HttpPut]
        public ObjectResult Update([FromBody] DeviceDetailDTO updatedDevice)
        {
            try
            {
                if (updatedDevice == null)
                    throw new ArgumentNullException("Device param is null");

                Device device = _deviceService.GetById(updatedDevice.id);

                if (device == null)
                    throw new KeyNotFoundException("Device does not exist");

                // Todo add some verification ? 
                device.Name = updatedDevice.name;
                device.Identifier = updatedDevice.identifier;
                device.IpAddressWLAN = updatedDevice.ipAddressWLAN;
                device.IpAddressETH = updatedDevice.ipAddressETH;
                device.Connected = updatedDevice.connected;
                device.ConnectionLevel = updatedDevice.connectionLevel;
                device.LastConnectionLevel = updatedDevice.lastConnectionLevel;
                device.BatteryLevel = updatedDevice.batteryLevel;
                device.LastBatteryLevel = updatedDevice.lastBatteryLevel;

                Device deviceModified = _deviceService.Update(updatedDevice.id, device);

                return new OkObjectResult(deviceModified.ToDTO());
            }
            catch (ArgumentNullException ex)
            {
                return new BadRequestObjectResult(ex.Message) { };
            }
            catch (KeyNotFoundException ex)
            {
                return new NotFoundObjectResult(ex.Message) { };
            }
            catch (Exception ex)
            {
                return new ObjectResult(ex.Message) { StatusCode = 500 };
            }
        }

        /// <summary>
        /// Update device main info
        /// </summary>
        /// <param name="updatedDevice">Device to update</param>  
        [ProducesResponseType(typeof(DeviceDTO), 200)]
        [ProducesResponseType(typeof(string), 400)]
        [ProducesResponseType(typeof(string), 404)]
        [ProducesResponseType(typeof(string), 500)]
        [HttpPut("mainInfos")]
        public ObjectResult UpdateMainInfos([FromBody] DeviceDTO deviceIn)
        {
            try
            {
                if (deviceIn == null)
                    throw new ArgumentNullException("Device param is null");

                Device device = _deviceService.GetById(deviceIn.id);

                if (device == null)
                    throw new KeyNotFoundException("Device does not exist");

                var configuration = _configurationService.GetById(deviceIn.configurationId);

                if (configuration == null)
                    throw new KeyNotFoundException("Configuration does not exist");

                // Todo add some verification ? 
                device.Name = deviceIn.name;
                device.Connected = deviceIn.connected;
                device.Configuration = configuration.Label;
                device.ConfigurationId = deviceIn.configurationId;

                Device deviceModified = _deviceService.Update(device.Id, device);

                // TODO MqttClientService.PublishMessage($"player/{device.Id}", JsonConvert.SerializeObject(new PlayerMessageDTO() { configChanged = true }));

                return new OkObjectResult(deviceModified.ToDTO());
            }
            catch (ArgumentNullException ex)
            {
                return new BadRequestObjectResult(ex.Message) { };
            }
            catch (KeyNotFoundException ex)
            {
                return new NotFoundObjectResult(ex.Message) { };
            }
            catch (Exception ex)
            {
                return new ObjectResult(ex.Message) { StatusCode = 500 };
            }
        }


        /// <summary>
        /// Delete a device
        /// </summary>
        /// <param name="id">Id of device to delete</param>  
        [ProducesResponseType(typeof(string), 202)]
        [ProducesResponseType(typeof(string), 400)]
        [ProducesResponseType(typeof(string), 404)]
        [ProducesResponseType(typeof(string), 500)]
        [HttpDelete("{id}")]
        public ObjectResult Delete(string id)
        {
            try
            {
                if (id == null)
                    throw new ArgumentNullException("Device param is null");

                if (!_deviceService.IsExist(id))
                    throw new KeyNotFoundException("Device does not exist");

                _deviceService.Remove(id);

                return new ObjectResult("The device has been deleted") { StatusCode = 202 };

            }
            catch (ArgumentNullException ex)
            {
                return new BadRequestObjectResult(ex.Message) { };
            }
            catch (KeyNotFoundException ex)
            {
                return new NotFoundObjectResult(ex.Message) { };
            }
            catch (Exception ex)
            {
                return new ObjectResult(ex.Message) { StatusCode = 500 };
            }
        }
    }
}