using FieldLogger.Models;
using SQLite;

namespace FieldLogger.Services.Data;

/// <summary>Local SQLite store for jobs and logged points.</summary>
public sealed class AppDatabase
{
    private readonly Lazy<Task<SQLiteAsyncConnection>> _connection;

    public AppDatabase()
    {
        _connection = new Lazy<Task<SQLiteAsyncConnection>>(async () =>
        {
            var path = Path.Combine(FileSystem.AppDataDirectory, "fieldlogger.db3");
            var db = new SQLiteAsyncConnection(path,
                SQLiteOpenFlags.ReadWrite | SQLiteOpenFlags.Create | SQLiteOpenFlags.SharedCache);
            await db.CreateTableAsync<Job>();
            await db.CreateTableAsync<LoggedPoint>();
            return db;
        });
    }

    private Task<SQLiteAsyncConnection> Db => _connection.Value;

    // ---- Jobs ----

    public async Task<List<Job>> GetJobsAsync()
    {
        var db = await Db;
        return await db.Table<Job>().OrderByDescending(j => j.CreatedUtc).ToListAsync();
    }

    public async Task<Job?> GetJobAsync(int id)
    {
        var db = await Db;
        return await db.Table<Job>().Where(j => j.Id == id).FirstOrDefaultAsync();
    }

    public async Task<Job> CreateJobAsync(string name, string notes = "")
    {
        var db = await Db;
        var job = new Job { Name = name, Notes = notes };
        await db.InsertAsync(job);
        return job;
    }

    public async Task UpdateJobAsync(Job job)
    {
        var db = await Db;
        await db.UpdateAsync(job);
    }

    public async Task DeleteJobAsync(int jobId)
    {
        var db = await Db;
        await db.Table<LoggedPoint>().DeleteAsync(p => p.JobId == jobId);
        await db.DeleteAsync<Job>(jobId);
    }

    // ---- Points ----

    public async Task<int> AddPointAsync(LoggedPoint point)
    {
        var db = await Db;
        await db.InsertAsync(point);
        return point.Id;
    }

    public async Task<List<LoggedPoint>> GetPointsAsync(int jobId)
    {
        var db = await Db;
        return await db.Table<LoggedPoint>()
            .Where(p => p.JobId == jobId)
            .OrderBy(p => p.TimestampUtc)
            .ToListAsync();
    }

    public async Task<List<LoggedPoint>> GetUnsyncedPointsAsync()
    {
        var db = await Db;
        return await db.Table<LoggedPoint>()
            .Where(point => !point.Synced)
            .OrderBy(point => point.TimestampUtc)
            .ToListAsync();
    }

    public async Task<LoggedPoint?> GetPointBySyncIdAsync(string syncPointId)
    {
        var db = await Db;
        return await db.Table<LoggedPoint>()
            .Where(point => point.SyncPointId == syncPointId)
            .FirstOrDefaultAsync();
    }

    public async Task<int> GetPointCountAsync(int jobId)
    {
        var db = await Db;
        return await db.Table<LoggedPoint>().Where(p => p.JobId == jobId).CountAsync();
    }

    public async Task DeletePointAsync(int pointId)
    {
        var db = await Db;
        await db.DeleteAsync<LoggedPoint>(pointId);
    }

    public async Task UpdatePointAsync(LoggedPoint point)
    {
        var db = await Db;
        await db.UpdateAsync(point);
    }

    public async Task MarkPointSyncedAsync(string syncPointId)
    {
        var db = await Db;
        await db.ExecuteAsync(
            "UPDATE points SET Synced = 1, SyncError = NULL WHERE SyncPointId = ?",
            syncPointId);
    }

    public async Task MarkPointSyncErrorAsync(string syncPointId, string reasonCode)
    {
        var db = await Db;
        await db.ExecuteAsync(
            "UPDATE points SET Synced = 0, SyncError = ? WHERE SyncPointId = ?",
            reasonCode,
            syncPointId);
    }
}