namespace FinControl.Web.Services;

using System.Net.Http.Json;

public class FinControlApiService
{
    private readonly HttpClient _httpClient;
    private readonly ILocalStorageService _localStorage;
    private const string BaseUrl = "http://localhost:5000/api";

    public FinControlApiService(HttpClient httpClient, ILocalStorageService localStorage)
    {
        _httpClient = httpClient;
        _localStorage = localStorage;
    }

    // Auth
    public async Task<LoginResponse?> LoginAsync(string email, string password)
    {
        try
        {
            var response = await _httpClient.PostAsJsonAsync(
                $"{BaseUrl}/login",
                new { email, password });

            if (response.IsSuccessStatusCode)
            {
                return await response.Content.ReadFromJsonAsync<LoginResponse>();
            }
            return null;
        }
        catch
        {
            return null;
        }
    }

    public async Task<LoginResponse?> RegisterAsync(string name, string email, string password)
    {
        try
        {
            var response = await _httpClient.PostAsJsonAsync(
                $"{BaseUrl}/login/register",
                new { name, email, password });

            if (response.IsSuccessStatusCode)
            {
                return await response.Content.ReadFromJsonAsync<LoginResponse>();
            }
            return null;
        }
        catch
        {
            return null;
        }
    }

    // Health Check
    public async Task<(bool Success, string Message)> CheckHealthAsync()
    {
        try
        {
            var response = await _httpClient.GetAsync($"{BaseUrl}/health");
            return (response.IsSuccessStatusCode, response.IsSuccessStatusCode ? "API Online" : "API Offline");
        }
        catch (Exception ex)
        {
            return (false, $"Erro: {ex.Message}");
        }
    }

    // Accounts
    public async Task<List<AccountResponse>> GetAccountsByUserAsync(Guid userId)
    {
        try
        {
            await AddAuthHeaderAsync();
            var response = await _httpClient.GetFromJsonAsync<List<AccountResponse>>(
                $"{BaseUrl}/accounts/user/{userId}");
            return response ?? new List<AccountResponse>();
        }
        catch
        {
            return new List<AccountResponse>();
        }
    }

    public async Task<AccountResponse?> GetAccountAsync(Guid id)
    {
        try
        {
            return await _httpClient.GetFromJsonAsync<AccountResponse>($"{BaseUrl}/accounts/{id}");
        }
        catch
        {
            return null;
        }
    }

    public async Task<AccountResponse?> CreateAccountAsync(Guid userId, CreateAccountRequest request)
    {
        try
        {
            var response = await _httpClient.PostAsJsonAsync(
                $"{BaseUrl}/accounts?userId={userId}", request);

            if (response.IsSuccessStatusCode)
                return await response.Content.ReadFromJsonAsync<AccountResponse>();

            return null;
        }
        catch
        {
            return null;
        }
    }

    public async Task<bool> UpdateAccountAsync(Guid id, CreateAccountRequest request)
    {
        try
        {
            var response = await _httpClient.PutAsJsonAsync(
                $"{BaseUrl}/accounts/{id}", request);
            return response.IsSuccessStatusCode;
        }
        catch
        {
            return false;
        }
    }

    public async Task<bool> DeleteAccountAsync(Guid id)
    {
        try
        {
            var response = await _httpClient.DeleteAsync($"{BaseUrl}/accounts/{id}");
            return response.IsSuccessStatusCode;
        }
        catch
        {
            return false;
        }
    }

    // Transactions
    public async Task<List<TransactionResponse>> GetTransactionsByAccountAsync(Guid accountId)
    {
        try
        {
            var response = await _httpClient.GetFromJsonAsync<List<TransactionResponse>>(
                $"{BaseUrl}/transactions/account/{accountId}");
            return response ?? new List<TransactionResponse>();
        }
        catch
        {
            return new List<TransactionResponse>();
        }
    }

    public async Task<List<TransactionResponse>> GetTransactionsByUserAsync(Guid userId)
    {
        try
        {
            var response = await _httpClient.GetFromJsonAsync<List<TransactionResponse>>(
                $"{BaseUrl}/transactions/user/{userId}");
            return response ?? new List<TransactionResponse>();
        }
        catch
        {
            return new List<TransactionResponse>();
        }
    }

    public async Task<TransactionResponse?> CreateTransactionAsync(CreateTransactionRequest request)
    {
        try
        {
            var response = await _httpClient.PostAsJsonAsync($"{BaseUrl}/transactions", request);
            if (response.IsSuccessStatusCode)
                return await response.Content.ReadFromJsonAsync<TransactionResponse>();
            return null;
        }
        catch
        {
            return null;
        }
    }

    public async Task<bool> DeleteTransactionAsync(Guid id)
    {
        try
        {
            var response = await _httpClient.DeleteAsync($"{BaseUrl}/transactions/{id}");
            return response.IsSuccessStatusCode;
        }
        catch
        {
            return false;
        }
    }

    private async Task AddAuthHeaderAsync()
    {
        var token = await _localStorage.GetItemAsync("token");
        if (!string.IsNullOrEmpty(token))
        {
            _httpClient.DefaultRequestHeaders.Authorization =
                new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", token);
        }
    }
}

public class AccountResponse
{
    public Guid Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public int Type { get; set; }
    public decimal InitialBalance { get; set; }
    public decimal CurrentBalance { get; set; }
    public string? Institution { get; set; }
    public DateTime CreatedAt { get; set; }

    public string TypeName => Type switch
    {
        0 => "Conta Corrente",
        1 => "Conta Poupança",
        2 => "Carteira",
        3 => "Investimentos",
        _ => "Desconhecido"
    };
}

public class CreateAccountRequest
{
    public string Name { get; set; } = string.Empty;
    public int Type { get; set; }
    public decimal InitialBalance { get; set; }
    public string? Institution { get; set; }
}

public class CreateTransactionRequest
{
    public Guid AccountId { get; set; }
    public Guid CategoryId { get; set; }
    public decimal Amount { get; set; }
    public int Type { get; set; }
    public string Description { get; set; } = string.Empty;
    public DateTime Date { get; set; }
}

public class TransactionResponse
{
    public Guid Id { get; set; }
    public Guid AccountId { get; set; }
    public Guid CategoryId { get; set; }
    public decimal Amount { get; set; }
    public int Type { get; set; }
    public string TypeName { get; set; } = string.Empty;
    public string Description { get; set; } = string.Empty;
    public DateTime Date { get; set; }
    public DateTime CreatedAt { get; set; }
}