Data-Coupler/DataConnection/DB/FoxProDatabaseManager.cs

using System.Linq.Expressions;
using DataConnection.DB.FoxPro;
using DataConnection.Interfaces;

namespace DataConnection.DB;

/// <summary>
/// Database manager per sorgenti <b>Visual FoxPro / dBase</b> in modalità completamente
/// <b>managed</b>: legge direttamente i file <c>.dbf</c>/<c>.fpt</c>/<c>.dbc</c> tramite la
/// libreria <c>DbfDataReader</c>, senza alcun provider OLE DB/ODBC e funzionando a 64-bit.
///
/// <para><b>Sola lettura</b>: FoxPro è supportato come <i>sorgente</i> dati. Le operazioni di
/// scrittura lanciano <see cref="NotSupportedException"/> — scrivere nei <c>.dbf</c> rischierebbe
/// di corrompere indici <c>.cdx</c> e memo <c>.fpt</c> dei gestionali legacy.</para>
///
/// La "connection string" è semplicemente un percorso: un file <c>.dbc</c> (container) oppure
/// una cartella di tabelle libere <c>.dbf</c>. Vedi <see cref="FoxProReader.Resolve"/>.
/// </summary>
public class FoxProDatabaseManager : IDatabaseManager
{
    private const string ReadOnlyMessage =
        "Visual FoxPro è supportato in sola lettura (sorgente dati). La scrittura sui file .dbf non è disponibile.";

    private readonly FoxProConnectionInfo _info;

    public FoxProDatabaseManager(string connectionString)
    {
        _info = FoxProReader.Resolve(connectionString);
    }

    public async Task<bool> TestConnectionAsync()
    {
        try
        {
            await Task.Run(() =>
            {
                FoxProReader.EnsureReachable(_info);
                // Forza la lettura dell'elenco tabelle: conferma che cartella/.dbc siano leggibili.
                _ = FoxProReader.GetTableNames(_info);
            });
            return true;
        }
        catch
        {
            return false;
        }
    }

    public Task<IEnumerable<string>> GetTableNamesAsync()
        => Task.Run(() => (IEnumerable<string>)FoxProReader.GetTableNames(_info));

    public Task<IEnumerable<DbColumnInfo>> GetTableSchemaAsync(string tableName)
        => Task.Run(() => (IEnumerable<DbColumnInfo>)FoxProReader.GetTableColumns(_info, tableName));

    public Task<IDictionary<string, IEnumerable<DbColumnInfo>>> GetDatabaseSchemaAsync()
    {
        return Task.Run(() =>
        {
            var result = new Dictionary<string, IEnumerable<DbColumnInfo>>(StringComparer.OrdinalIgnoreCase);
            foreach (var table in FoxProReader.GetTableNames(_info))
            {
                try
                {
                    var columns = FoxProReader.GetTableColumns(_info, table);
                    if (columns.Count > 0)
                        result[table] = columns;
                }
                catch (Exception ex)
                {
                    Console.WriteLine($"[FoxPro] Schema non leggibile per {table}: {ex.Message}");
                }
            }
            return (IDictionary<string, IEnumerable<DbColumnInfo>>)result;
        });
    }

    public Task<IEnumerable<Dictionary<string, object>>> GetAllRecordsAsync(string tableName)
        => Task.Run(() => (IEnumerable<Dictionary<string, object>>)FoxProReader.ReadRecords(_info, tableName).ToList());

    public Task<List<Dictionary<string, object>>> ExecuteRawQueryAsync(string sql, string databaseName = "", params object[] parameters)
    {
        return Task.Run(() =>
        {
            var parsed = FoxProReader.ParseSimpleSelect(sql);
            if (parsed == null)
                throw new NotSupportedException(
                    "Per le sorgenti FoxPro è supportato solo 'SELECT [TOP n] * FROM <tabella>'. " +
                    "Impossibile interpretare la query: " + sql);

            var (table, top) = parsed.Value;
            return FoxProReader.ReadRecords(_info, table, top).ToList();
        });
    }

    public Task<string?> GetPrimaryKeyFieldAsync(string tableName)
        // Le tabelle .dbf non espongono una PK affidabile: la chiave si seleziona nel coupler.
        => Task.FromResult<string?>(null);

    public Task<List<string>> GetAvailableDatabasesAsync()
        => Task.FromResult(new List<string> { _info.DisplayName });

    public Task ChangeDatabaseAsync(string databaseName)
    {
        // Sorgente file-based: il database è definito dal percorso. Nessun cambio a runtime.
        return Task.CompletedTask;
    }

    // ===== Operazioni non supportate (sola lettura) =====

    public Task<int> ExecuteCommandAsync(string sql, params object[] parameters)
        => throw new NotSupportedException(ReadOnlyMessage);

    public Task<bool> UpsertRecordAsync(string tableName, string keyField, object? keyValue, Dictionary<string, object?> record)
        => throw new NotSupportedException(ReadOnlyMessage);

    // ===== Operazioni LINQ/tipizzate non applicabili a una sorgente DBF =====

    public Task<IEnumerable<T>> GetAsync<T>(
        Expression<Func<T, bool>>? filter = null,
        Func<IQueryable<T>, IOrderedQueryable<T>>? orderBy = null,
        string includeProperties = "",
        int? skip = null,
        int? take = null) where T : class
        => throw new NotSupportedException("GetAsync<T> con LINQ non è supportato per FoxPro. Usare GetAllRecordsAsync.");

    public Task<T?> GetByIdAsync<T>(object id) where T : class
        => throw new NotSupportedException("GetByIdAsync<T> non è supportato per FoxPro.");

    public Task<IEnumerable<T>> ExecuteQueryAsync<T>(string sql, params object[] parameters) where T : class
        => throw new NotSupportedException("ExecuteQueryAsync<T> tipizzato non è supportato per FoxPro. Usare ExecuteRawQueryAsync.");

    public void Dispose()
    {
        // Nessuna risorsa persistente: ogni operazione apre/chiude i file.
        GC.SuppressFinalize(this);
    }
}