using Microsoft.AspNetCore.Mvc;
using FinControl.Domain.Repositories;
using FinControl.Contracts.Responses;
using FinControl.Domain.Entities;
using FinControl.Domain.Enums;
using FinControl.Contracts.Requests;

namespace FinControl.API.Controllers;

[ApiController]
[Route("api/[controller]")]
public class AccountsController : ControllerBase
{
    private readonly IAccountRepository _accountRepository;
    private readonly IUserRepository _userRepository;

    public AccountsController(IAccountRepository accountRepository, IUserRepository userRepository)
    {
        _accountRepository = accountRepository;
        _userRepository = userRepository;
    }

    [HttpGet("user/{userId}")]
    public async Task<ActionResult<List<AccountResponse>>> GetByUserId(Guid userId)
    {
        var accounts = await _accountRepository.GetByUserIdAsync(userId);
        var response = accounts.Select(a => new AccountResponse
        {
            Id = a.Id,
            Name = a.Name,
            Type = (int)a.Type,
            InitialBalance = a.InitialBalance,
            CurrentBalance = a.CurrentBalance,
            Institution = a.Institution,
            CreatedAt = a.CreatedAt
        }).ToList();

        return Ok(response);
    }

    [HttpGet("{id}")]
    public async Task<ActionResult<AccountResponse>> GetById(Guid id)
    {
        var account = await _accountRepository.GetByIdAsync(id);
        if (account == null)
            return NotFound();

        var response = new AccountResponse
        {
            Id = account.Id,
            Name = account.Name,
            Type = (int)account.Type,
            InitialBalance = account.InitialBalance,
            CurrentBalance = account.CurrentBalance,
            Institution = account.Institution,
            CreatedAt = account.CreatedAt
        };

        return Ok(response);
    }

    [HttpPost]
    public async Task<ActionResult<AccountResponse>> Create([FromBody] CreateAccountRequest request, [FromQuery] Guid userId)
    {
        var user = await _userRepository.GetByIdAsync(userId);
        if (user == null)
            return BadRequest("User not found");

        var account = new Account
        {
            UserId = userId,
            Name = request.Name,
            Type = (AccountType)request.Type,
            InitialBalance = request.InitialBalance,
            CurrentBalance = request.InitialBalance,
            Institution = request.Institution
        };

        await _accountRepository.AddAsync(account);

        var response = new AccountResponse
        {
            Id = account.Id,
            Name = account.Name,
            Type = (int)account.Type,
            InitialBalance = account.InitialBalance,
            CurrentBalance = account.CurrentBalance,
            Institution = account.Institution,
            CreatedAt = account.CreatedAt
        };

        return CreatedAtAction(nameof(GetById), new { id = account.Id }, response);
    }

    [HttpPut("{id}")]
    public async Task<IActionResult> Update(Guid id, [FromBody] CreateAccountRequest request)
    {
        var account = await _accountRepository.GetByIdAsync(id);
        if (account == null)
            return NotFound();

        account.Name = request.Name;
        account.Type = (AccountType)request.Type;
        account.Institution = request.Institution;
        account.UpdatedAt = DateTime.UtcNow;

        await _accountRepository.UpdateAsync(account);
        return NoContent();
    }

    [HttpDelete("{id}")]
    public async Task<IActionResult> Delete(Guid id)
    {
        var account = await _accountRepository.GetByIdAsync(id);
        if (account == null)
            return NotFound();

        await _accountRepository.DeleteAsync(id);
        return NoContent();
    }
}