using GB5Shared.DTO.Framework.Login;
using GB5Shared.Resource.Response;
using Microsoft.Extensions.Logging;
using SwDAL.CustomCode.Project;
using SwDAL.DTO.Project;
using System.Text.Json;

namespace SwBLL.Project;

public class ProjectBLL : IProjectBLL
{
    private readonly IProjectDAL         _dal;
    private readonly ILogger<ProjectBLL> _logger;

    public ProjectBLL(IProjectDAL dal, ILogger<ProjectBLL> logger)
    {
        _dal    = dal;
        _logger = logger;
    }

    public async Task<ProjectDTO?> GetById(int projectId, LoginDTO login, CancellationToken ct)
    {
        try
        {
            return await _dal.GetById(projectId, login, ct).ConfigureAwait(false);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GetById failed for ProjectId {ProjectId}", projectId);
            throw;
        }
    }

    public async Task<string> GetList(string? searchText, int pageOffset, int pageSize, LoginDTO login, CancellationToken ct)
    {
        try
        {
            var (rows, total) = await _dal.GetList(searchText, pageOffset, pageSize, login, ct).ConfigureAwait(false);
            return JsonSerializer.Serialize(new { rows, total });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GetList failed");
            throw;
        }
    }

    public async Task<string> GetSelectList(int firstNumber, int maxResult, LoginDTO login, CancellationToken ct)
    {
        try
        {
            var rows = await _dal.GetSelectList(firstNumber, maxResult, login, ct).ConfigureAwait(false);
            return JsonSerializer.Serialize(rows);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GetSelectList failed");
            throw;
        }
    }

    public async Task<string> Save(ProjectDTO dto, LoginDTO login, CancellationToken ct)
    {
        try
        {
            if (string.IsNullOrWhiteSpace(dto.ProjectName))
                throw new InvalidOperationException("Project Name is required.");

            if (dto.ProjectId == 0)
            {
                int newId = await _dal.Insert(dto, login, ct).ConfigureAwait(false);
                return $"{SuccessResponse.SaveSuccessMessage} {newId}";
            }

            await _dal.Update(dto, login, ct).ConfigureAwait(false);
            return SuccessResponse.UpdateSuccess;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Save failed for ProjectName {ProjectName}", dto.ProjectName);
            throw;
        }
    }

    public async Task<string> Delete(int projectId, LoginDTO login, CancellationToken ct)
    {
        try
        {
            await _dal.Delete(projectId, login, ct).ConfigureAwait(false);
            return SuccessResponse.DeleteSuccessMessage;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Delete failed for ProjectId {ProjectId}", projectId);
            throw;
        }
    }

    public async Task<string> GetServers(int projectId, LoginDTO login, CancellationToken ct)
    {
        try
        {
            var servers = await _dal.GetServers(projectId, login, ct).ConfigureAwait(false);
            return JsonSerializer.Serialize(servers);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GetServers failed for ProjectId {ProjectId}", projectId);
            throw;
        }
    }

    public async Task<string> AddServer(int projectId, int dbServerId, LoginDTO login, CancellationToken ct)
    {
        try
        {
            await _dal.AddServer(projectId, dbServerId, login, ct).ConfigureAwait(false);
            return SuccessResponse.UpdateSuccess;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "AddServer failed for ProjectId {ProjectId}, DbServerId {DbServerId}", projectId, dbServerId);
            throw;
        }
    }

    public async Task<string> RemoveServer(int projectId, int dbServerId, LoginDTO login, CancellationToken ct)
    {
        try
        {
            await _dal.RemoveServer(projectId, dbServerId, login, ct).ConfigureAwait(false);
            return SuccessResponse.UpdateSuccess;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "RemoveServer failed for ProjectId {ProjectId}, DbServerId {DbServerId}", projectId, dbServerId);
            throw;
        }
    }

    public async Task<string> GetManagers(int projectId, LoginDTO login, CancellationToken ct)
    {
        try
        {
            var managers = await _dal.GetManagers(projectId, login, ct).ConfigureAwait(false);
            return JsonSerializer.Serialize(managers);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "GetManagers failed for ProjectId {ProjectId}", projectId);
            throw;
        }
    }

    public async Task<string> AddManager(int projectId, int userId, LoginDTO login, CancellationToken ct)
    {
        try
        {
            await _dal.AddManager(projectId, userId, login, ct).ConfigureAwait(false);
            return SuccessResponse.UpdateSuccess;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "AddManager failed for ProjectId {ProjectId}, UserId {UserId}", projectId, userId);
            throw;
        }
    }

    public async Task<string> RemoveManager(int projectId, int userId, LoginDTO login, CancellationToken ct)
    {
        try
        {
            await _dal.RemoveManager(projectId, userId, login, ct).ConfigureAwait(false);
            return SuccessResponse.UpdateSuccess;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "RemoveManager failed for ProjectId {ProjectId}, UserId {UserId}", projectId, userId);
            throw;
        }
    }
}