using SteUp.Shared.Core.Dto;
using SteUp.Shared.Core.Helpers;
using SteUp.Shared.Core.Interface.System;

namespace SteUp.Maui.Core.Services;

public class AttachedService : IAttachedService
{
    private static string AttachedRoot =>
        Path.Combine(FileSystem.CacheDirectory, "attached");

    public async Task<AttachedDto?> SelectImageFromCamera()
    {
        var cameraPerm = await Permissions.RequestAsync<Permissions.Camera>();
        var storagePerm = await Permissions.RequestAsync<Permissions.StorageWrite>();

        if (cameraPerm != PermissionStatus.Granted || storagePerm != PermissionStatus.Granted)
            return null;

        FileResult? result;

        try
        {
            result = await MediaPicker.Default.CapturePhotoAsync();
            result?.FileName = $"img_{DateTime.Now:ddMMyyy_hhmmss}{result.FileName[result.FileName.IndexOf('.')..]}";
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Errore cattura foto: {ex.Message}");
            SentrySdk.CaptureException(ex);
            return null;
        }

        return result is null ? null : await ConvertToDto(result, AttachedDto.TypeAttached.Image);
    }

    public async Task<List<AttachedDto>?> SelectImageFromGallery()
    {
        List<FileResult>? resultList;
        var storagePerm = await Permissions.RequestAsync<Permissions.StorageRead>();
        if (storagePerm != PermissionStatus.Granted)
            return null;

        try
        {
            resultList = await MediaPicker.Default.PickPhotosAsync();
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Errore selezione galleria: {ex.Message}");
            SentrySdk.CaptureException(ex);
            return null;
        }

        if (resultList.IsNullOrEmpty()) return null;

        List<AttachedDto> returnList = [];
        foreach (var fileResult in resultList)
        {
            returnList.Add(await ConvertToDto(fileResult, AttachedDto.TypeAttached.Image));
        }

        return returnList;
    }

    private static async Task<AttachedDto> ConvertToDto(FileResult file, AttachedDto.TypeAttached type)
    {
        var stream = await file.OpenReadAsync();
        using var ms = new MemoryStream();
        await stream.CopyToAsync(ms);

        return new AttachedDto
        {
            Name = file.FileName,
            Path = file.FullPath,
            MimeType = file.ContentType,
            DimensionBytes = ms.Length,
            FileBytes = ms.ToArray(),
            Type = type
        };
    }

    public async Task<string> SaveToTempStorage(Stream file, string fileName, CancellationToken ct = default)
    {
        ArgumentNullException.ThrowIfNull(file);

        if (file.CanSeek)
            file.Position = 0;

        fileName = Path.GetFileName(fileName);

        var dir = FileSystem.CacheDirectory;
        var filePath = Path.Combine(dir, fileName);

        await using var fileStream = File.Create(filePath);
        await file.CopyToAsync(fileStream, ct);

        return filePath;
    }

    public Task CleanTempStorageAsync(CancellationToken ct = default)
    {
        return Task.Run(() =>
        {
            if (Directory.Exists(AttachedRoot))
                Directory.Delete(AttachedRoot, true);
        }, ct);
    }

    public Task OpenFile(string fileName, string filePath)
    {
#if IOS
        throw new NotImplementedException();
#else
        return Launcher.OpenAsync(new OpenFileRequest
        {
            Title = "Apri file",
            File = new ReadOnlyFile(filePath)
        });
#endif
    }

    public async Task<(string originalUrl, string thumbUrl)> SaveAndCreateThumbAsync(
        byte[] bytes, string fileName, CancellationToken ct = default)
    {
        Directory.CreateDirectory(AttachedRoot);

        var id = Guid.NewGuid().ToString("N");
        var safeName = SanitizeFileName(fileName);

        var originalFile = $"{id}_{safeName}";
        var thumbFile = $"{id}_thumb.jpg";

        var originalPath = Path.Combine(AttachedRoot, originalFile);
        await File.WriteAllBytesAsync(originalPath, bytes, ct);

        var thumbPath = Path.Combine(AttachedRoot, thumbFile);
        await ImageThumb.CreateThumbnailAsync(originalPath, thumbPath, maxSide: 320, quality: 70, ct);

        return ($"https://localfiles/attached/{originalFile}",
            $"https://localfiles/attached/{thumbFile}");
    }

    private static string SanitizeFileName(string fileName)
    {
        var name = Path.GetFileName(fileName);
        return Path.GetInvalidFileNameChars().Aggregate(name, (current, c) => current.Replace(c, '_'));
    }
}