ProfileController.cs

using System.Security.Claims;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Glense.AccountService.Data;
using Glense.AccountService.DTOs;

namespace Glense.AccountService.Controllers
{
    [ApiController]
    [Route("api/profile")]
    public class ProfileController : ControllerBase
    {
        private readonly AccountDbContext _context;
        private readonly ILogger<ProfileController> _logger;

        public ProfileController(AccountDbContext context, ILogger<ProfileController> logger)
        {
            _context = context;
            _logger = logger;
        }

        private Guid GetCurrentUserId()
        {
            var userIdClaim = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
            if (!Guid.TryParse(userIdClaim, out var userId))
                throw new UnauthorizedAccessException("Invalid or missing user identity claim");
            return userId;
        }

        [HttpGet("search")]
        public async Task<IActionResult> SearchUsers([FromQuery] string? q, [FromQuery] int limit = 20)
        {
            try
            {
                var query = _context.Users.Where(u => u.IsActive);

                if (!string.IsNullOrWhiteSpace(q))
                {
                    var search = q.ToLower();
                    query = query.Where(u =>
                        u.Username.ToLower().Contains(search) ||
                        u.Email.ToLower().Contains(search));
                }

                var users = await query
                    .OrderBy(u => u.Username)
                    .Take(limit)
                    .Select(u => new UserDto
                    {
                        Id = u.Id,
                        Username = u.Username,
                        Email = u.Email,
                        ProfilePictureUrl = u.ProfilePictureUrl,
                        AccountType = u.AccountType,
                        CreatedAt = u.CreatedAt
                    })
                    .ToListAsync();

                return Ok(users);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error searching users");
                return StatusCode(500, new { message = "An error occurred" });
            }
        }

        [Authorize]
        [HttpGet("me")]
        public async Task<IActionResult> GetMyProfile()
        {
            try
            {
                var userId = GetCurrentUserId();
                var user = await _context.Users.FindAsync(userId);
                if (user == null) return NotFound();

                var dto = new UserDto
                {
                    Id = user.Id,
                    Username = user.Username,
                    Email = user.Email,
                    ProfilePictureUrl = user.ProfilePictureUrl,
                    AccountType = user.AccountType,
                    CreatedAt = user.CreatedAt
                };

                return Ok(dto);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error getting current user");
                return StatusCode(500, new { message = "An error occurred" });
            }
        }

        [HttpGet("{userId:guid}")]
        public async Task<IActionResult> GetById(Guid userId)
        {
            try
            {
                var user = await _context.Users
                    .Where(u => u.Id == userId && u.IsActive)
                    .FirstOrDefaultAsync();
                if (user == null) return NotFound();

                var dto = new UserDto
                {
                    Id = user.Id,
                    Username = user.Username,
                    Email = user.Email,
                    ProfilePictureUrl = user.ProfilePictureUrl,
                    AccountType = user.AccountType,
                    CreatedAt = user.CreatedAt
                };

                return Ok(dto);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error getting user by ID");
                return StatusCode(500, new { message = "An error occurred" });
            }
        }

        [Authorize]
        [HttpPut("me")]
        public async Task<ActionResult<UserDto>> UpdateProfile([FromBody] UpdateProfileDto updateDto)
        {
            try
            {
                var userId = GetCurrentUserId();
                var user = await _context.Users.FindAsync(userId);

                if (user == null)
                {
                    return NotFound(new { message = "User not found" });
                }

                // Update username if provided
                if (!string.IsNullOrWhiteSpace(updateDto.Username) && updateDto.Username != user.Username)
                {
                    var usernameExists = await _context.Users.AnyAsync(u => u.Username == updateDto.Username && u.Id != userId);
                    if (usernameExists)
                    {
                        return BadRequest(new { message = "Username already taken" });
                    }
                    user.Username = updateDto.Username;
                }

                // Update email if provided
                if (!string.IsNullOrWhiteSpace(updateDto.Email) && updateDto.Email != user.Email)
                {
                    var emailExists = await _context.Users.AnyAsync(u => u.Email == updateDto.Email && u.Id != userId);
                    if (emailExists)
                    {
                        return BadRequest(new { message = "Email already in use" });
                    }
                    user.Email = updateDto.Email;
                    user.IsVerified = false; // Reset verification when email changes
                }

                // Update profile picture if provided
                if (updateDto.ProfilePictureUrl != null)
                {
                    user.ProfilePictureUrl = updateDto.ProfilePictureUrl;
                }

                await _context.SaveChangesAsync();

                return Ok(new UserDto
                {
                    Id = user.Id,
                    Username = user.Username,
                    Email = user.Email,
                    ProfilePictureUrl = user.ProfilePictureUrl,
                    AccountType = user.AccountType,
                    CreatedAt = user.CreatedAt,
                    IsVerified = user.IsVerified
                });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error updating profile");
                return StatusCode(500, new { message = "An error occurred" });
            }
        }

        [Authorize]
        [HttpDelete("me")]
        public async Task<IActionResult> DeleteAccount()
        {
            try
            {
                var userId = GetCurrentUserId();
                var user = await _context.Users.FindAsync(userId);

                if (user == null)
                {
                    return NotFound(new { message = "User not found" });
                }

                // Soft delete
                user.IsActive = false;
                await _context.SaveChangesAsync();

                return Ok(new { message = "Account deactivated successfully" });
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Error deleting account");
                return StatusCode(500, new { message = "An error occurred" });
            }
        }
    }
}