//CONTROLLER
@RequestMapping(method = [(RequestMethod.GET)])
    fun download(@PathVariable("bucketname") bucketName: String,
                 @PathVariable("objectname") objectName: String,
                 @RequestHeader("Range") range: String,
                 request: HttpServletRequest,
                 response: HttpServletResponse): ResponseEntity<Any>{
        return try{

            var getAllParts = false
            if(range == ""){
                getAllParts = true
            }
            val pattern = Pattern.compile("(-?[0-9]*)-(-?[0-9]*)")
            val matcher = pattern.matcher(range)
            matcher.find()

            val from = matcher.group(1).toInt()

            var to = 0
            to = if(matcher.group(2) == ""){
                -1
            }else{
                matcher.group(2).toInt()
            }

            objectStorageService.download(bucketName,objectName,from,to,response,getAllParts)
            ResponseEntity.ok().build()
        }
        catch (e: Exception){
            ResponseEntity.badRequest().build()
        }

// SERVICE
@Transactional
    fun download(bucketName: String,objectName: String,from: Int,to: Int,response: HttpServletResponse,getAllParts: Boolean){

        val bucket = bucketRepository.findByName(bucketName) ?: throw Exception("Bucket Doesn't Exist")
        val obj = objectStorageRepository.findOneByBucketAndName(bucket,objectName) ?: throw Exception("Object Doesn't Exist")


        if(!obj.complete){
            throw Exception("Object is not completed.")
        }

        val allParts = partObjectRepository.findAllByObjectStorageOrderByPartNumberAsc(obj)
        val target = response.outputStream
        val baOutputStream = ByteArrayOutputStream()
        var totalSizeRead = 0
        for (p in allParts){
            val fileInputStream = File(p.location).inputStream()
            totalSizeRead += baOutputStream.write(fileInputStream)
            fileInputStream.close()
        }

//        println(obj.totalSize)
//        println(totalSizeRead)

        val inputStream = baOutputStream.toInputStream()

        if(getAllParts){
//            Write all parts to response
            target.write(inputStream.readBytes())
        }else{

            var newTo = to
            if (newTo < 0){
                newTo = totalSizeRead
            }

            val sizeNeeded = newTo - from
            inputStream.skip(from.toLong())

//            var ba = ByteArray(sizeNeeded)
//            inputStream.read(ba)
//            target.write(ba)

//            val bounded = BoundedInputStream(inputStream,from.toLong()+sizeNeeded.toLong())

            for(i in 1..sizeNeeded){
                target.write(inputStream.read())
            }
//            target.write(bounded.readBytes())
        }


        response.setHeader("eTag", obj.objectETag)

    }