using Dpz.Core.Backup;
using Dpz.Core.Entity.Base;
using Dpz.Core.Infrastructure;
using Dpz.Core.Public.Entity;
using Dpz.Core.Public.ViewModel;
using Dpz.Core.Service.RepositoryService;
using Hangfire;
using JetBrains.Annotations;
using MongoDB.Bson.Serialization;
using MongoDB.Driver;

namespace Dpz.Core.Web.Jobs.Hangfire;

[UsedImplicitly]
public class BackupActivator(
    IBackupService backupService,
    IBackupRecordService backupRecordService,
    IConfiguration configuration,
    //ISafeFileService safeFileService,
    ILogger<BackupActivator> logger
) : JobActivator
{
    [ProlongExpirationTime]
    public async Task BackupAsync()
    {
        var filter = new Dictionary<string, string>
        {
            {
                nameof(MessageOutboxRecord),
                SerializerFilterDocument(
                    new ExpressionFilterDefinition<MessageOutboxRecord>(x =>
                        x.Status != OutboxMessageStatus.Consumed
                    )
                )
            },
        };

        try
        {
            await BackupMainAsync("mongodb", filter);
            await BackupMainAsync("AgileConfig");
        }
        catch (Exception e)
        {
            logger.LogError(e, "backup fail");
        }
    }

    private static string SerializerFilterDocument<T>(FilterDefinition<T> filter)
        where T : IBaseEntity
    {
        var serializerRegistry = BsonSerializer.SerializerRegistry;
        var documentSerializer = serializerRegistry.GetSerializer<T>();

        var serializerArgs = new RenderArgs<T>(documentSerializer, serializerRegistry);
        var result = filter.Render(serializerArgs);

        return result.ToString();
    }

    private async Task BackupMainAsync(
        string connectionStringName,
        Dictionary<string, string>? filter = null
    )
    {
        logger.LogInformation("Start backing up database: {Database}", connectionStringName);
        var connectionString = configuration.GetConnectionString(connectionStringName);
        backupService.UploadAsync = UploadAsync;
        var backupRecord = await backupService.BackupAsync(connectionString, filter);
        await backupRecordService.AddRecordAsync(backupRecord);
        logger.LogInformation("Database: {Database} backup complete", connectionStringName);
    }

    private async Task<VmBackupRecord?> UploadAsync(BackupResult result)
    {
        if (string.IsNullOrEmpty(result.BackupPath))
        {
            throw new BusinessException("backup path is null");
        }

        if (!File.Exists(result.BackupPath))
        {
            throw new BusinessException("backup file not exist");
        }
        var backupRootPath = configuration.GetValue<string>("BackupRootPath");
        if (string.IsNullOrEmpty(backupRootPath) || !Directory.Exists(backupRootPath))
        {
            throw new BusinessException("backup root path is null");
        }

        var date = DateTime.Now;
        var backupPath = new List<string> { "db", date.Year.ToString(), date.Month.ToString() };
        var fileName = Path.GetFileName(result.BackupPath);
#if DEBUG
        backupPath.Insert(1, "Test");
#endif
        // var cloudFile = new CloudFile
        // {
        //     PathToFile = pathToFile,
        //     Stream = new FileStream(
        //         result.BackupPath,
        //         FileMode.Open,
        //         FileAccess.Read,
        //         FileShare.Read,
        //         1 << 12
        //     ),
        // };
        // var address = await safeFileService.UploadFileForFtpAsync(cloudFile);
        // if (address == null)
        // {
        //     throw new BusinessException("upload backup file fail");
        // }

        var backupPathDir = Path.Combine(backupRootPath, Path.Combine(backupPath.ToArray()));
        var destination = Path.Combine(backupPathDir, fileName);
        try
        {
            if (!Directory.Exists(backupPathDir))
            {
                Directory.CreateDirectory(backupPathDir);
            }
            destination = Path.Combine(backupPathDir, fileName);
            File.Move(result.BackupPath, destination);
            await using var writer = File.CreateText(destination + "__password.txt");
            await writer.WriteAsync(result.ZipPassword);
            await writer.FlushAsync();
            writer.Close();
        }
        catch (Exception e)
        {
            logger.LogError(
                e,
                "move backup file fail, source: {Source}, destination: {Destination}",
                result.BackupPath,
                destination
            );
            throw;
        }

        return new VmBackupRecord
        {
            Filename = destination,
            BackupTime = DateTime.Now,
            Database = result.Database,
            BackupPassword = result.ZipPassword,
        };
    }
}