using Dpz.Core.Infrastructure;
using Dpz.Core.Infrastructure.PublicStruct;
using Dpz.Core.Shard.Service;
using FluentFTP;
using Microsoft.Extensions.Logging;

namespace Dpz.Core.Service.ObjectStorage.Services.Impl;

public class ObjectStorageService(
    UpyunOperator upyunOperator,
    HttpClient httpClient,
    ILogger<ObjectStorageService> logger,
    IFtpLogger ftpLogger,
    ParallelChunkBreakpointUpload<UpyunOperator> parallelChunkBreakpointUpload,
    UpyunUpload upyunUpload
) : IObjectStorageOperation
{
    private const string FtpHost = "v0.ftp.upyun.com";

    public string Bucket => upyunOperator.Bucket ?? throw new BusinessException("Bucket is null");

    public async Task<UploadResult> UploadAsync(
        Stream stream,
        ICollection<string> path,
        string filename,
        CancellationToken cancellationToken = default
    )
    {
        return await UploadAsync(
            path,
            filename,
            () => new StreamContent(stream),
            cancellationToken: cancellationToken
        );
    }

    private async Task<UploadResult> UploadAsync(
        IEnumerable<string> path,
        string filename,
        Func<HttpContent> setContent,
        string? contentMd5 = null,
        CancellationToken cancellationToken = default
    )
    {
        if (string.IsNullOrEmpty(filename))
        {
            throw new ArgumentNullException(nameof(filename));
        }
        var pathList = path.ToList();
        pathList.Add(filename);

        return await UploadAsync(pathList, setContent, contentMd5, cancellationToken);
    }

    private async Task<UploadResult> UploadAsync(
        ICollection<string> pathToFile,
        Func<HttpContent> setContent,
        string? contentMd5 = null,
        CancellationToken cancellationToken = default
    )
    {
        return await upyunUpload.UploadAsync(
            pathToFile,
            setContent,
            upyunOperator,
            contentMd5,
            cancellationToken
        );
    }

    public async Task<FileAddress?> UploadFileAsync(
        CloudFile file,
        CancellationToken cancellationToken = default
    )
    {
        return await parallelChunkBreakpointUpload.UploadFileAsync(
            file,
            UploadAsync,
            cancellationToken: cancellationToken
        );
    }

    public async Task<UploadResult> UploadAsync(
        byte[] bytes,
        ICollection<string> path,
        string filename,
        CancellationToken cancellationToken = default
    )
    {
        return await UploadAsync(
            path,
            filename,
            () => new ByteArrayContent(bytes),
            cancellationToken: cancellationToken
        );
    }

    public async Task<Stream> DownloadAsync(
        string pathToFile,
        CancellationToken cancellationToken = default
    )
    {
        var request = new HttpRequestMessage(HttpMethod.Get, $"/{Bucket}/{pathToFile}")
        {
            Version = new Version(2, 0),
        };
        await request.SignatureAsync(upyunOperator, cancellationToken: cancellationToken);
        var response = await httpClient.SendAsync(request, cancellationToken);
        if (!response.IsSuccessStatusCode)
        {
            logger.LogError("download fail,status code:{StatusCode}", response.StatusCode);
            throw new BusinessException(
                $"download fail,response status code:{response.StatusCode}"
            );
        }

        var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
        return stream;
    }

    public async Task SaveAsAsync(
        string pathToFile,
        string path,
        CancellationToken cancellationToken = default
    )
    {
        if (string.IsNullOrEmpty(pathToFile))
        {
            throw new ArgumentNullException(nameof(pathToFile));
        }

        if (string.IsNullOrEmpty(path))
        {
            throw new ArgumentNullException(nameof(path));
        }

        var stream = await DownloadAsync(pathToFile, cancellationToken);
        await using var fileStream = new FileStream(path, FileMode.Create, FileAccess.Write);
        await stream.CopyToAsync(fileStream, cancellationToken);
        await fileStream.FlushAsync(cancellationToken);
    }

    public async Task DeleteAsync(string pathToFile, CancellationToken cancellationToken = default)
    {
        if (string.IsNullOrEmpty(pathToFile))
        {
            throw new ArgumentNullException(nameof(pathToFile));
        }
        if (pathToFile.StartsWith("http", StringComparison.OrdinalIgnoreCase))
        {
            pathToFile = pathToFile.Replace(
                upyunOperator.Host
                    ?? throw new BusinessException(
                        "configuration upyun operator host value is null"
                    ),
                ""
            );
        }
        else
        {
            pathToFile = !pathToFile.StartsWith('/') ? $"/{pathToFile}" : pathToFile;
        }

        var request = new HttpRequestMessage(HttpMethod.Delete, $"/{Bucket}{pathToFile}")
        {
            Version = new Version(2, 0),
        };
        await request.SignatureAsync(upyunOperator, cancellationToken: cancellationToken);
        var response = await httpClient.SendAsync(request, cancellationToken);
        if (!response.IsSuccessStatusCode)
        {
            logger.LogError("delete fail,status code:{StatusCode}", response.StatusCode);
        }
    }

    public async Task<IList<FolderResult>> GetFolderListAsync(
        string path,
        CancellationToken cancellationToken = default
    )
    {
        if (path == null)
        {
            throw new ArgumentNullException(nameof(path));
        }

        try
        {
            await using var client = new AsyncFtpClient(
                FtpHost,
                $"{upyunOperator.Operator}/{upyunOperator.Bucket}",
                upyunOperator.Password,
                logger: ftpLogger
            );

            await client.Connect(cancellationToken);
            //await client.AutoConnectAsync();

            var list = new List<FolderResult>();
            foreach (var item in await client.GetListing(path, cancellationToken))
            {
                var result = new FolderResult { LastUpdateTime = item.Modified, Name = item.Name };
                if (item.Type == FtpObjectType.Directory)
                {
                    result.FileType = FileType.Directory;
                }
                else
                {
                    result.FileType = FileType.File;
                    result.Size = await client.GetFileSize(item.FullName, token: cancellationToken);
                }

                list.Add(result);
            }

            await client.Disconnect(cancellationToken);
            return list;
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "get folder list fail");
            return new List<FolderResult>();
        }
    }

    public async Task<FileInformation> GetFileInformationAsync(
        string pathToFile,
        CancellationToken cancellationToken = default
    )
    {
        if (string.IsNullOrEmpty(pathToFile))
        {
            throw new ArgumentNullException(nameof(pathToFile));
        }

        pathToFile = !pathToFile.StartsWith('/') ? $"/{pathToFile}" : pathToFile;

        var request = new HttpRequestMessage(HttpMethod.Head, $"/{Bucket}{pathToFile}")
        {
            Version = new Version(2, 0),
        };
        await request.SignatureAsync(upyunOperator, cancellationToken: cancellationToken);
        var response = await httpClient.SendAsync(request, cancellationToken);
        if (!response.IsSuccessStatusCode)
        {
            logger.LogError("delete fail,status code:{StatusCode}", response.StatusCode);
            throw new BusinessException($"delete fail,response status code:{response.StatusCode}");
        }

        // response.Headers.Contains("x-upyun-frames")
        //     ? response.Headers.GetValues("x-upyun-file-size").FirstOrDefault() ?? "0"
        //     : "0";
        response.Headers.TryGetValues("x-upyun-file-size", out var size);
        long.TryParse(size?.FirstOrDefault() ?? "0", out var length);

        response.Headers.TryGetValues("x-upyun-file-date", out var date);

        long.TryParse(date?.FirstOrDefault() ?? "0", out var timespan);

        var dateTime = timespan.ToDateTime();

        response.Headers.TryGetValues("Content-Md5", out var md5);

        var information = new FileInformation
        {
            Length = length,
            Md5 = md5?.FirstOrDefault() ?? "",
            UploadTime = dateTime,
        };

        return information;
    }
}