using Dpz.Core.Backup;
using Dpz.Core.EnumLibrary;
using Dpz.Core.Infrastructure;
using Dpz.Core.Infrastructure.Entity;
using Dpz.Core.Public.Entity;
using Dpz.Core.Public.ViewModel;
using Dpz.Core.Service.ObjectStorage.Services;
using Dpz.Core.Service.RepositoryService;
using Dpz.Core.Shard.Service;
using MongoDB.Bson.Serialization;
using MongoDB.Driver;

namespace Dpz.Core.Web.Jobs.Hangfire;

public class BackupActivator(
    IBackupService backupService,
    IBackupRecordService backupRecordService,
    IConfiguration configuration,
    ISafeFileService safeFileService,
    ILogger<BackupActivator> logger
)
{
    public async Task BackupAsync()
    {
        var filter = new Dictionary<string, string>
        {
            {
                nameof(AccountToken),
                SerializerFilterDocument(
                    new ExpressionFilterDefinition<AccountToken>(x =>
                        x.RefreshTokenExpiryTime > DateTime.Now
                    )
                )
            },
            {
                nameof(WaitExecution),
                SerializerFilterDocument(
                    new ExpressionFilterDefinition<WaitExecution>(x =>
                        x.Status != ExecuteStatus.ExecuteComplete
                    )
                )
            },
        };

        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 fileName = Path.GetFileName(result.BackupPath);
        var date = DateTime.Now;
        List<string> pathToFile =
        [
            "backup",
            date.Year.ToString(),
            date.Month.ToString(),
            $"{fileName}",
        ];
#if DEBUG
        pathToFile.Insert(0, "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");
        }

        return new VmBackupRecord
        {
            Filename = string.Join('/', pathToFile),
            BackupTime = DateTime.Now,
            Database = result.Database,
            BackupPassword = result.ZipPassword,
        };
    }
}