const minioClient = require('./minio')
const fs = require('fs')

// Ensure buckets exist in MinIO
const ensureBucketsExist = async (bucketNames = ['temp', 'properties', 'documents']) => {
    for (const bucketName of bucketNames) {
        try {
            const exists = await minioClient.bucketExists(bucketName).catch(() => false)
            if (!exists) {
                await minioClient.makeBucket(bucketName, process.env.AWS_REGION || 'us-east-1')
                console.log(`MinIO bucket "${bucketName}" created successfully.`)
            }
        } catch (err) {
            console.error(`Error ensuring MinIO bucket "${bucketName}" exists:`, err.message)
        }
    }
}

// Upload File to s3 bucket
exports.uploadObject = async (file, bucketName) => {
    const bucketExists = await minioClient.bucketExists(bucketName).catch(() => false)
    if (!bucketExists) {
        await minioClient.makeBucket(bucketName, process.env.AWS_REGION || 'us-east-1')
    }

    const fileStream = fs.createReadStream(file.path)

    const uploadedFile = await minioClient.putObject(bucketName, `${file.filename}-${file.originalName}`, fileStream)

    const protocol = process.env.AWS_USE_SSL === 'true' ? 'https://' : 'http://'
    const endpoint = process.env.AWS_ENDPOINT || 'localhost'
    const hostPort = (endpoint.includes(':') || !process.env.AWS_PORT) ? endpoint : `${endpoint}:${process.env.AWS_PORT}`
    const fullHost = hostPort.startsWith('http://') || hostPort.startsWith('https://') ? hostPort : `${protocol}${hostPort}`

    uploadedFile.fileURL = fullHost.replace(/\/$/, '') + '/' + bucketName + '/' + file.filename + '-' + file.originalName
    uploadedFile.fileName = file.filename + '-' + file.originalName
    uploadedFile.fileEndpoint = process.env.AWS_ENDPOINT

    return uploadedFile
}

exports.listOfObjects = (bucketName) => {
    return new Promise((resolve, reject) => {
        let objects = []

        const stream = minioClient.listObjectsV2(bucketName, '', true)

        stream.on('data', (obj) => {
            objects.push(obj)
        })

        stream.on('error', (err) => {
            reject(err)
        })

        stream.on('end', () => {
            resolve(objects)
        })
    })
}

exports.signedUrl = (bucketName, fileName) => {
    return minioClient.presignedUrl('GET', bucketName, fileName, 60 * 60)
}

exports.deleteObject = (fileName, bucketName) => {
    return minioClient.removeObject(bucketName, fileName)
}

exports.copyObject = async (targetBucket, fileName, sourceBucketAndFile) => {
    const bucketExists = await minioClient.bucketExists(targetBucket).catch(() => false)
    if (!bucketExists) {
        await minioClient.makeBucket(targetBucket, process.env.AWS_REGION || 'us-east-1')
    }
    const conds = minioClient.CopyConditions ? new minioClient.CopyConditions() : null
    return minioClient.copyObject(targetBucket, fileName, sourceBucketAndFile, conds)
}

exports.removeObject = (bucketName, fileName) => {
    return minioClient.removeObject(bucketName, fileName)
}

exports.ensureBucketsExist = ensureBucketsExist
exports.minioClient = minioClient