using iyixiGames.Domain.DTOs.Sites; // 使用 Application 层定义的 DTOs
using iyixiGames.Application.Services;   // 引入应用服务接口
using Microsoft.AspNetCore.Mvc;          // 引入 MVC 控制器和相关特性
using System.Collections.Generic;        // 引入集合类型
using System.Threading.Tasks;            // 引入异步编程
using Microsoft.Extensions.Logging;      // 引入日志
using System;
using iyixiGames.Infrastructure.Services; // 引入异常类型
using Microsoft.AspNetCore.Authorization; // 引入授权特性

namespace iyixiGames.Web.Controllers
{
    // 重要：移除 [ApiController] 特性，因为它会启用仅适用于 Web API 的行为。
    // 如果一个控制器既处理 MVC 视图又处理 API 请求，通常不使用 [ApiController]。
    // 继承自 Controller，这是 MVC 控制器的标准基类。
    [Authorize] // 将授权应用到整个控制器，确保只有登录用户才能访问。
                // 如果需要更细粒度的控制，可以在具体 Action 上使用 [Authorize] 或 [AllowAnonymous]。
    public class SitesController : Controller // 从 ControllerBase 更改为 Controller
    {
        private readonly ISiteService _siteService;
        private readonly ILogger<SitesController> _logger;

        public SitesController(ISiteService siteService, ILogger<SitesController> logger)
        {
            _siteService = siteService;
            _logger = logger;
        }

        // -----------------------------------------------------
        // 以下是 **MVC 视图相关** 的 Action 方法
        // 它们通常返回 IActionResult (View(), RedirectToAction())
        // -----------------------------------------------------

        /// <summary>
        /// MVC 视图：显示所有网站的列表。
        /// GET: /Sites 或 /Sites/Index
        /// </summary>
        [HttpGet]
        [Route("Sites")] // 明确指定 MVC 路由，或依赖默认的 MapControllerRoute
        [Route("Sites/Index")]
        public async Task<IActionResult> Index()
        {
            _logger.LogInformation("MVC：用户请求访问网站管理列表。");
            var sites = await _siteService.GetAllSitesAsync();
            return View(sites); // 返回视图并传递数据
        }

        /// <summary>
        /// MVC 视图：显示单个网站的详细信息。
        /// GET: /Sites/Details/{id}
        /// </summary>
        [HttpGet("Sites/Details/{id}")] // 明确指定 MVC 路由
        public async Task<IActionResult> Details(string id)
        {
            if (string.IsNullOrEmpty(id))
            {
                _logger.LogWarning("MVC：请求网站详情但ID为空。");
                return NotFound(); // 返回 404 Not Found 状态码
            }

            var site = await _siteService.GetSiteByIdAsync(id);
            if (site == null)
            {
                _logger.LogWarning("MVC：请求网站详情，但未找到网站 ID: {SiteId}", id);
                return NotFound(); // 返回 404 Not Found 状态码
            }
            return View(site); // 返回视图并传递数据
        }

        /// <summary>
        /// MVC 视图：显示创建新网站的表单。
        /// GET: /Sites/Create
        /// </summary>
        [HttpGet("Sites/Create")] // 明确指定 MVC 路由
        public IActionResult Create()
        {
            return View(); // 返回空表单视图
        }

        /// <summary>
        /// MVC 视图：处理创建新网站的表单提交。
        /// POST: /Sites/Create
        /// </summary>
        [HttpPost("Sites/Create")] // 明确指定 MVC 路由
        [ValidateAntiForgeryToken] // 防止 CSRF 攻击
        public async Task<IActionResult> Create([FromForm] CreateSiteRequest request) // 从表单绑定数据
        {
            _logger.LogInformation("MVC：接收到创建网站的提交请求，名称: {SiteName}", request.Name);
            if (ModelState.IsValid)
            {
                try
                {
                    var newSite = await _siteService.CreateSiteAsync(request);
                    _logger.LogInformation("MVC：网站 '{SiteName}' (ID: {SiteId}) 创建成功，重定向到详情页。", newSite.Name, newSite.Id);
                    return RedirectToAction(nameof(Details), new { id = newSite.Id }); // 重定向到详情页
                }
                catch (InvalidOperationException ex)
                {
                    ModelState.AddModelError(string.Empty, ex.Message); // 将业务逻辑错误添加到模型状态，View 会显示
                    _logger.LogError(ex, "MVC：创建网站时发生业务逻辑错误：{ErrorMessage}", ex.Message);
                }
                catch (Exception ex)
                {
                    ModelState.AddModelError(string.Empty, "创建网站时发生未知错误。");
                    _logger.LogError(ex, "MVC：创建网站时发生服务器内部错误。");
                }
            }
            else
            {
                _logger.LogWarning("MVC：创建网站失败：模型验证不通过。");
            }
            // 如果模型无效或发生错误，返回视图并显示错误信息
            return View(request);
        }

        /// <summary>
        /// MVC 视图：显示编辑网站信息的表单，预填充现有数据。
        /// GET: /Sites/Edit/{id}
        /// </summary>
        [HttpGet("Sites/Edit/{id}")] // 明确指定 MVC 路由
        public async Task<IActionResult> Edit(string id)
        {
            if (string.IsNullOrEmpty(id))
            {
                _logger.LogWarning("MVC：请求编辑网站但ID为空。");
                return NotFound();
            }

            var site = await _siteService.GetSiteByIdAsync(id);
            if (site == null)
            {
                _logger.LogWarning("MVC：请求编辑网站，但未找到网站 ID: {SiteId}", id);
                return NotFound();
            }

            // 将 SiteResponse 映射到 UpdateSiteRequest 以填充表单
            // 注意：对于嵌套对象如 Seo 和 Settings，需要手动创建 DTO 实例
            // 更复杂的映射可以使用 AutoMapper 库
            var updateRequest = new UpdateSiteRequest
            {
                Name = site.Name,
                Domain = site.Domain,
                OwnerUserId = site.OwnerUserId,
                Seo = site.Seo != null ? new SiteSeoDTO { Description = site.Seo.Description, Keywords = site.Seo.Keywords } : null,
                Settings = site.Settings != null ? new SiteSettingsDTO { Theme = site.Settings.Theme, Language = site.Settings.Language, AdEnabled = site.Settings.AdEnabled } : null,
                // 对于 TeamMembers，通常在编辑页面会使用更复杂的 JavaScript 来处理动态添加/删除成员
                // 这里为了简化，不将 TeamMembers 填充到 UpdateSiteRequest 中，View 端也不会显示其编辑表单
            };

            ViewBag.SiteId = id; // 将ID传递给View，用于表单提交，如果 UpdateSiteRequest 不包含ID
            ViewBag.SiteName = site.Name; // 将网站名称传递给View，用于页面标题
            return View(updateRequest);
        }

        /// <summary>
        /// MVC 视图：处理编辑网站信息的表单提交。
        /// POST: /Sites/Edit/{id}
        /// </summary>
        [HttpPost("Sites/Edit/{id}")] // 明确指定 MVC 路由
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> Edit(string id, [FromForm] UpdateSiteRequest request) // 从表单绑定数据
        {
            _logger.LogInformation("MVC：接收到更新网站 ID: {SiteId} 的提交请求。", id);
            if (string.IsNullOrEmpty(id))
            {
                _logger.LogWarning("MVC：更新网站时ID为空。");
                return NotFound();
            }

            if (ModelState.IsValid)
            {
                try
                {
                    var updatedSite = await _siteService.UpdateSiteAsync(id, request);
                    if (updatedSite == null)
                    {
                        _logger.LogWarning("MVC：更新网站失败：未找到网站 ID: {SiteId}。", id);
                        return NotFound();
                    }
                    _logger.LogInformation("MVC：网站 '{SiteId}' 更新成功，重定向到详情页。", id);
                    return RedirectToAction(nameof(Details), new { id = id });
                }
                catch (InvalidOperationException ex)
                {
                    ModelState.AddModelError(string.Empty, ex.Message);
                    _logger.LogError(ex, "MVC：更新网站时发生业务逻辑错误：{ErrorMessage}", ex.Message);
                }
                catch (Exception ex)
                {
                    ModelState.AddModelError(string.Empty, "更新网站时发生未知错误。");
                    _logger.LogError(ex, "MVC：更新网站时发生服务器内部错误。");
                }
            }
            else
            {
                _logger.LogWarning("MVC：更新网站失败：模型验证不通过。");
            }
            ViewBag.SiteId = id; // 重新传递 ID 和名称，以防视图需要
            ViewBag.SiteName = request.Name ?? "未知网站";
            return View(request);
        }

        /// <summary>
        /// MVC 视图：显示删除确认页。
        /// GET: /Sites/Delete/{id}
        /// </summary>
        [HttpGet("Sites/Delete/{id}")] // 明确指定 MVC 路由
        public async Task<IActionResult> Delete(string id)
        {
            if (string.IsNullOrEmpty(id))
            {
                _logger.LogWarning("MVC：请求删除网站但ID为空。");
                return NotFound();
            }

            var site = await _siteService.GetSiteByIdAsync(id);
            if (site == null)
            {
                _logger.LogWarning("MVC：请求删除网站，但未找到网站 ID: {SiteId}", id);
                return NotFound();
            }
            return View(site); // 返回视图并传递数据
        }

        /// <summary>
        /// MVC 视图：处理删除网站的 POST 请求。
        /// POST: /Sites/Delete/{id}
        /// </summary>
        [HttpPost("Sites/Delete/{id}")] // 明确指定 MVC 路由
        [ActionName("Delete")] // 允许 POST 请求到 /Sites/Delete/{id}，但内部方法名为 DeleteConfirmed
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> DeleteConfirmed(string id)
        {
            _logger.LogInformation("MVC：接收到确认删除网站 ID: {SiteId} 的请求。", id);
            if (string.IsNullOrEmpty(id))
            {
                _logger.LogWarning("MVC：确认删除网站时ID为空。");
                return NotFound();
            }

            var deleted = await _siteService.DeleteSiteAsync(id);
            if (!deleted)
            {
                _logger.LogWarning("MVC：删除网站失败：未找到网站 ID: {SiteId}。", id);
                // 即使 service 返回 false，也可以重定向回 Index 或显示错误
                return NotFound();
            }
            _logger.LogInformation("MVC：网站 '{SiteId}' 成功删除，重定向到列表页。", id);
            return RedirectToAction(nameof(Index)); // 重定向到列表页
        }

        // -----------------------------------------------------
        // 以下是 **Web API 相关** 的 Action 方法
        // 它们通常返回 ActionResult<T> 或 ActionResult
        // 并带有 [Route("api/sites")] 作为基路由
        // -----------------------------------------------------

        /// <summary>
        /// API：获取所有网站列表。
        /// GET: /api/sites
        /// </summary>
        [HttpGet] // 继承 [Route("api/sites")]
        [ProducesResponseType(typeof(IEnumerable<SiteResponse>), 200)]
        public async Task<ActionResult<IEnumerable<SiteResponse>>> GetApiAllSites() // 重命名以避免冲突
        {
            _logger.LogInformation("API：接收到获取所有网站的请求。");
            var sites = await _siteService.GetAllSitesAsync();
            return Ok(sites);
        }

        /// <summary>
        /// API：根据ID获取单个网站详情。
        /// GET: /api/sites/{id}
        /// </summary>
        [HttpGet("{id}")] // 继承 [Route("api/sites")]
        [ProducesResponseType(typeof(SiteResponse), 200)]
        [ProducesResponseType(404)]
        public async Task<ActionResult<SiteResponse>> GetApiSiteById(string id) // 重命名以避免冲突
        {
            _logger.LogInformation("API：接收到获取网站 ID: {SiteId} 的请求。", id);
            var site = await _siteService.GetSiteByIdAsync(id);
            if (site == null)
            {
                _logger.LogWarning("API：获取网站失败：未找到网站 ID: {SiteId}。", id);
                return NotFound();
            }
            return Ok(site);
        }

        /// <summary>
        /// API：创建新网站。
        /// POST: /api/sites
        /// </summary>
        [HttpPost] // 继承 [Route("api/sites")]
        [ProducesResponseType(typeof(SiteResponse), 201)]
        [ProducesResponseType(400)]
        [ProducesResponseType(409)] // Conflict for domain exists
        public async Task<ActionResult<SiteResponse>> CreateApiSite([FromBody] CreateSiteRequest request) // 重命名以避免冲突
        {
            _logger.LogInformation("API：接收到创建新网站的请求，名称: {SiteName}", request.Name);
            // 对于 API，ModelState.IsValid 的处理通常通过 [ApiController] 自动进行，
            // 但因为我们移除了 [ApiController]，所以需要手动检查。
            if (!ModelState.IsValid)
            {
                _logger.LogWarning("API：创建网站失败：模型验证不通过。");
                return BadRequest(ModelState);
            }

            try
            {
                var newSite = await _siteService.CreateSiteAsync(request);
                return CreatedAtAction(nameof(GetApiSiteById), new { id = newSite.Id }, newSite);
            }
            catch (InvalidOperationException ex)
            {
                _logger.LogError(ex, "API：创建网站失败：{ErrorMessage}", ex.Message);
                return Conflict(new { message = ex.Message }); // 返回409冲突
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "API：创建网站时发生服务器内部错误。");
                return StatusCode(500, "内部服务器错误。");
            }
        }

        /// <summary>
        /// API：更新网站信息。
        /// PUT: /api/sites/{id}
        /// </summary>
        [HttpPut("{id}")] // 继承 [Route("api/sites")]
        [ProducesResponseType(typeof(SiteResponse), 200)]
        [ProducesResponseType(400)]
        [ProducesResponseType(404)]
        [ProducesResponseType(409)] // Conflict for domain exists
        public async Task<ActionResult<SiteResponse>> UpdateApiSite(string id, [FromBody] UpdateSiteRequest request) // 重命名以避免冲突
        {
            _logger.LogInformation("API：接收到更新网站 ID: {SiteId} 的请求。", id);
            if (!ModelState.IsValid)
            {
                _logger.LogWarning("API：更新网站失败：模型验证不通过。");
                return BadRequest(ModelState);
            }

            try
            {
                var updatedSite = await _siteService.UpdateSiteAsync(id, request);
                if (updatedSite == null)
                {
                    _logger.LogWarning("API：更新网站失败：未找到网站 ID: {SiteId}。", id);
                    return NotFound();
                }
                return Ok(updatedSite);
            }
            catch (InvalidOperationException ex)
            {
                _logger.LogError(ex, "API：更新网站失败：{ErrorMessage}", ex.Message);
                return Conflict(new { message = ex.Message }); // 返回409冲突
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "API：更新网站时发生服务器内部错误。");
                return StatusCode(500, "内部服务器错误。");
            }
        }

        /// <summary>
        /// API：更新网站状态。
        /// PATCH: /api/sites/{id}/status
        /// </summary>
        [HttpPatch("{id}/status")] // 继承 [Route("api/sites")]
        [ProducesResponseType(typeof(SiteResponse), 200)]
        [ProducesResponseType(400)]
        [ProducesResponseType(404)]
        public async Task<ActionResult<SiteResponse>> UpdateApiSiteStatus(string id, [FromBody] UpdateSiteStatusRequest request) // 重命名以避免冲突
        {
            _logger.LogInformation("API：接收到更新网站 ID: {SiteId} 状态的请求，新状态: {NewStatus}", id, request.Status);
            if (!ModelState.IsValid)
            {
                _logger.LogWarning("API：更新网站状态失败：模型验证不通过。");
                return BadRequest(ModelState);
            }

            var updatedSite = await _siteService.UpdateSiteStatusAsync(id, request);
            if (updatedSite == null)
            {
                _logger.LogWarning("API：更新网站状态失败：未找到网站 ID: {SiteId}。", id);
                return NotFound();
            }
            return Ok(updatedSite);
        }

        /// <summary>
        /// API：删除网站。
        /// DELETE: /api/sites/{id}
        /// </summary>
        [HttpDelete("{id}")] // 继承 [Route("api/sites")]
        [ProducesResponseType(204)] // No Content
        [ProducesResponseType(404)]
        public async Task<ActionResult> DeleteApiSite(string id) // 重命名以避免冲突
        {
            _logger.LogInformation("API：接收到删除网站 ID: {SiteId} 的请求。", id);
            var deleted = await _siteService.DeleteSiteAsync(id);
            if (!deleted)
            {
                _logger.LogWarning("API：删除网站失败：未找到网站 ID: {SiteId}。", id);
                return NotFound();
            }
            return NoContent(); // 删除成功，返回204 No Content
        }
    }
}