using Fengling.Console.Models.Dtos;
using Fengling.Console.Services;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;

namespace Fengling.Console.Controllers;

[ApiController]
[Route("api/[controller]")]
[Authorize]
public class TenantsController : ControllerBase
{
    private readonly ITenantService _tenantService;
    private readonly ILogger<TenantsController> _logger;

    public TenantsController(ITenantService tenantService, ILogger<TenantsController> logger)
    {
        _tenantService = tenantService;
        _logger = logger;
    }

    [HttpGet]
    public async Task<ActionResult<object>> GetTenants(
        [FromQuery] int page = 1,
        [FromQuery] int pageSize = 10,
        [FromQuery] string? name = null,
        [FromQuery] string? tenantId = null,
        [FromQuery] string? status = null)
    {
        try
        {
            var (items, totalCount) = await _tenantService.GetTenantsAsync(page, pageSize, name, tenantId, status);
            return Ok(new { items, totalCount, page, pageSize });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error getting tenants");
            return StatusCode(500, new { message = ex.Message });
        }
    }

    [HttpGet("{id}")]
    public async Task<ActionResult<TenantDto>> GetTenant(long id)
    {
        try
        {
            var tenant = await _tenantService.GetTenantAsync(id);
            if (tenant == null)
            {
                return NotFound();
            }
            return Ok(tenant);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error getting tenant {TenantId}", id);
            return StatusCode(500, new { message = ex.Message });
        }
    }

    [HttpGet("{tenantId}/users")]
    public async Task<ActionResult<IEnumerable<UserDto>>> GetTenantUsers(long tenantId)
    {
        try
        {
            var users = await _tenantService.GetTenantUsersAsync(tenantId);
            return Ok(users);
        }
        catch (KeyNotFoundException ex)
        {
            _logger.LogWarning(ex, "Tenant not found: {TenantId}", tenantId);
            return NotFound();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error getting users for tenant {TenantId}", tenantId);
            return StatusCode(500, new { message = ex.Message });
        }
    }

    [HttpGet("{tenantId}/roles")]
    public async Task<ActionResult<IEnumerable<object>>> GetTenantRoles(long tenantId)
    {
        try
        {
            var roles = await _tenantService.GetTenantRolesAsync(tenantId);
            return Ok(roles);
        }
        catch (KeyNotFoundException ex)
        {
            _logger.LogWarning(ex, "Tenant not found: {TenantId}", tenantId);
            return NotFound();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error getting roles for tenant {TenantId}", tenantId);
            return StatusCode(500, new { message = ex.Message });
        }
    }

    [HttpGet("{tenantId}/settings")]
    public async Task<ActionResult<TenantSettingsDto>> GetTenantSettings(string tenantId)
    {
        try
        {
            var settings = await _tenantService.GetTenantSettingsAsync(tenantId);
            return Ok(settings);
        }
        catch (KeyNotFoundException ex)
        {
            _logger.LogWarning(ex, "Tenant not found: {TenantId}", tenantId);
            return NotFound();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error getting settings for tenant {TenantId}", tenantId);
            return StatusCode(500, new { message = ex.Message });
        }
    }

    [HttpPut("{tenantId}/settings")]
    public async Task<IActionResult> UpdateTenantSettings(string tenantId, [FromBody] TenantSettingsDto settings)
    {
        try
        {
            await _tenantService.UpdateTenantSettingsAsync(tenantId, settings);
            return NoContent();
        }
        catch (KeyNotFoundException ex)
        {
            _logger.LogWarning(ex, "Tenant not found: {TenantId}", tenantId);
            return NotFound();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error updating settings for tenant {TenantId}", tenantId);
            return StatusCode(500, new { message = ex.Message });
        }
    }

    [HttpPost]
    public async Task<ActionResult<TenantDto>> CreateTenant([FromBody] CreateTenantDto dto)
    {
        try
        {
            var tenant = await _tenantService.CreateTenantAsync(dto);
            return CreatedAtAction(nameof(GetTenant), new { id = tenant.Id }, tenant);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error creating tenant");
            return StatusCode(500, new { message = ex.Message });
        }
    }

    [HttpPut("{id}")]
    public async Task<IActionResult> UpdateTenant(long id, [FromBody] UpdateTenantDto dto)
    {
        try
        {
            await _tenantService.UpdateTenantAsync(id, dto);
            return NoContent();
        }
        catch (KeyNotFoundException ex)
        {
            _logger.LogWarning(ex, "Tenant not found: {TenantId}", id);
            return NotFound();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error updating tenant {TenantId}", id);
            return StatusCode(500, new { message = ex.Message });
        }
    }

    [HttpDelete("{id}")]
    public async Task<IActionResult> DeleteTenant(long id)
    {
        try
        {
            await _tenantService.DeleteTenantAsync(id);
            return NoContent();
        }
        catch (KeyNotFoundException ex)
        {
            _logger.LogWarning(ex, "Tenant not found: {TenantId}", id);
            return NotFound();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Error deleting tenant {TenantId}", id);
            return StatusCode(500, new { message = ex.Message });
        }
    }
}