using Microsoft.AspNetCore.Mvc;
using WIDESEAWCS_S7Simulator.Application.Protocol;
using WIDESEAWCS_S7Simulator.Core.Entities;
using WIDESEAWCS_S7Simulator.Core.Interfaces;

namespace WIDESEAWCS_S7Simulator.Server.Controllers
{
    /// <summary>
    /// 仿真器实例管理控制器
    /// </summary>
    [ApiController]
    [Route("api/[controller]")]
    public class SimulatorInstancesController : ControllerBase
    {
        private readonly ISimulatorInstanceManager _instanceManager;
        private readonly IProtocolTemplateService _protocolTemplateService;
        private readonly ILogger<SimulatorInstancesController> _logger;

        public SimulatorInstancesController(
            ISimulatorInstanceManager instanceManager,
            IProtocolTemplateService protocolTemplateService,
            ILogger<SimulatorInstancesController> logger)
        {
            _instanceManager = instanceManager ?? throw new ArgumentNullException(nameof(instanceManager));
            _protocolTemplateService = protocolTemplateService ?? throw new ArgumentNullException(nameof(protocolTemplateService));
            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        }

        /// <summary>
        /// 获取所有实例列表
        /// </summary>
        [HttpGet("GetAll")]
        [ProducesResponseType(typeof(IEnumerable<object>), StatusCodes.Status200OK)]
        public ActionResult GetAllInstances()
        {
            try
            {
                var instances = _instanceManager.GetAllInstances();
                var result = instances.Select(i => new
                {
                    instanceId = i.Config.Id,
                    name = i.Config.Name,
                    plcType = i.Config.PLCType.ToString(),
                    port = i.Config.Port,
                    status = i.GetState().Status.ToString(),
                    clientCount = i.GetState().ClientCount,
                    totalRequests = i.GetState().TotalRequests,
                    startTime = i.GetState().StartTime,
                    lastActivityTime = i.GetState().LastActivityTime,
                    errorMessage = i.GetState().ErrorMessage
                }).ToList();
                return Ok(result);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to get all instances");
                return StatusCode(StatusCodes.Status500InternalServerError, new { error = "Failed to retrieve instances" });
            }
        }

        /// <summary>
        /// 创建新实例
        /// </summary>
        [HttpPost("Create")]
        [ProducesResponseType(typeof(object), StatusCodes.Status201Created)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        public async Task<ActionResult> CreateInstance([FromBody] InstanceConfig config)
        {
            try
            {
                if (config == null)
                {
                    return BadRequest(new { error = "Instance configuration is required" });
                }

                if (string.IsNullOrWhiteSpace(config.Id))
                {
                    return BadRequest(new { error = "Instance ID is required" });
                }

                if (string.IsNullOrWhiteSpace(config.Name))
                {
                    return BadRequest(new { error = "Instance name is required" });
                }

                if (_instanceManager.InstanceExists(config.Id))
                {
                    return Conflict(new { error = $"Instance with ID '{config.Id}' already exists" });
                }

                if (config.Port <= 0 || config.Port > 65535)
                {
                    return BadRequest(new { error = "Port must be between 1 and 65535" });
                }

                NormalizeMemoryConfig(config);

                if (string.IsNullOrWhiteSpace(config.ProtocolTemplateId))
                {
                    return BadRequest(new { error = "Protocol template is required" });
                }

                if (!await _protocolTemplateService.ExistsAsync(config.ProtocolTemplateId))
                {
                    return BadRequest(new { error = $"Protocol template '{config.ProtocolTemplateId}' not found" });
                }

                var instance = await _instanceManager.CreateInstanceAsync(config);
                var state = instance.GetState();
                var result = new
                {
                    instanceId = instance.Config.Id,
                    name = instance.Config.Name,
                    plcType = instance.Config.PLCType.ToString(),
                    port = instance.Config.Port,
                    status = state.Status.ToString(),
                    clientCount = state.ClientCount,
                    totalRequests = state.TotalRequests,
                    startTime = state.StartTime,
                    lastActivityTime = state.LastActivityTime,
                    errorMessage = state.ErrorMessage
                };

                return CreatedAtAction(
                    nameof(GetInstance),
                    new { id = config.Id },
                    result);
            }
            catch (ArgumentException ex)
            {
                _logger.LogWarning(ex, "Invalid instance configuration");
                return BadRequest(new { error = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to create instance");
                return StatusCode(StatusCodes.Status500InternalServerError, new { error = "Failed to create instance" });
            }
        }

        /// <summary>
        /// 获取指定实例详情
        /// </summary>
        [HttpGet("GetInstance")]
        [ProducesResponseType(typeof(object), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public ActionResult GetInstance(string id)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(id))
                {
                    return BadRequest(new { error = "Instance ID is required" });
                }

                var instance = _instanceManager.GetInstance(id);
                if (instance == null)
                {
                    return NotFound(new { error = $"Instance with ID '{id}' not found" });
                }

                var state = instance.GetState();
                var result = new
                {
                    instanceId = instance.Config.Id,
                    name = instance.Config.Name,
                    plcType = instance.Config.PLCType.ToString(),
                    port = instance.Config.Port,
                    status = state.Status.ToString(),
                    clientCount = state.ClientCount,
                    totalRequests = state.TotalRequests,
                    startTime = state.StartTime,
                    lastActivityTime = state.LastActivityTime,
                    errorMessage = state.ErrorMessage
                };
                return Ok(result);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to get instance {InstanceId}", id);
                return StatusCode(StatusCodes.Status500InternalServerError, new { error = "Failed to retrieve instance" });
            }
        }

        /// <summary>
        /// 获取指定实例的配置
        /// </summary>
        [HttpGet("GetInstanceConfig")]
        [ProducesResponseType(typeof(InstanceConfig), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public ActionResult<InstanceConfig> GetInstanceConfig(string id)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(id))
                {
                    return BadRequest(new { error = "Instance ID is required" });
                }

                var instance = _instanceManager.GetInstance(id);
                if (instance == null)
                {
                    return NotFound(new { error = $"Instance with ID '{id}' not found" });
                }

                return Ok(instance.Config);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to get instance config {InstanceId}", id);
                return StatusCode(StatusCodes.Status500InternalServerError, new { error = "Failed to retrieve instance config" });
            }
        }

        /// <summary>
        /// 更新实例配置
        /// </summary>
        [HttpPut("Update")]
        [ProducesResponseType(typeof(object), StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public async Task<ActionResult> UpdateInstance([FromQuery] string id, [FromBody] InstanceConfig config)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(id))
                {
                    return BadRequest(new { error = "Instance ID is required" });
                }

                if (config == null)
                {
                    return BadRequest(new { error = "Instance configuration is required" });
                }

                var instance = _instanceManager.GetInstance(id);
                if (instance == null)
                {
                    return NotFound(new { error = $"Instance with ID '{id}' not found" });
                }

                // Validate port if changed
                if (config.Port <= 0 || config.Port > 65535)
                {
                    return BadRequest(new { error = "Port must be between 1 and 65535" });
                }

                NormalizeMemoryConfig(config);

                if (string.IsNullOrWhiteSpace(config.ProtocolTemplateId))
                {
                    return BadRequest(new { error = "Protocol template is required" });
                }

                if (!await _protocolTemplateService.ExistsAsync(config.ProtocolTemplateId))
                {
                    return BadRequest(new { error = $"Protocol template '{config.ProtocolTemplateId}' not found" });
                }

                // Delete existing instance and recreate with new config
                // Note: This is a simplified approach. In production, you might want to support hot-reload
                bool wasRunning = instance.GetState().Status == Core.Enums.InstanceStatus.Running;
                await _instanceManager.DeleteInstanceAsync(id, deleteConfig: false);

                config.Id = id; // Ensure ID matches route parameter
                var newInstance = await _instanceManager.CreateInstanceAsync(config);

                if (wasRunning)
                {
                    await _instanceManager.StartInstanceAsync(id);
                }

                var state = newInstance.GetState();
                var result = new
                {
                    instanceId = newInstance.Config.Id,
                    name = newInstance.Config.Name,
                    plcType = newInstance.Config.PLCType.ToString(),
                    port = newInstance.Config.Port,
                    status = state.Status.ToString(),
                    clientCount = state.ClientCount,
                    totalRequests = state.TotalRequests,
                    startTime = state.StartTime,
                    lastActivityTime = state.LastActivityTime,
                    errorMessage = state.ErrorMessage
                };
                return Ok(result);
            }
            catch (ArgumentException ex)
            {
                _logger.LogWarning(ex, "Invalid instance configuration");
                return BadRequest(new { error = ex.Message });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to update instance {InstanceId}", id);
                return StatusCode(StatusCodes.Status500InternalServerError, new { error = "Failed to update instance" });
            }
        }

        /// <summary>
        /// 删除实例
        /// </summary>
        [HttpDelete("Delete")]
        [ProducesResponseType(StatusCodes.Status204NoContent)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public async Task<IActionResult> DeleteInstance(string id, bool deleteConfig = true)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(id))
                {
                    return BadRequest(new { error = "Instance ID is required" });
                }

                if (!_instanceManager.InstanceExists(id))
                {
                    return NotFound(new { error = $"Instance with ID '{id}' not found" });
                }

                await _instanceManager.DeleteInstanceAsync(id, deleteConfig);
                return NoContent();
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to delete instance {InstanceId}", id);
                return StatusCode(StatusCodes.Status500InternalServerError, new { error = "Failed to delete instance" });
            }
        }

        /// <summary>
        /// 启动实例
        /// </summary>
        [HttpPost("start")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        public async Task<ActionResult> StartInstance([FromQuery] string id)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(id))
                {
                    return BadRequest(new { error = "Instance ID is required" });
                }

                if (!_instanceManager.InstanceExists(id))
                {
                    return NotFound(new { error = $"Instance with ID '{id}' not found" });
                }

                bool success = await _instanceManager.StartInstanceAsync(id);
                if (!success)
                {
                    return BadRequest(new { error = "Failed to start instance" });
                }

                var instance = _instanceManager.GetInstance(id);
                var state = instance?.GetState();
                var result = new
                {
                    instanceId = instance.Config.Id,
                    name = instance.Config.Name,
                    plcType = instance.Config.PLCType.ToString(),
                    port = instance.Config.Port,
                    status = state.Status.ToString(),
                    clientCount = state.ClientCount,
                    totalRequests = state.TotalRequests,
                    startTime = state.StartTime,
                    lastActivityTime = state.LastActivityTime,
                    errorMessage = state.ErrorMessage
                };
                return Ok(result);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to start instance {InstanceId}", id);
                return StatusCode(StatusCodes.Status500InternalServerError, new { error = "Failed to start instance" });
            }
        }

        /// <summary>
        /// 停止实例
        /// </summary>
        [HttpPost("stop")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        public async Task<ActionResult> StopInstance([FromQuery] string id)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(id))
                {
                    return BadRequest(new { error = "Instance ID is required" });
                }

                if (!_instanceManager.InstanceExists(id))
                {
                    return NotFound(new { error = $"Instance with ID '{id}' not found" });
                }

                await _instanceManager.StopInstanceAsync(id);

                var instance = _instanceManager.GetInstance(id);
                var state = instance?.GetState();
                var result = new
                {
                    instanceId = instance.Config.Id,
                    name = instance.Config.Name,
                    plcType = instance.Config.PLCType.ToString(),
                    port = instance.Config.Port,
                    status = state.Status.ToString(),
                    clientCount = state.ClientCount,
                    totalRequests = state.TotalRequests,
                    startTime = state.StartTime,
                    lastActivityTime = state.LastActivityTime,
                    errorMessage = state.ErrorMessage
                };
                return Ok(result);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to stop instance {InstanceId}", id);
                return StatusCode(StatusCodes.Status500InternalServerError, new { error = "Failed to stop instance" });
            }
        }

        /// <summary>
        /// 重启实例
        /// </summary>
        [HttpPost("restart")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        [ProducesResponseType(StatusCodes.Status404NotFound)]
        [ProducesResponseType(StatusCodes.Status400BadRequest)]
        public async Task<ActionResult> RestartInstance([FromQuery] string id)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(id))
                {
                    return BadRequest(new { error = "Instance ID is required" });
                }

                if (!_instanceManager.InstanceExists(id))
                {
                    return NotFound(new { error = $"Instance with ID '{id}' not found" });
                }

                bool success = await _instanceManager.RestartInstanceAsync(id);
                if (!success)
                {
                    return BadRequest(new { error = "Failed to restart instance" });
                }

                var instance = _instanceManager.GetInstance(id);
                var state = instance?.GetState();
                var result = new
                {
                    instanceId = instance.Config.Id,
                    name = instance.Config.Name,
                    plcType = instance.Config.PLCType.ToString(),
                    port = instance.Config.Port,
                    status = state.Status.ToString(),
                    clientCount = state.ClientCount,
                    totalRequests = state.TotalRequests,
                    startTime = state.StartTime,
                    lastActivityTime = state.LastActivityTime,
                    errorMessage = state.ErrorMessage
                };
                return Ok(result);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to restart instance {InstanceId}", id);
                return StatusCode(StatusCodes.Status500InternalServerError, new { error = "Failed to restart instance" });
            }
        }

        /// <summary>
        /// 启动所有自动启动实例
        /// </summary>
        [HttpPost("start-all")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        public async Task<ActionResult> StartAllAutoStartInstances()
        {
            try
            {
                await _instanceManager.LoadSavedInstancesAsync(autoStart: true);
                return Ok(new {
                    message = "Started all auto-start instances",
                    runningCount = _instanceManager.GetRunningInstanceCount()
                });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to start all instances");
                return StatusCode(StatusCodes.Status500InternalServerError, new { error = "Failed to start instances" });
            }
        }

        /// <summary>
        /// 停止所有实例
        /// </summary>
        [HttpPost("stop-all")]
        [ProducesResponseType(StatusCodes.Status200OK)]
        public async Task<ActionResult> StopAllInstances()
        {
            try
            {
                await _instanceManager.StopAllInstancesAsync();
                return Ok(new {
                    message = "Stopped all instances",
                    runningCount = _instanceManager.GetRunningInstanceCount()
                });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to stop all instances");
                return StatusCode(StatusCodes.Status500InternalServerError, new { error = "Failed to stop instances" });
            }
        }

        /// <summary>
        /// 规范化并校验内存配置，优先使用显式 DB 块列表。
        /// </summary>
        private static void NormalizeMemoryConfig(InstanceConfig config)
        {
            if (config.MemoryConfig == null)
            {
                config.MemoryConfig = new MemoryRegionConfig();
            }

            var dbBlockNumbers = (config.MemoryConfig.DBBlockNumbers ?? new List<int>())
                .Where(x => x > 0)
                .Distinct()
                .OrderBy(x => x)
                .ToList();

            if (dbBlockNumbers.Count == 0)
            {
                var count = config.MemoryConfig.DBBlockCount > 0 ? config.MemoryConfig.DBBlockCount : 1;
                dbBlockNumbers = Enumerable.Range(1, count).ToList();
            }

            config.MemoryConfig.DBBlockNumbers = dbBlockNumbers;
            config.MemoryConfig.DBBlockCount = dbBlockNumbers.Count;
            config.MemoryConfig.DBBlockSize = config.MemoryConfig.DBBlockSize > 0 ? config.MemoryConfig.DBBlockSize : 1024;
        }
    }
}