using Sonex.Data.Database;

namespace Sonex.Data.Records;

public sealed class GroupRecord
{
    private string _originalName = string.Empty;

    public int Id { get; set; }
    public string Name
    {
        get => _name;
        set
        {
            _name = value ?? string.Empty;
            if (string.IsNullOrWhiteSpace(_originalName))
                _originalName = _name;
        }
    }
    private string _name = string.Empty;

    public string Description { get; set; } = string.Empty;
    public string DisplayName
    {
        get
        {
            var text = Name.Replace("group_", string.Empty, StringComparison.OrdinalIgnoreCase).Replace('_', ' ').Trim();
            return string.IsNullOrEmpty(text)
                ? string.Empty
                : char.ToUpperInvariant(text[0]) + text[1..];
        }
    }
    public string[] GrantedPermission { get; set; } = [];

    public static async Task<DB.SingleResult<GroupRecord>> Get(string name)
    {
        var result = await DB.QuerySingleAsync<GroupRecord>(
            "SELECT * FROM sonex.v_group_permissions WHERE name = @group_Name LIMIT 1;",
            new { group_Name = name }).ConfigureAwait(false);

        result.Item?.MarkPersisted();
        return result;
    }

    public static async Task<DB.Result<GroupRecord>> GetAll()
    {
        var result = await DB.QueryListAsync<GroupRecord>(
            "SELECT * FROM sonex.v_group_permissions;").ConfigureAwait(false);

        foreach (var item in result.Items)
            item.MarkPersisted();

        return result;
    }

    public static Task<DB.SingleResult<int>> Create(string name, string description)
    {
        return DB.QuerySingleAsync<int>(
            "SELECT sonex.groups_create(@GroupName, @Description); ",
            new
            {
                GroupName = name,
                Description = description
            });
    }

    public async Task<DB.SingleResult<bool>> Save()
    {
        var originalName = string.IsNullOrWhiteSpace(_originalName)
            ? Name
            : _originalName;

        var result = await DB.QuerySingleAsync<bool>(
            "SELECT sonex.groups_update(@GroupName, @NewGroupName, @Description);",
            new
            {
                GroupName = originalName,
                NewGroupName = Name,
                Description
            }).ConfigureAwait(false);

        if (result.Success)
            _originalName = Name;

        return result;
    }

    public Task<DB.SingleResult<bool>> Delete()
    {
        return DB.QuerySingleAsync<bool>(
            "SELECT sonex.groups_delete(@GroupName); ",
            new
            {
                GroupName = Name
            });
    }

    public Task<DB.SingleResult<bool>> AddPermission(string permission)
    {
        return DB.QuerySingleAsync<bool>(
            "SELECT sonex.groups_permissions_add(@GroupName, @Permission);",
            new
            {
                GroupName = Name,
                Permission = permission
            });
    }

    public Task<DB.SingleResult<bool>> RemovePermission(string permission)
    {
        return DB.QuerySingleAsync<bool>(
            "SELECT sonex.groups_permissions_remove(@GroupName, @Permission);",
            new
            {
                GroupName = Name,
                Permission = permission
            });
    }

    private void MarkPersisted()
    {
        _originalName = Name;
    }
}