Login Service

// Memory Session Storage (static)
private static readonly ConcurrentDictionary<Guid, User> _loginSessions 
    = new ConcurrentDictionary<Guid, User>();

// Login 처리
public async Task<IActionResult> Login([FromBody] LoginDto dto)
{
    // 1. 사용자 인증
    var user = await _userRepository.GetByUserNameAsync(dto.id);
    if (user == null || user.Password != dto.password)
        return Unauthorized("Invalid credentials");
    
    // 2. 중복 로그인 체크 (메모리에서 즉시 확인)
    var alreadyLoggedIn = _loginSessions.Values
        .Any(u => u.Username == dto.id);
    
    if (alreadyLoggedIn)
        return Conflict("Already logged in from another device");
    
    // 3. 세션 생성
    var sessionId = Guid.NewGuid();
    _loginSessions.TryAdd(sessionId, user);
    
    // 4. JWT 토큰 생성
    var jwt = JwtUtils.Generate(
        user.Id.ToString(),
        sessionId.ToString(),
        TimeSpan.FromHours(1)
    );
    
    return Ok(new { jwt, userId = user.Id, nickname = user.Nickname });
}

// Logout 처리
public IActionResult Logout([FromHeader] string sessionId)
{
    if (Guid.TryParse(sessionId, out var guid))
    {
        _loginSessions.TryRemove(guid, out _);
        return Ok();
    }
    return BadRequest();
}

public static string Generate(string userId, string sessionId, TimeSpan lifetime)
{
    var securityKey = new SymmetricSecurityKey(
        Encoding.UTF8.GetBytes(_secretKey)
    );
    var credentials = new SigningCredentials(
        securityKey, 
        SecurityAlgorithms.HmacSha256
    );
    
    var claims = new[]
    {
        new Claim(JwtRegisteredClaimNames.Sub, userId),
        new Claim("session_id", sessionId),
        new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
    };
    
    var token = new JwtSecurityToken(
        issuer: "LoginService",
        audience: "UnityClient",
        claims: claims,
        expires: DateTime.UtcNow.Add(lifetime),
        signingCredentials: credentials
    );
    
    return new JwtSecurityTokenHandler().WriteToken(token);
}

public static ClaimsPrincipal? Validate(string token)
{
    var tokenHandler = new JwtSecurityTokenHandler();
    var key = Encoding.UTF8.GetBytes(_secretKey);
    
    try
    {
        var principal = tokenHandler.ValidateToken(token, new TokenValidationParameters
        {
            ValidateIssuerSigningKey = true,
            IssuerSigningKey = new SymmetricSecurityKey(key),
            ValidateIssuer = true,
            ValidIssuer = "LoginService",
            ValidateAudience = true,
            ValidAudience = "UnityClient",
            ValidateLifetime = true,
            ClockSkew = TimeSpan.FromMinutes(5) // 시간 오차 허용
        }, out var validatedToken);
        
        return principal;
    }
    catch
    {
        return null;
    }
}

// User Entity
public class User
{
    public Guid Id { get; set; }
    public string Username { get; set; } = string.Empty;
    public string Password { get; set; } = string.Empty;
    public string? Nickname { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime? LastConnected { get; set; }
    public int SkinIndex { get; set; }
}

// DbContext Configuration
protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<User>(entity =>
    {
        entity.HasKey(e => e.Id);
        entity.Property(e => e.Username).IsRequired();
        entity.Property(e => e.Password).IsRequired();
        entity.Property(e => e.Nickname).HasMaxLength(12);
        entity.Property(e => e.CreatedAt)
              .HasDefaultValueSql("CURRENT_TIMESTAMP");
        
        // Unique Indexes
        entity.HasIndex(e => e.Username).IsUnique();
        entity.HasIndex(e => e.Nickname).IsUnique();
    });
}